diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 00000000..e69de29b diff --git a/_articulation_vertex_detection_8hpp_source.html b/_articulation_vertex_detection_8hpp_source.html new file mode 100644 index 00000000..bc7c4c91 --- /dev/null +++ b/_articulation_vertex_detection_8hpp_source.html @@ -0,0 +1,281 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal/ArticulationVertexDetection.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ArticulationVertexDetection.hpp
+
+
+
1/*
+
2 * ArticulationVertexDetection.hpp
+
3 *
+
4 * Created on: Feb 17, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7#ifndef EGOA__ALGORITHMS__GRAPH_TRAVERSAL__ARTICULATION_VERTEX_DETECTION__HPP
+
8#define EGOA__ALGORITHMS__GRAPH_TRAVERSAL__ARTICULATION_VERTEX_DETECTION__HPP
+
9
+
10#include "Algorithms/GraphTraversal/DepthFirstSearch.hpp"
+
11
+
12namespace egoa {
+
13
+
24template< typename GraphType
+
25 , bool IsDirected = false >
+
+
26class ArticulationVertexDetection : public DepthFirstSearch<GraphType, IsDirected> {
+
27 using TTime = typename DepthFirstSearch<GraphType, IsDirected>::TTime;
+
28 public:
+
29 using TGraph = GraphType;
+
30 using TVertexId = typename TGraph::TVertexId;
+
31
+
32#pragma mark CONSTRUCTOR_AND_DESTRUCTOR
+
33 ArticulationVertexDetection ( TGraph const & graph, TVertexId source )
+
34 : DepthFirstSearch<TGraph, IsDirected> ( graph, source )
+
35 , timeOfOldestReachableAncestor_( graph.NumberOfVertices(), Const::NONE )
+
36 , isArticulationVertex_( graph.NumberOfVertices(), false )
+
37 , treeOutDegree_( std::vector<TVertexId>( graph.NumberOfVertices(), 0 ) )
+
38 {}
+
39
+
40 virtual ~ArticulationVertexDetection(){}
+
41
+
42#pragma mark GETTER_AND_SETTER
+
43 protected:
+
52 inline Types::count TreeOutDegree ( TVertexId const vertex ) const { return treeOutDegree_[vertex]; }
+
53 inline Types::count & TreeOutDegree ( TVertexId const vertex ) { return treeOutDegree_[vertex]; }
+
55
+
56 inline TTime & TimeOfOldestReachableAncestor( TVertexId vertex ) {
+
57 ESSENTIAL_ASSERT(vertex < timeOfOldestReachableAncestor_.size());
+
58 return timeOfOldestReachableAncestor_[vertex];
+
59 }
+
60
+
61#pragma mark FURTHER_PROCESSING
+
+
69 virtual inline void PreprocessingVertexWith ( TVertexId const vertex ) override
+
70 {
+
71 TimeOfOldestReachableAncestor( vertex ) = this->EntryTimeAt( vertex );
+
72 }
+
+
73
+
+
84 virtual inline void ProcessingEdgeWith ( TVertexId source
+
85 , TVertexId target
+
86 , Types::edgeId edgeId ) override
+
87 {
+
88 // Ignore edges that directly lead to the parent again.
+
89 if (target == this->ParentOf(source)) {
+
90 return;
+
91 }
+
92
+
93 DfsEdgeType edgeType = this->TypifyEdge ( source, target );
+
94
+
95 if ( edgeType == DfsEdgeType::tree ) {
+
96 ++TreeOutDegree ( source );
+
97 }
+
98 }
+
+
99
+
+
100 virtual inline void PostprocessingEdgeWith(TVertexId source,
+
101 TVertexId target,
+
102 Types::edgeId edgeId ) override
+
103 {
+
104 // Ignore edges that directly lead to the parent again.
+
105 if (target == this->ParentOf(source)) {
+
106 return;
+
107 }
+
108
+
109 TTime oldestTimeSeenAtTarget = TimeOfOldestReachableAncestor( target );
+
110 TTime & oldestTimeSeenAtSource = TimeOfOldestReachableAncestor( source );
+
111
+
112
+
113 if ( oldestTimeSeenAtTarget >= this->EntryTimeAt( source )
+
114 && !IsRoot( source ) ) {
+
115 // The source is at least as old as the oldest reachable vertex
+
116 // from the target. Therefore, the source is an articulation vertex.
+
117 isArticulationVertex_[source] = true;
+
118 }
+
119
+
120 if (oldestTimeSeenAtSource > oldestTimeSeenAtTarget) {
+
121 // Propagate the oldest vertex reached in the search.
+
122 oldestTimeSeenAtSource = oldestTimeSeenAtTarget;
+
123 }
+
124 }
+
+
125
+
+
131 virtual inline void PostprocessingVertexWith ( TVertexId vertexId ) override
+
132 {
+
133 if ( IsRoot( vertexId ) ) {
+
134 isArticulationVertex_[ vertexId ] = (TreeOutDegree( vertexId ) > 1);
+
135 }
+
136 }
+
+
137
+
138#pragma mark ARTICULATION_VERTEX_DETERMINATION
+
139 public:
+
+
152 inline bool IsRootArticulationVertexAt ( TVertexId const vertex ) const
+
153 {
+
154 if ( IsRoot ( vertex ) ) {
+
155 if ( TreeOutDegree ( vertex ) > 1 ) {
+
156 // root articulation point
+
157 return true;
+
158 }
+
159 }
+
160 return false;
+
161 }
+
+
162
+
+
174 inline bool IsParentArticulationVertexAt ( TVertexId const vertex ) const
+
175 {
+
176 if ( this->ParentOf ( vertex ) == OldestReachableAncestor ( vertex )
+
177 && !IsRoot ( this->ParentOf( vertex ) )
+
178 )
+
179 {
+
180 return true;
+
181 }
+
182 return false;
+
183 }
+
+
184
+
+
199 inline std::pair<bool,bool> IsBridgeArticulationVertexAt ( TVertexId const vertex ) const {
+
200 if ( vertex == OldestReachableAncestor ( vertex ) ) {
+
201 if ( TreeOutDegree ( vertex ) > 0 )
+
202 { // The vertex is not a leaf
+
203 return std::make_pair<bool,bool>(true,true);
+
204 }
+
205 // Only the parent is an articulation vertex
+
206 return std::make_pair<bool,bool>(true,false);
+
207 }
+
208 return std::make_pair<bool,bool>(false,false);
+
209 }
+
+
210
+
+
218 inline bool IsArticulationVertexAt( TVertexId const vertex ) const {
+
219 return isArticulationVertex_[vertex];
+
220 }
+
+
221
+
+
231 inline bool IsRoot ( TVertexId const vertex ) const
+
232 {
+
233 // if Const::NONE the parent of vertex represents a root
+
234 return this->ParentOf ( vertex ) == Const::NONE;
+
235 }
+
+
236
+
237#pragma mark MEMBERS
+
238 private:
+
239 std::vector<TTime> timeOfOldestReachableAncestor_;
+
240 std::vector<Types::count> treeOutDegree_;
+
241 std::vector<bool> isArticulationVertex_;
+
242};
+
+
243
+
244} // namespace egoa
+
245
+
246#endif // EGOA__ALGORITHMS__GRAPH_TRAVERSAL__ARTICULATION_VERTEX_DETECTION__HPP
+
egoa::ArticulationVertexDetection
Class to find articulation vertices.
Definition ArticulationVertexDetection.hpp:26
+
egoa::ArticulationVertexDetection::IsBridgeArticulationVertexAt
std::pair< bool, bool > IsBridgeArticulationVertexAt(TVertexId const vertex) const
Determines if vertex and thus, its parent is a bridge articulation vertex .
Definition ArticulationVertexDetection.hpp:199
+
egoa::ArticulationVertexDetection::IsRoot
bool IsRoot(TVertexId const vertex) const
Determines if vertex is a root.
Definition ArticulationVertexDetection.hpp:231
+
egoa::ArticulationVertexDetection::PostprocessingEdgeWith
virtual void PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) override
Post processing the edge with edgeId.
Definition ArticulationVertexDetection.hpp:100
+
egoa::ArticulationVertexDetection::PostprocessingVertexWith
virtual void PostprocessingVertexWith(TVertexId vertexId) override
Decide which vertices are articulation vertices.
Definition ArticulationVertexDetection.hpp:131
+
egoa::ArticulationVertexDetection::IsArticulationVertexAt
bool IsArticulationVertexAt(TVertexId const vertex) const
Whether the vertex is an articulation vertex.
Definition ArticulationVertexDetection.hpp:218
+
egoa::ArticulationVertexDetection::IsRootArticulationVertexAt
bool IsRootArticulationVertexAt(TVertexId const vertex) const
Determines if vertex is a root articulation vertex .
Definition ArticulationVertexDetection.hpp:152
+
egoa::ArticulationVertexDetection::PreprocessingVertexWith
virtual void PreprocessingVertexWith(TVertexId const vertex) override
Preprocessing vertex with vertexId.
Definition ArticulationVertexDetection.hpp:69
+
egoa::ArticulationVertexDetection::TreeOutDegree
Types::count TreeOutDegree(TVertexId const vertex) const
Accessors for the tree out degree.
Definition ArticulationVertexDetection.hpp:52
+ + +
egoa::ArticulationVertexDetection::IsParentArticulationVertexAt
bool IsParentArticulationVertexAt(TVertexId const vertex) const
Determines if vertex is a parent articulation vertex .
Definition ArticulationVertexDetection.hpp:174
+ +
egoa::ArticulationVertexDetection::ProcessingEdgeWith
virtual void ProcessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) override
Update the oldest reachable ancestor.
Definition ArticulationVertexDetection.hpp:84
+
egoa::DepthFirstSearch
Class for the Depth-First Search (DFS).
Definition DepthFirstSearch.hpp:35
+
egoa::DepthFirstSearch::TypifyEdge
DfsEdgeType TypifyEdge(TVertexId source, TVertexId target)
Determine DFS edge type.
Definition DepthFirstSearch.hpp:127
+
egoa::DepthFirstSearch::EntryTimeAt
TTime EntryTimeAt(TVertexId vertexId) const
{ function_description }
Definition DepthFirstSearch.hpp:188
+
egoa::Traversal::ParentOf
TVertexId & ParentOf(TVertexId vertexId)
Getter and setter for the parent relation.
Definition Traversal.hpp:152
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_assertions_8hpp_source.html b/_assertions_8hpp_source.html new file mode 100644 index 00000000..2169b452 --- /dev/null +++ b/_assertions_8hpp_source.html @@ -0,0 +1,168 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Exceptions/Assertions.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Assertions.hpp
+
+
+
1/*
+
2 * @file Assertions.hpp
+
3 * @brief If the @p EGOA_ENABLE_ASSERTION is enabled in the cmake setting
+
4 * both @p ESSENTIAL_ASSERT and @p USAGE_ASSERT throw asserts if
+
5 * needed, otherwise if @p EGOA_ENABLE_EXCEPTION_HANDLING is
+
6 * enabled in the cmake setting both methods throw exceptions.
+
7 *
+
8 * Operation | Effect
+
9 * ---------------------------------------------|-----------------------------
+
10 * @code ESSENTIAL_ASSERT ( false ); @endcode | Throws an essential assert. Essential asserts
+
11 * | show that a crucial invariant in the code is
+
12 * | violated. This is a hint of a programming mistake.
+
13 * @code USAGE_ASSERT ( false ); @endcode | Throws a usage assert. A usage assert shows
+
14 * | that the method is not used in a correct way,
+
15 * | e.g., incorrect parameter input. Take a look
+
16 * | at the precondition section of the comments.
+
17 *
+
18 * Created on: Feb 14, 2019
+
19 * Author: Franziska Wegner
+
20 */
+
21
+
22#ifndef EGOA__EXCEPTIONS__ASSERTIONS_HPP
+
23#define EGOA__EXCEPTIONS__ASSERTIONS_HPP
+
24
+
25#include <exception>
+
26#include <sstream>
+
27#include <iostream>
+
28
+
29#ifdef EGOA_ENABLE_ASSERTION
+
30 #define ESSENTIAL_ASSERT( expr ) \
+
31 if (!(expr)) \
+
32 { \
+
33 std::cerr << "ESSENTIAL assertion failed at " << __FILE__ \
+
34 << ":" << __LINE__; \
+
35 std::cerr << " inside " << __FUNCTION__; \
+
36 std::cerr << ".\n Condition: " << #expr; \
+
37 abort(); \
+
38 }
+
39
+
40 #define USAGE_ASSERT( expr ) \
+
41 if (!(expr)) \
+
42 { \
+
43 std::cerr << "USAGE assertion failed at " << __FILE__ \
+
44 << ":" << __LINE__; \
+
45 std::cerr << " inside " << __FUNCTION__; \
+
46 std::cerr << ".\n Condition: " << #expr; \
+
47 abort(); \
+
48 }
+
49#else // ifdef EGOA_ENABLE_ASSERTION
+
50#ifdef EGOA_ENABLE_EXCEPTION_HANDLING
+
51 #define ESSENTIAL_ASSERT( expr ) \
+
52 if (!(expr)) \
+
53 { \
+
54 std::stringstream message; \
+
55 message << "Essential exception at "<< __FILE__ \
+
56 << ":" << __LINE__ \
+
57 << " inside " << __FUNCTION__ \
+
58 << ".\n Condition: " << #expr; \
+
59 throw ( std::runtime_error ( message.str() ) ); \
+
60 }
+
61
+
62 #define USAGE_ASSERT( expr ) \
+
63 if (!(expr)) \
+
64 { \
+
65 std::stringstream message; \
+
66 message << "Usage exception at "<< __FILE__ \
+
67 << ":" << __LINE__ \
+
68 << " inside " << __FUNCTION__ \
+
69 << ".\n Condition: " << #expr; \
+
70 throw ( std::runtime_error( message.str() ) ); \
+
71 }
+
72#else // ifdef EGOA_ENABLE_EXCEPTION_HANDLING
+
73 #define ESSENTIAL_ASSERT( expr ) ( expr )
+
74 #define USAGE_ASSERT( expr ) ( expr )
+
75#endif // ifdef EGOA_ENABLE_EXCEPTION_HANDLING
+
76#endif // ifdef EGOA_ENABLE_ASSERTION
+
77
+
78#endif // EGOA__EXCEPTIONS__ASSERTIONS_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_auxiliary_2_types_8hpp_source.html b/_auxiliary_2_types_8hpp_source.html new file mode 100644 index 00000000..ffc9572c --- /dev/null +++ b/_auxiliary_2_types_8hpp_source.html @@ -0,0 +1,170 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/Types.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Types.hpp
+
+
+
1/*
+
2 * Types.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__AUXILIARY__TYPES_HPP
+
8#define EGOA__AUXILIARY__TYPES_HPP
+
9
+
10#include <QDebug>
+
11#include <QRegularExpression>
+
12#ifdef GUROBI_AVAILABLE
+
13 #include "gurobi_c++.h"
+
14#endif
+
15
+
16namespace egoa::Types {
+
17
+
18 // Integer Z
+
19 typedef int64_t integer;
+
20 typedef integer rcount;
+
21 typedef integer difference;
+
23 // Positive integer Z_{>=0}
+
24 // for uint64_t check: https://en.cppreference.com/w/cpp/types/integer
+
25 typedef uint64_t posInteger;
+
26 typedef uint8_t ubyte;
+
27 typedef posInteger largeNumber;
+
28 typedef posInteger count;
+
29 typedef posInteger index;
+
31 // Identifier
+
32 typedef index vertexId;
+
33 typedef index loadId;
+
34 typedef index generatorId;
+
35 typedef index edgeId;
+
36 typedef index labelId;
+
37 typedef index blockId;
+
39 // Real numbers R
+
40 typedef double real;
+
41 typedef long double largeReal;
+
43 // String
+
44 typedef std::string string;
+
45 typedef std::string name;
+
47 // Snapshots
+
48 typedef real generatorSnapshot;
+
49 typedef real loadSnapshot;
+
50 typedef real weightSnapshot;
+
51 typedef string timestampSnapshot;
+
63 inline real String2double( std::string str )
+
64 {
+
65 QRegularExpression rx("(^-?[0-9]?\\d*(\\.\\d+)?)"); // Filter numbers only
+
66 QRegularExpressionMatchIterator i = rx.globalMatch(QString::fromStdString(str));
+
67 QRegularExpressionMatch match = i.next();
+
68 QString t_string = match.captured(1);
+
69
+
70 // QString t_string(str.c_str());
+
71 bool ok; double number(0);
+
72 // QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
+
73 number = QString(t_string).toDouble(&ok); // ok == true, d == 1234.56
+
74 // if (!ok) {
+
75 // QLocale locale(QLocale::German); //QLocale::Catalan
+
76 // number = locale.toDouble(t_string);
+
77 // }
+
78 return number;
+
79 }
+
80
+
91 inline count String2integer( std::string str )
+
92 {
+
93 QRegularExpression rx("(^-?[0-9]?\\d*(\\.\\d+)?)"); // Filter numbers only
+
94 QRegularExpressionMatchIterator i = rx.globalMatch(QString::fromStdString(str));
+
95 QRegularExpressionMatch match = i.next();
+
96 QString t_string = match.captured(1);
+
97
+
98 // QString t_string(str.c_str());
+
99 bool ok; count number(0);
+
100 number = QString(t_string).toUInt(&ok);
+
101 return number;
+
102 }
+
103
+
104} // namespace egoa::Types
+
105
+
106#endif // EGOA__AUXILIARY__TYPES_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_auxiliary_8hpp_source.html b/_auxiliary_8hpp_source.html new file mode 100644 index 00000000..d37dddfe --- /dev/null +++ b/_auxiliary_8hpp_source.html @@ -0,0 +1,172 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/Auxiliary.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Auxiliary.hpp
+
+
+
1/*
+
2 * Auxiliary.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__AUXILIARY__AUXILIARY_HPP
+
9#define EGOA__AUXILIARY__AUXILIARY_HPP
+
10
+
11#include "Auxiliary/Constants.hpp"
+
12#include "Auxiliary/Types.hpp"
+
13
+
14#ifdef OPENMP_AVAILABLE
+
15 #include <omp.h>
+
16#endif // OPENMP_AVAILABLE
+
17
+
18namespace egoa::Auxiliary {
+
19
+
20#ifdef OPENMP_AVAILABLE
+
26 inline Types::count NumberOfThreads () { return omp_get_num_threads(); }
+
27
+
33 inline Types::count MaximumNumberOfThreads () { return omp_get_max_threads(); }
+
34
+
40 inline Types::count NumberOfProcessors () { return omp_get_num_procs(); }
+
41#else // OPENMP_AVAILABLE
+
47 inline Types::count NumberOfThreads () { return 1; }
+
48
+
54 inline Types::count MaximumNumberOfThreads () { return 1; }
+
55
+
61 inline Types::count NumberOfProcessors () { return 1; }
+
62#endif // OPENMP_AVAILABLE
+
63
+
66
+
89inline bool EQ (double a, double b, double absTol = Const::EPSILON, double relTol = Const::EPSILON)
+
90{
+
91 if ( fabs(a - b) <= absTol * std::max(1.0, ( relTol/absTol * std::max(fabs(a), fabs(b)) ) ) )
+
92 return true;
+
93 else
+
94 return false;
+
95}
+
97
+
100
+
106
+
+
109struct MatchPathSeparator
+
110{
+
111 bool operator()( char ch ) const
+
112 {
+
113 return ch == '/';
+
114 }
+
115};
+
+
116
+
123// struct MatchPathSeparator
+
124// {
+
125// bool operator()( char ch ) const
+
126// {
+
127// return ch == '\\' || ch == '/';
+
128// }
+
129// };
+
131
+
139inline Types::string Basename( Types::string const & pathname )
+
140{
+
141 return std::string(
+
142 std::find_if( pathname.rbegin(),
+
143 pathname.rend(),
+
144 MatchPathSeparator()
+
145 ).base(),
+
146 pathname.end() );
+
147}
+
148
+
156inline Types::string RemoveExtension( std::string const & filename )
+
157{
+
158 std::string::const_reverse_iterator pivot = std::find( filename.rbegin(), filename.rend(), '.' );
+
159 return pivot == filename.rend() ? filename : std::string( filename.begin(), pivot.base() - 1 );
+
160}
+
161
+
162} // namespace egoa::Auxiliary
+
163
+
164#endif // EGOA__AUXILIARY__AUXILIARY_HPP
+
egoa::Auxiliary::MatchPathSeparator
Path separator in UNIX systems.
Definition Auxiliary.hpp:110
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_betweenness_centrality_8hpp_source.html b/_betweenness_centrality_8hpp_source.html new file mode 100644 index 00000000..3f87a731 --- /dev/null +++ b/_betweenness_centrality_8hpp_source.html @@ -0,0 +1,411 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/Centralities/BetweennessCentrality.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BetweennessCentrality.hpp
+
+
+
1/*
+
2 * BetweennessCentrality.hpp
+
3 *
+
4 * Created on: Feb 26, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__CENTRALITY__BETWEENNESS_CENTRALITY_HPP
+
9#define EGOA__ALGORITHMS__CENTRALITY__BETWEENNESS_CENTRALITY_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif // OPENMP_AVAILABLE
+
14
+
15#include "Algorithms/PathFinding/DominatingThetaPath.hpp"
+
16#include "IO/Statistics/DtpRuntimeCollection.hpp"
+
17
+
18namespace egoa {
+
19
+
20enum class CentralityCounter {
+
21 counterAtEdges = 0,
+
22 counterAtVertices = 1
+
23};
+
24
+
62template< typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>
+
63 , Edges::ElectricalProperties >
+
64 , typename PathFindingAlgorithm = DominatingThetaPath<GraphType>
+
65 , typename MeasurementCollection = IO::DtpRuntimeCollection
+
66 , CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges >
+
+
67class BetweennessCentrality {
+
68 public:
+
69#pragma mark TYPE_ALIASING
+
70 // Graph specific types
+
71 using TGraph = GraphType;
+
72 using TVertex = typename TGraph::TVertex;
+
73 using TVertexId = typename TGraph::TVertexId;
+
74 using TEdge = typename TGraph::TEdge;
+
75 using TEdgeId = typename TGraph::TEdgeId;
+
77 using TAlgorithm = PathFindingAlgorithm;
+
78 using TMeasurementCollection = MeasurementCollection;
+
79 using TMeasurementRow = typename TMeasurementCollection::TRow;
+
81 protected:
+
82#ifdef OPENMP_AVAILABLE
+
83 using TAlgoHandling = std::vector<TAlgorithm>;
+
84 using TNumberOfPaths = std::vector<std::vector<Types::count>>;
+
85 using TRelativeNumberOfPaths = std::vector<std::vector<Types::real>>;
+
86#else
+
87 using TAlgoHandling = TAlgorithm;
+
88 using TNumberOfPaths = std::vector<Types::count>;
+
89 using TRelativeNumberOfPaths = std::vector<Types::real>;
+
90#endif
+
91 public:
+
94#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
95
+
+
101 BetweennessCentrality ( TGraph const & graph )
+
102 : countersSize_(0)
+
103 , graph_( graph )
+
104#if defined(OPENMP_AVAILABLE)
+
105 , algo_( omp_get_max_threads(), TAlgorithm( graph_ ) )
+
106#else
+
107 , algo_( graph_ )
+
108#endif
+
109 {}
+
+
110
+
114 ~BetweennessCentrality () {}
+
115
+
117
+
120#pragma mark EXECUTE_ALGORITHM
+
121
+
+
132 inline void Run ()
+
133 {
+
134 TNumberOfPaths numberOfPaths;
+
135 TRelativeNumberOfPaths relativeNumberOfPaths;
+
136
+
137 Clear ( numberOfPaths, relativeNumberOfPaths );
+
138
+
139 graph_.template for_all_vertex_identifiers<ExecutionPolicy::sequential> ( [ this
+
140 , & numberOfPaths
+
141 , & relativeNumberOfPaths ] ( TVertexId vertexId )
+
142 {
+
143#ifdef OPENMP_AVAILABLE
+
144 Algorithm()[omp_get_thread_num()].Clear();
+
145 Algorithm()[omp_get_thread_num()].Source( vertexId );
+
146 Algorithm()[omp_get_thread_num()].Run();
+
147 Algorithm()[omp_get_thread_num()].NumberOfLabels();
+
148 TotalNumberOfPaths( numberOfPaths, relativeNumberOfPaths );
+
149#ifdef EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY // COLLECT RUNTIME INFORMATION
+
150 #pragma omp critical
+
151 { // More information concerning standard container
+
152 // concurrency under "Thread safety":
+
153 // https://en.cppreference.com/w/cpp/container
+
154 Collection() += Algorithm()[omp_get_thread_num()].Statistic();
+
155 }
+
156#endif // EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
157
+
158// ################################################################################
+
159// ################################################################################
+
160// ################################################################################
+
161
+
162#else // OPENMP IS NOT AVAILABLE
+
163
+
164 Algorithm().Clear();
+
165 Algorithm().Source ( vertexId );
+
166 Algorithm().Run();
+
167 TotalNumberOfPaths ( numberOfPaths, relativeNumberOfPaths );
+
168
+
169#ifdef EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
170 Collection() += Algorithm().Statistic();
+
171#endif // EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
172#endif // OPENMP_AVAILABLE
+
173 });
+
174 JoinThreadBasedResults ( numberOfPaths
+
175 , relativeNumberOfPaths
+
176 , 1 / static_cast<Types::real>( graph_.NumberOfVertices() * ( graph_.NumberOfVertices() - 1 ) ) );
+
177 }
+
+
179
+
182#pragma mark GETTER_AND_SETTER
+
183
+
+
189 inline std::vector<Types::real> const & TotalRelativeNumberOfPaths () const
+
190 {
+
191 USAGE_ASSERT ( totalRelativeNumberOfPaths_.size() == countersSize_ );
+
192 return totalRelativeNumberOfPaths_;
+
193 }
+
+
194
+
+
200 inline std::vector<Types::count> const & TotalNumberOfPaths () const
+
201 {
+
202 USAGE_ASSERT ( totalNumberOfPaths_.size() == countersSize_ );
+
203 return totalNumberOfPaths_;
+
204 }
+
+
205
+
+
211 inline TAlgoHandling & Algorithm ()
+
212 {
+
213 return algo_;
+
214 }
+
+
215
+
+
221 inline TAlgoHandling const & Algorithm () const
+
222 {
+
223 return algo_;
+
224 }
+
+
225
+
+
231 inline TMeasurementCollection const & Collection () const
+
232 {
+
233 return collection_;
+
234 }
+
+
235
+
+
241 inline TMeasurementCollection & Collection ()
+
242 {
+
243 return collection_;
+
244 }
+
+
246
+
249#pragma mark MODIFIER
+
250
+
+
254 inline void Clear ()
+
255 {
+
256 collection_.Clear();
+
257
+
258 if ( CentralityCounterType == CentralityCounter::counterAtEdges )
+
259 {
+
260 countersSize_ = graph_.NumberOfEdges();
+
261 } else {
+
262 countersSize_ = graph_.NumberOfVertices();
+
263 }
+
264
+
265 totalRelativeNumberOfPaths_.assign ( countersSize_, 0.0 );
+
266 totalNumberOfPaths_.assign ( countersSize_, 0 );
+
267 }
+
+
269
+
270 protected:
+
271
+
274#pragma mark TOTAL_NUMBER_OF_PATHS
+
275
+
+
286 inline void JoinThreadBasedResults ( TNumberOfPaths const & numberOfPaths
+
287 , TRelativeNumberOfPaths const & relativeNumberOfPaths
+
288 , Types::real const & m_BNormalization )
+
289 {
+
290#ifdef OPENMP_AVAILABLE
+
291 ESSENTIAL_ASSERT ( totalRelativeNumberOfPaths_.size() == countersSize_ );
+
292 ESSENTIAL_ASSERT ( relativeNumberOfPaths.size() == omp_get_max_threads () );
+
293 ESSENTIAL_ASSERT ( relativeNumberOfPaths[0].size() == countersSize_ );
+
294 ESSENTIAL_ASSERT ( totalNumberOfPaths_.size() == countersSize_ );
+
295 ESSENTIAL_ASSERT ( numberOfPaths.size() == omp_get_max_threads () );
+
296 ESSENTIAL_ASSERT ( numberOfPaths[0].size() == countersSize_ );
+
297
+
298 for ( Types::count counterThreads = 0
+
299 ; counterThreads < omp_get_max_threads()
+
300 ; ++counterThreads )
+
301 {
+
302 for ( Types::count counterEdgesOrVertices = 0
+
303 ; counterEdgesOrVertices < countersSize_
+
304 ; ++counterEdgesOrVertices )
+
305 {
+
306 // Total relative number of paths per edge
+
307 totalRelativeNumberOfPaths_[counterEdgesOrVertices] += relativeNumberOfPaths[counterThreads][counterEdgesOrVertices];
+
308 totalNumberOfPaths_[counterEdgesOrVertices] += numberOfPaths[counterThreads][counterEdgesOrVertices];
+
309 }
+
310 }
+
311
+
312 std::transform ( totalRelativeNumberOfPaths_.begin()
+
313 , totalRelativeNumberOfPaths_.end()
+
314 , totalRelativeNumberOfPaths_.begin()
+
315 , std::bind( std::multiplies<Types::real>(), std::placeholders::_1, m_BNormalization ) );
+
316
+
317#else // OPENMP IS NOT AVAILABLE
+
318 ESSENTIAL_ASSERT ( totalRelativeNumberOfPaths_.size() == countersSize_ );
+
319 ESSENTIAL_ASSERT ( relativeNumberOfPaths.size() == countersSize_ );
+
320 ESSENTIAL_ASSERT ( totalNumberOfPaths_.size() == countersSize_ );
+
321 ESSENTIAL_ASSERT ( numberOfPaths.size() == countersSize_ );
+
322
+
323 // Total relative number of paths per edge
+
324 totalRelativeNumberOfPaths_ = relativeNumberOfPaths;
+
325 totalNumberOfPaths_ = numberOfPaths;
+
326
+
327 std::transform ( totalRelativeNumberOfPaths_.begin()
+
328 , totalRelativeNumberOfPaths_.end()
+
329 , totalRelativeNumberOfPaths_.begin()
+
330 , std::bind( std::multiplies<Types::real>(), std::placeholders::_1, m_BNormalization ) );
+
331#endif
+
332 }
+
+
333
+
+
342 inline void TotalNumberOfPaths ( TNumberOfPaths & numberOfPaths
+
343 , TRelativeNumberOfPaths & relativeNumberOfPaths )
+
344 {
+
345#ifdef OPENMP_AVAILABLE
+
346 if ( CentralityCounterType == CentralityCounter::counterAtEdges )
+
347 {
+
348 Algorithm()[ omp_get_thread_num() ].TotalNumberOfPathsThroughEdge ( numberOfPaths[ omp_get_thread_num() ]
+
349 , relativeNumberOfPaths[ omp_get_thread_num() ] );
+
350 } else {
+
351 Algorithm()[ omp_get_thread_num() ].TotalNumberOfPathsThroughVertex ( numberOfPaths[ omp_get_thread_num() ]
+
352 , relativeNumberOfPaths[ omp_get_thread_num() ] );
+
353 }
+
354#else
+
355 if ( CentralityCounterType == CentralityCounter::counterAtEdges )
+
356 {
+
357 Algorithm().TotalNumberOfPathsThroughEdge ( numberOfPaths, relativeNumberOfPaths );
+
358 } else {
+
359 Algorithm().TotalNumberOfPathsThroughVertex ( numberOfPaths, relativeNumberOfPaths );
+
360 }
+
361#endif
+
362 }
+
+
364
+
367#pragma mark PROTECTED_MODIFIERS
+
368
+
+
375 inline void Clear ( TNumberOfPaths & numberOfPaths
+
376 , TRelativeNumberOfPaths & relativeNumberOfPaths )
+
377 {
+
378 Clear();
+
379#ifdef OPENMP_AVAILABLE
+
380 numberOfPaths.assign ( omp_get_max_threads(), std::vector<Types::count> ( countersSize_, 0 ) );
+
381 relativeNumberOfPaths.assign ( omp_get_max_threads(), std::vector<Types::real> ( countersSize_, 0.0 ) );
+
382#else
+
383 numberOfPaths.assign ( countersSize_, 0 );
+
384 relativeNumberOfPaths.assign ( countersSize_, 0.0 );
+
385#endif
+
386 }
+
+
388
+
389#pragma mark MEMBERS
+
390 private:
+
391 Types::count countersSize_;
+
392 TGraph const & graph_;
+
393 TAlgoHandling algo_;
+
394 TMeasurementCollection collection_;
+
396 std::vector<Types::real> totalRelativeNumberOfPaths_;
+
397 std::vector<Types::count> totalNumberOfPaths_;
+
398};
+
+
399
+
400} // egoa
+
401
+
402#endif // EGOA__ALGORITHMS__CENTRALITY__BETWEENNESS_CENTRALITY_HPP
+
egoa::BetweennessCentrality
Class for betweenness centrality.
Definition BetweennessCentrality.hpp:67
+
egoa::BetweennessCentrality::TVertex
typename TGraph::TVertex TVertex
Definition BetweennessCentrality.hpp:72
+ + +
egoa::BetweennessCentrality::BetweennessCentrality
BetweennessCentrality(TGraph const &graph)
Constructs the betweenness centrality object.
Definition BetweennessCentrality.hpp:101
+ +
egoa::BetweennessCentrality::Algorithm
TAlgoHandling const & Algorithm() const
Getter for the algorithm.
Definition BetweennessCentrality.hpp:221
+
egoa::BetweennessCentrality::TotalNumberOfPaths
void TotalNumberOfPaths(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)
Total number of paths.
Definition BetweennessCentrality.hpp:342
+
egoa::BetweennessCentrality::TVertexId
typename TGraph::TVertexId TVertexId
Definition BetweennessCentrality.hpp:73
+
egoa::BetweennessCentrality::JoinThreadBasedResults
void JoinThreadBasedResults(TNumberOfPaths const &numberOfPaths, TRelativeNumberOfPaths const &relativeNumberOfPaths, Types::real const &m_BNormalization)
Join the thread based result from OpenMP.
Definition BetweennessCentrality.hpp:286
+
egoa::BetweennessCentrality::~BetweennessCentrality
~BetweennessCentrality()
Destroys the object.
Definition BetweennessCentrality.hpp:114
+
egoa::BetweennessCentrality::Run
void Run()
Run the betweenness centrality.
Definition BetweennessCentrality.hpp:132
+
egoa::BetweennessCentrality::Collection
TMeasurementCollection const & Collection() const
Getter for the measurement collection.
Definition BetweennessCentrality.hpp:231
+
egoa::BetweennessCentrality::Clear
void Clear()
Clears the measurement collection.
Definition BetweennessCentrality.hpp:254
+ + +
egoa::BetweennessCentrality::TEdgeId
typename TGraph::TEdgeId TEdgeId
Definition BetweennessCentrality.hpp:75
+
egoa::BetweennessCentrality::TMeasurementRow
typename TMeasurementCollection::TRow TMeasurementRow
Definition BetweennessCentrality.hpp:79
+
egoa::BetweennessCentrality::Clear
void Clear(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)
Clear all.
Definition BetweennessCentrality.hpp:375
+
egoa::BetweennessCentrality::Collection
TMeasurementCollection & Collection()
Setter for the measurement collection.
Definition BetweennessCentrality.hpp:241
+
egoa::BetweennessCentrality::TotalRelativeNumberOfPaths
std::vector< Types::real > const & TotalRelativeNumberOfPaths() const
Getter for the total relative number of paths per edge.
Definition BetweennessCentrality.hpp:189
+
egoa::BetweennessCentrality::TotalNumberOfPaths
std::vector< Types::count > const & TotalNumberOfPaths() const
Getter for the total number of paths per edge.
Definition BetweennessCentrality.hpp:200
+ +
egoa::BetweennessCentrality::Algorithm
TAlgoHandling & Algorithm()
Setter for the algorithm.
Definition BetweennessCentrality.hpp:211
+
egoa::BetweennessCentrality::TMeasurementCollection
MeasurementCollection TMeasurementCollection
Definition BetweennessCentrality.hpp:78
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_binary_heap_8hpp_source.html b/_binary_heap_8hpp_source.html new file mode 100644 index 00000000..f35cdbf3 --- /dev/null +++ b/_binary_heap_8hpp_source.html @@ -0,0 +1,966 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/BinaryHeap.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BinaryHeap.hpp
+
+
+
1/*
+
2 * BinaryHeap.hpp
+
3 *
+
4 * Created on: Nov 25, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__BINARY_HEAP_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__BINARY_HEAP_HPP
+
10
+
11#include "Auxiliary/Auxiliary.hpp"
+
12#include "Auxiliary/Constants.hpp"
+
13#include "Auxiliary/ExecutionPolicy.hpp"
+
14#include "Auxiliary/Types.hpp"
+
15#include "Exceptions/Assertions.hpp"
+
16
+
17#include <iomanip>
+
18#include <iterator>
+
19
+
20namespace egoa {
+
21
+
22namespace internal {
+
43template<typename Type, bool inOrder>
+
44class BinaryHeapCheck;
+
45
+
61template<typename HeapType, ExecutionPolicy Policy>
+
62class BinaryHeapLoopDifferentiation;
+
63} // namespace internal
+
64
+
93template<typename ElementType>
+
+
94class BinaryHeap {
+
95 public:
+
96 // Type aliasing
+
100 using TElement = ElementType;
+
101
+
104#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
+
110 BinaryHeap()
+
111 {
+
112 Minimize();
+
113 }
+
+
114
+
+
120 explicit BinaryHeap ( std::vector<TElement> const & elements )
+
121 {
+
122 Minimize();
+
123 BuildWith( elements );
+
124 }
+
+
126
+
129#pragma mark ELEMENT_ACCESS
+
+
137 inline TElement const & Top() const
+
138 {
+
139 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
140 USAGE_ASSERT ( !Empty() );
+
141 return heap_.front();
+
142 }
+
+
143
+
+
151 inline Types::index Search ( TElement const & element ) const
+
152 {
+
153 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
154
+
155 auto result = std::find( std::begin(heap_), std::end(heap_), element );
+
156 if ( result != std::end( heap_ ) )
+
157 {
+
158 return std::distance( std::begin(heap_), result );
+
159 }
+
160 return Const::NONE;
+
161 }
+
+
163
+
166#pragma mark ADD_ELEMENTS
+
+
174 inline BinaryHeap & operator+= ( TElement const & rhs )
+
175 {
+
176 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
177 heap_.emplace_back(rhs);
+
178 SiftUp();
+
179 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
180 return *this;
+
181 }
+
+
182
+
+
190 inline BinaryHeap & operator+= ( TElement && rhs )
+
191 {
+
192 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
193 heap_.emplace_back(std::move(rhs));
+
194 SiftUp();
+
195 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
196 return *this;
+
197 }
+
+
198
+
+
204 inline void Insert ( TElement const & element )
+
205 {
+
206 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
207 *this += element;
+
208 }
+
+
209
+
+
215 inline void Insert ( TElement && element )
+
216 {
+
217 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
218 *this += std::move(element);
+
219 }
+
+
220
+
230 template<typename InputIt>
+
+
231 inline void Insert ( InputIt first, InputIt last)
+
232 {
+
233 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
234 for ( InputIt it = first
+
235 ; it != last
+
236 ; ++it )
+
237 {
+
238 *this += *it;
+
239 }
+
240 }
+
+
241
+
+
247 inline void Insert ( std::vector<TElement> const & elements)
+
248 {
+
249 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
250 Insert(elements.begin(), elements.end());
+
251 }
+
+
252
+
258 template <typename... Args>
+
+
259 inline void Emplace ( Args&&... args )
+
260 {
+
261 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
262 heap_.emplace_back ( std::forward<Args>(args)... );
+
263 SiftUp();
+
264 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
265 }
+
+
266
+
+
274 inline void BuildWith ( std::vector<TElement> const & elements )
+
275 {
+
276 heap_ = elements;
+
277 MakeHeapProperty();
+
278 }
+
+
280
+
283#pragma mark MODIFIERS
+
+
289 inline void Pop()
+
290 {
+
291 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
292 USAGE_ASSERT ( Size() > 0 );
+
293 DeleteTop();
+
294 }
+
+
295
+
+
303 inline TElement DeleteTop()
+
304 {
+
305 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
306 USAGE_ASSERT ( Size() > 0 );
+
307
+
308 TElement top = std::move( Front() );
+
309 if ( Size() > 1 )
+
310 {
+
311 using std::swap; // enable ADL
+
312 swap ( Front(), Back() );
+
313 heap_.pop_back();
+
314 SiftDown();
+
315 } else {
+
316 heap_.pop_back();
+
317 }
+
318 return top;
+
319 }
+
+
320
+
+
324 inline void Clear()
+
325 {
+
326 heap_.clear();
+
327 }
+
+
328
+
+
339 inline void ChangeKey ( Types::index index
+
340 , TElement const & element )
+
341 {
+
342 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
343 USAGE_ASSERT ( index < Size() );
+
344
+
345 ElementAt( index ) = element;
+
346 SiftUp( index );
+
347 SiftDown( index );
+
348 }
+
+
349
+
+
363 inline void DecreaseKey ( Types::index index
+
364 , TElement const & element )
+
365 {
+
366 ESSENTIAL_ASSERT ( ComplyHeapProperty() );
+
367 USAGE_ASSERT ( index < Size() );
+
368
+
369 ElementAt( index ) = element;
+
370 SiftUp( index );
+
371 }
+
+
373
+
376#pragma mark CAPACITY
+
377
+
+
383 inline bool Empty() const
+
384 {
+
385 return heap_.empty();
+
386 }
+
+
387
+
+
393 inline Types::count Size() const
+
394 {
+
395 return heap_.size();
+
396 }
+
+
398
+
401#pragma mark COMPARATORS
+
402
+
408 inline std::function< bool ( TElement const &
+
409 , TElement const & ) >
+
+
410 const & Comparator() const
+
411 {
+
412 return comparator_;
+
413 }
+
+
414
+
+
429 inline void Comparator( std::function<bool ( TElement const &
+
430 , TElement const & )> comparator )
+
431 {
+
432 comparator_ = comparator;
+
433 MakeHeapProperty();
+
434 }
+
+
435
+
+
441 inline void Maximize()
+
442 {
+
443 Comparator ( std::greater<TElement>() );
+
444 }
+
+
445
+
+
451 inline void Minimize()
+
452 {
+
453 Comparator ( std::less<TElement>() );
+
454 }
+
+
456
+
459#pragma mark OPERATORS
+
+
470 inline bool operator==( BinaryHeap const & rhs ) const
+
471 {
+
472 return IsEqualTo<false>( rhs );
+
473 }
+
+
474
+
+
486 inline bool operator!=( BinaryHeap const & rhs) const
+
487 {
+
488 return !(*this==rhs);
+
489 }
+
+
490
+
502 template<bool IsIdentical>
+
+
503 inline bool IsEqualTo( BinaryHeap const & rhs ) const
+
504 {
+
505 return internal::BinaryHeapCheck<TElement, IsIdentical>
+
506 ::IsEqualTo(*this, rhs);
+
507 }
+
+
508
+
+
515 friend void swap ( BinaryHeap<TElement> & lhs, BinaryHeap<TElement> & rhs )
+
516 { // Necessary for the copy and swap idiom
+
517 using std::swap; // enable ADL
+
518 swap( lhs.heap_, rhs.heap_ );
+
519 swap( lhs.comparator_, rhs.comparator_);
+
520 }
+
+
522
+
525#pragma mark OUTPUT
+
+
534 friend std::ostream & operator<<( std::ostream & outputStream
+
535 , BinaryHeap const & heap )
+
536 {
+
537 std::copy( heap.begin(), heap.end(), std::ostream_iterator<TElement>( outputStream , "|" ) );
+
538 return outputStream;
+
539 }
+
+
541
+
544#pragma mark ITERATORS
+
545 private:
+
546
+
+
551 class HeapIterator {
+
552 Types::largeNumber counter_;
+
553 Types::largeNumber begin_;
+
554 Types::largeNumber end_;
+
555 std::vector<TElement> const * vector_;
+
556 public:
+
557 using iterator_category = std::forward_iterator_tag;
+
558 using value_type = TElement;
+
559 using difference_type = Types::difference;
+
560 using pointer = const TElement*;
+
561 using reference = const TElement&;
+
563 explicit HeapIterator ( std::vector<TElement> const * vector
+
564 , Types::largeNumber counter = 0 )
+
565 : counter_( counter )
+
566 , begin_( 0 )
+
567 , end_( vector->size() - 1 )
+
568 , vector_(vector){ }
+
569
+
570 explicit HeapIterator ( std::vector<TElement> const * vector
+
571 , Types::largeNumber counter
+
572 , Types::largeNumber begin
+
573 , Types::largeNumber end )
+
574 : counter_( counter )
+
575 , begin_( begin )
+
576 , end_( end )
+
577 , vector_(vector){ }
+
578
+
579 HeapIterator & operator++() { ( end_ >= begin_ ) ? ( ++counter_ ) : ( --counter_ ); return *this; }
+
580 HeapIterator operator++(int) {
+
581 HeapIterator copy = *this;
+
582 ++*this;
+
583 return copy;
+
584 }
+
585 bool operator==( HeapIterator const & rhs) const {
+
586 return counter_ == rhs.counter_ && vector_ == rhs.vector_;
+
587 }
+
588 bool operator!=( HeapIterator const & rhs) const { return !( operator==(rhs) ); }
+
589 TElement const & operator*() const { return (*vector_)[counter_]; }
+
590 TElement const * operator->() const { return &((*vector_)[counter_]); }
+
591 };
+
+
592
+
593 public:
+
599 HeapIterator begin() const noexcept { return HeapIterator(&heap_, 0); }
+
600
+
606 HeapIterator end() const noexcept { return HeapIterator( &heap_, heap_.size() ); }
+
608
+
611#pragma mark LOOPS
+
625 template<ExecutionPolicy Policy, typename FUNCTION>
+
626 inline
+
+
627 void for_all_elements ( FUNCTION function )
+
628 {
+
629 internal::BinaryHeapLoopDifferentiation<BinaryHeap, Policy>
+
630 ::for_all_elements ( *this, function);
+
631 }
+
+
632
+
646 template<ExecutionPolicy Policy, typename FUNCTION>
+
647 inline
+
+
648 void for_all_elements ( FUNCTION function ) const
+
649 {
+
650 internal::BinaryHeapLoopDifferentiation<BinaryHeap const, Policy>
+
651 ::for_all_elements ( *this, function);
+
652 }
+
+
654
+
655 private:
+
658#pragma mark ACCESSORS
+
659 inline TElement & ElementAt ( Types::index index ) { ESSENTIAL_ASSERT( index < Size() ); return heap_[index]; }
+
660 inline TElement const & ElementAt ( Types::index index ) const { ESSENTIAL_ASSERT( index < Size() ); return heap_[index]; }
+
661
+
662 inline TElement & ParentElementAt ( Types::index index ) { ESSENTIAL_ASSERT( HasParent() ); return ElementAt(ParentIdOf(index)); }
+
663 inline TElement const & ParentElementAt ( Types::index index ) const { ESSENTIAL_ASSERT( HasParent() ); return ElementAt(ParentIdOf(index)); }
+
664
+
665 inline TElement & RightElementAt ( Types::index index ) { ESSENTIAL_ASSERT( HasRightChild(index) ); return ElementAt(RightChildIdOf(index)); }
+
666 inline TElement const & RightElementAt ( Types::index index ) const { ESSENTIAL_ASSERT( HasRightChild(index) ); return ElementAt(RightChildIdOf(index)); }
+
667
+
668 inline TElement & LeftElementAt ( Types::index index ) { ESSENTIAL_ASSERT( HasLeftChild(index) ); return ElementAt(LeftChildIdOf(index)); }
+
669 inline TElement const & LeftElementAt ( Types::index index ) const { ESSENTIAL_ASSERT( HasLeftChild(index) ); return ElementAt(LeftChildIdOf(index)); }
+
670
+
671 inline Types::index LeftChildIdOf ( Types::index index ) const { return ( 2 * index + 1 ); }
+
672 inline Types::index RightChildIdOf ( Types::index index ) const { return ( 2 * index + 2 ); }
+
673 inline bool HasChildren ( Types::index index ) const { return LeftChildIdOf(index) < Size(); }
+
674 inline bool HasLeftChild ( Types::index index ) const { return LeftChildIdOf(index) < Size(); }
+
675 inline bool HasRightChild ( Types::index index ) const { return RightChildIdOf(index) < Size(); }
+
676 inline Types::index ParentIdOf ( Types::index index ) const { return floor( ( index - 1 ) / 2 ); }
+
677 inline bool HasParent ( Types::index index ) const { return index > 0; }
+
678
+
+
684 inline TElement & Front()
+
685 {
+
686 ESSENTIAL_ASSERT( !Empty() );
+
687 return heap_.front();
+
688 }
+
+
689
+
+
695 inline TElement const & Front() const
+
696 {
+
697 ESSENTIAL_ASSERT( !Empty() );
+
698 return heap_.front();
+
699 }
+
+
700
+
+
706 inline TElement & Back()
+
707 {
+
708 ESSENTIAL_ASSERT( !Empty() );
+
709 return heap_.back();
+
710 }
+
+
711
+
+
717 inline TElement const & Back() const
+
718 {
+
719 ESSENTIAL_ASSERT( !Empty() );
+
720 return heap_.back();
+
721 }
+
+
722
+
+
728 inline Types::index MaximumIndex() const
+
729 {
+
730 ESSENTIAL_ASSERT( !Empty() );
+
731 return heap_.size() - 1;
+
732 }
+
+
734
+
737#pragma mark HEAP_PROPERTY_METHODS
+
+
751 inline void MakeHeapProperty()
+
752 {
+
753 for ( Types::rcount counter = heap_.size() / 2 - 1
+
754 ; counter >= 0
+
755 ; --counter )
+
756 {
+
757 SiftDown( counter );
+
758 }
+
759 ESSENTIAL_ASSERT( ComplyHeapProperty() );
+
760 }
+
+
761
+
+
771 inline bool ComplyHeapProperty( Types::index index ) const
+
772 {
+
773 ESSENTIAL_ASSERT( index < Size() );
+
774 if ( !HasChildren( index ) ) return true;
+
775 if ( Comparator()( LeftElementAt(index), ElementAt(index) ) ) return false;
+
776 if ( !HasRightChild( index ) ) return true;
+
777 return !Comparator()(RightElementAt(index), ElementAt(index));
+
778 }
+
+
779
+
+
786 inline bool ComplyHeapProperty() const
+
787 {
+
788 for ( Types::count counter = 0
+
789 ; counter < Size()
+
790 ; ++counter )
+
791 {
+
792 if ( !ComplyHeapProperty( counter ) )
+
793 {
+
794 return false;
+
795 }
+
796 }
+
797 return true;
+
798 }
+
+
800
+
803#pragma mark SIFTS
+
+
807 inline void SiftUp ()
+
808 {
+
809 ESSENTIAL_ASSERT( !Empty() );
+
810 SiftUp( MaximumIndex() );
+
811 }
+
+
812
+
+
819 inline void SiftUp ( Types::index index )
+
820 {
+
821 ESSENTIAL_ASSERT( index < Size() );
+
822
+
823 if ( !HasParent(index) ) return;
+
824 Types::index parentIndex = ParentIdOf( index );
+
825 while ( Comparator()( ElementAt( index ), ElementAt( parentIndex ) )
+
826 && index != 0 )
+
827 {
+
828 using std::swap; // enable ADL
+
829 swap( ElementAt( index ), ElementAt( parentIndex ) );
+
830 index = parentIndex;
+
831 if ( !HasParent(index) || index == 0 ) return;
+
832 parentIndex = ParentIdOf( index );
+
833 }
+
834 }
+
+
835
+
+
839 inline void SiftDown()
+
840 {
+
841 ESSENTIAL_ASSERT( !Empty() );
+
842 SiftDown( 0 );
+
843 }
+
+
844
+
+
851 inline void SiftDown( Types::index index )
+
852 {
+
853 ESSENTIAL_ASSERT( index < Size() );
+
854
+
855 Types::index childIndex = 0;
+
856 if ( !HasChildren( index ) ) return;
+
857 childIndex = SelectSwappableChildAt ( index );
+
858
+
859 while ( Comparator()( ElementAt(childIndex), ElementAt(index) )
+
860 && childIndex < Size() )
+
861 {
+
862 using std::swap;
+
863 swap( ElementAt(index), ElementAt(childIndex) );
+
864 index = childIndex;
+
865 if ( !HasChildren( index ) ) return;
+
866 childIndex = SelectSwappableChildAt ( index );
+
867 }
+
868 }
+
+
870
+
873#pragma mark SWAPPABILITY
+
+
884 inline Types::index SelectSwappableChildAt ( Types::index index ) const
+
885 {
+
886 ESSENTIAL_ASSERT( HasChildren(index) );
+
887 if ( !HasRightChild(index) )
+
888 {
+
889 return LeftChildIdOf( index );
+
890 }
+
891
+
892 ESSENTIAL_ASSERT( HasRightChild(index) );
+
893 if ( Comparator()( LeftElementAt( index ), RightElementAt( index )) )
+
894 {
+
895 return LeftChildIdOf( index );
+
896 }
+
897 return RightChildIdOf( index );
+
898 }
+
+
900
+
901#pragma mark FRIENDS
+
902 friend internal::BinaryHeapCheck<TElement, true>;
+
903 friend internal::BinaryHeapCheck<TElement, false>;
+
904 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap, ExecutionPolicy::sequential>;
+
905 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap, ExecutionPolicy::breakable>;
+
906 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap, ExecutionPolicy::parallel>;
+
907 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap const, ExecutionPolicy::sequential>;
+
908 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap const, ExecutionPolicy::breakable>;
+
909 friend internal::BinaryHeapLoopDifferentiation<BinaryHeap const, ExecutionPolicy::parallel>;
+
910
+
911#pragma mark MEMBERS
+
912 private:
+
913 std::vector<TElement> heap_;
+
914 std::function<bool(TElement const & a, TElement const & b)> comparator_;
+
915};
+
+
916
+
917namespace internal {
+
918#pragma mark HEAPS_ARE_IDENTICAL_CHECK
+
919template<typename Type>
+
+
920class BinaryHeapCheck<Type, true> {
+
921
+
922 // Type aliasing
+
923 using TElement = Type;
+
924 using THeap = BinaryHeap<TElement>;
+
925
+
926 public:
+
+
934 static inline bool IsEqualTo ( THeap const & lhs
+
935 , THeap const & rhs )
+
936 {
+
937 if ( lhs.Size() != rhs.Size() ) return false;
+
938 for ( Types::count counter = 0
+
939 ; counter < lhs.Size()
+
940 ; ++counter )
+
941 {
+
942 if ( lhs.ElementAt( counter ) != rhs.ElementAt( counter ) ) return false;
+
943 }
+
944 return true;
+
945 }
+
+
946};
+
+
947
+
948#pragma mark HEAPS_HAVE_SAME_ELEMENTS_CHECK
+
949template<typename Type>
+
+
950class BinaryHeapCheck<Type, false> {
+
951
+
952 // Template aliasing
+
953 using TElement = Type;
+
954 using THeap = BinaryHeap<TElement>;
+
955
+
956 public:
+
+
964 static inline bool IsEqualTo ( THeap const & lhs
+
965 , THeap const & rhs )
+
966 {
+
967 if ( lhs.Size() != rhs.Size() ) return false;
+
968 THeap tempRhs = rhs; std::sort( tempRhs.heap_.begin(), tempRhs.heap_.end() );
+
969 THeap tempLhs = lhs; std::sort( tempLhs.heap_.begin(), tempLhs.heap_.end() );
+
970 for ( Types::count counter = 0
+
971 ; counter < tempLhs.Size()
+
972 ; ++counter )
+
973 {
+
974 if ( tempLhs.ElementAt( counter ) != tempRhs.ElementAt( counter ) ) return false;
+
975 }
+
976 return true;
+
977 }
+
+
978};
+
+
979
+
980#pragma mark SEQUENTIAL_LOOPS
+
986template<typename HeapType>
+
+
987class BinaryHeapLoopDifferentiation<HeapType, ExecutionPolicy::sequential> {
+
988
+
989 using THeap = HeapType;
+
990
+
991 public:
+
1004 template<typename FUNCTION>
+
1005 inline static
+
+
1006 void for_all_elements ( THeap & heap
+
1007 , FUNCTION function )
+
1008 {
+
1009 for (auto & element : heap.heap_)
+
1010 {
+
1011 function(element);
+
1012 }
+
1013 if ( !heap.ComplyHeapProperty() )
+
1014 {
+
1015 heap.MakeHeapProperty();
+
1016 }
+
1017 }
+
+
1018};
+
+
1019
+
1025template<typename HeapType>
+
+
1026class BinaryHeapLoopDifferentiation<HeapType const, ExecutionPolicy::sequential> {
+
1027
+
1028 using THeap = HeapType const;
+
1029
+
1030 public:
+
1043 template<typename FUNCTION>
+
1044 inline static
+
+
1045 void for_all_elements ( THeap & heap
+
1046 , FUNCTION function )
+
1047 {
+
1048 for (auto & element : heap.heap_)
+
1049 {
+
1050 function(element);
+
1051 }
+
1052 ESSENTIAL_ASSERT( heap.ComplyHeapProperty() );
+
1053 }
+
+
1054};
+
+
1055
+
1056#pragma mark BREAKABLE_LOOPS
+
1057template<typename HeapType>
+
+
1058class BinaryHeapLoopDifferentiation<HeapType, ExecutionPolicy::breakable> {
+
1059
+
1060 using THeap = HeapType;
+
1061
+
1062 public:
+
1079 template<typename FUNCTION>
+
1080 inline static
+
+
1081 void for_all_elements ( THeap & heap
+
1082 , FUNCTION function )
+
1083 {
+
1084 for ( auto & element : heap.heap_ )
+
1085 {
+
1086 bool toContinue = function(element);
+
1087 if ( !toContinue ) break;
+
1088 }
+
1089 if ( !heap.ComplyHeapProperty() )
+
1090 {
+
1091 heap.MakeHeapProperty();
+
1092 }
+
1093 }
+
+
1094};
+
+
1095
+
1096template<typename HeapType>
+
+
1097class BinaryHeapLoopDifferentiation<HeapType const, ExecutionPolicy::breakable> {
+
1098
+
1099 using THeap = HeapType const;
+
1100
+
1101 public:
+
1118 template<typename FUNCTION>
+
1119 inline static
+
+
1120 void for_all_elements ( THeap & heap
+
1121 , FUNCTION function )
+
1122 {
+
1123 for ( auto & element : heap.heap_ )
+
1124 {
+
1125 bool toContinue = function(element);
+
1126 if ( !toContinue ) break;
+
1127 }
+
1128 ESSENTIAL_ASSERT( heap.ComplyHeapProperty() );
+
1129 }
+
+
1130};
+
+
1131
+
1132#pragma mark PARALLEL_LOOPS
+
1133
+
1134#ifdef OPENMP_AVAILABLE
+
1135
+
1136template<typename HeapType>
+
1137class BinaryHeapLoopDifferentiation<HeapType, ExecutionPolicy::parallel> {
+
1138
+
1139 // Type aliasing
+
1140 using THeap = HeapType;
+
1141
+
1142 public:
+
1155 template<typename FUNCTION>
+
1156 inline static
+
1157 void for_all_elements ( THeap & heap
+
1158 , FUNCTION function )
+
1159 {
+
1160 #pragma omp parallel for
+
1161 for ( Types::count counter = 0
+
1162 ; counter < heap.heap_.size()
+
1163 ; ++counter )
+
1164 {
+
1165 function ( heap.heap_[counter] );
+
1166 }
+
1167 if ( !heap.ComplyHeapProperty() )
+
1168 {
+
1169 heap.MakeHeapProperty();
+
1170 }
+
1171 }
+
1172};
+
1173
+
1174template<typename HeapType>
+
1175class BinaryHeapLoopDifferentiation<HeapType const, ExecutionPolicy::parallel> {
+
1176
+
1177 // Type aliasing
+
1178 using THeap = HeapType const;
+
1179
+
1180 public:
+
1193 template<typename FUNCTION>
+
1194 inline static
+
1195 void for_all_elements ( THeap & heap
+
1196 , FUNCTION function )
+
1197 {
+
1198 #pragma omp parallel for
+
1199 for ( Types::count counter = 0
+
1200 ; counter < heap.heap_.size()
+
1201 ; ++counter )
+
1202 {
+
1203 function ( heap.heap_[counter] );
+
1204 }
+
1205 ESSENTIAL_ASSERT( heap.ComplyHeapProperty() );
+
1206 }
+
1207};
+
1208
+
1209
+
1210#else // OPENMP_AVAILABLE
+
1211
+
1212template<typename HeapType>
+
+
1213class BinaryHeapLoopDifferentiation<HeapType, ExecutionPolicy::parallel>
+
1214 : public BinaryHeapLoopDifferentiation<HeapType, ExecutionPolicy::sequential> {
+
1215};
+
+
1216
+
1217#endif
+
1218
+
1219} // namespace internal
+
1220} // namespace egoa
+
1221
+
1222#endif // EGOA__DATA_STRUCTURES__CONTAINER__BINARY_HEAP_HPP
+
egoa::BinaryHeap::HeapIterator
Class for a heap iterator.
Definition BinaryHeap.hpp:551
+ + + + +
egoa::BinaryHeap::HeapIterator::difference_type
Types::difference difference_type
Definition BinaryHeap.hpp:559
+
egoa::BinaryHeap::HeapIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition BinaryHeap.hpp:557
+
egoa::BinaryHeap::HeapIterator::vector_
std::vector< TElement > const * vector_
Definition BinaryHeap.hpp:555
+ + +
egoa::BinaryHeap
Class for binary heap data structure.
Definition BinaryHeap.hpp:94
+
egoa::BinaryHeap::TElement
ElementType TElement
The type of the elements in the heap.
Definition BinaryHeap.hpp:100
+
egoa::BinaryHeap::Emplace
void Emplace(Args &&... args)
Emplaces an element to the heap.
Definition BinaryHeap.hpp:259
+
egoa::BinaryHeap::DeleteTop
TElement DeleteTop()
Deletes the top element.
Definition BinaryHeap.hpp:303
+
egoa::BinaryHeap::for_all_elements
void for_all_elements(FUNCTION function) const
Iterates over all elements in the heap.
Definition BinaryHeap.hpp:648
+
egoa::BinaryHeap::Insert
void Insert(TElement const &element)
Inserts an element into the heap.
Definition BinaryHeap.hpp:204
+
egoa::BinaryHeap::Top
TElement const & Top() const
The top element.
Definition BinaryHeap.hpp:137
+
egoa::BinaryHeap::Empty
bool Empty() const
Checks if BinaryHeap is empty.
Definition BinaryHeap.hpp:383
+
egoa::BinaryHeap::ChangeKey
void ChangeKey(Types::index index, TElement const &element)
Changes the key of one element.
Definition BinaryHeap.hpp:339
+
egoa::BinaryHeap::DecreaseKey
void DecreaseKey(Types::index index, TElement const &element)
Decreases the key of one element.
Definition BinaryHeap.hpp:363
+
egoa::BinaryHeap::Search
Types::index Search(TElement const &element) const
Searches for the first match.
Definition BinaryHeap.hpp:151
+
egoa::BinaryHeap::begin
HeapIterator begin() const noexcept
An iterator pointing to the top element of the heap.
Definition BinaryHeap.hpp:599
+
egoa::BinaryHeap::IsEqualTo
bool IsEqualTo(BinaryHeap const &rhs) const
Determines if equal to.
Definition BinaryHeap.hpp:503
+
egoa::BinaryHeap::for_all_elements
void for_all_elements(FUNCTION function)
Iterates over all elements in the heap.
Definition BinaryHeap.hpp:627
+
egoa::BinaryHeap::ComplyHeapProperty
bool ComplyHeapProperty(Types::index index) const
Checks if the heap complies with the heap property at element index.
Definition BinaryHeap.hpp:771
+
egoa::BinaryHeap::operator+=
BinaryHeap & operator+=(TElement const &rhs)
Inserts an element into the heap.
Definition BinaryHeap.hpp:174
+
egoa::BinaryHeap::swap
friend void swap(BinaryHeap< TElement > &lhs, BinaryHeap< TElement > &rhs)
Swap two BinaryHeaps.
Definition BinaryHeap.hpp:515
+
egoa::BinaryHeap::operator!=
bool operator!=(BinaryHeap const &rhs) const
Check if two heaps are not equivalent.
Definition BinaryHeap.hpp:486
+
egoa::BinaryHeap::Back
TElement const & Back() const
The last element.
Definition BinaryHeap.hpp:717
+
egoa::BinaryHeap::SelectSwappableChildAt
Types::index SelectSwappableChildAt(Types::index index) const
Selects the smallest child, where smallest is measured according to the comparator.
Definition BinaryHeap.hpp:884
+
egoa::BinaryHeap::Size
Types::count Size() const
Number of elements in the heap.
Definition BinaryHeap.hpp:393
+
egoa::BinaryHeap::MaximumIndex
Types::index MaximumIndex() const
Maximum index of the heap.
Definition BinaryHeap.hpp:728
+
egoa::BinaryHeap::Insert
void Insert(std::vector< TElement > const &elements)
Inserts the elements from the vector.
Definition BinaryHeap.hpp:247
+
egoa::BinaryHeap::operator==
bool operator==(BinaryHeap const &rhs) const
Check if two heaps are equivalent.
Definition BinaryHeap.hpp:470
+
egoa::BinaryHeap::end
HeapIterator end() const noexcept
An interator pointing behind the last element.
Definition BinaryHeap.hpp:606
+
egoa::BinaryHeap::Minimize
void Minimize()
Changes the comparator to construct a min-heap.
Definition BinaryHeap.hpp:451
+
egoa::BinaryHeap::SiftDown
void SiftDown()
Sift down the element at the root.
Definition BinaryHeap.hpp:839
+
egoa::BinaryHeap::Comparator
void Comparator(std::function< bool(TElement const &, TElement const &)> comparator)
Changes the comparator.
Definition BinaryHeap.hpp:429
+
egoa::BinaryHeap::BinaryHeap
BinaryHeap(std::vector< TElement > const &elements)
Constructs a Min-heap of an vector.
Definition BinaryHeap.hpp:120
+
egoa::BinaryHeap::ComplyHeapProperty
bool ComplyHeapProperty() const
Checks if the heap complies with the heap property.
Definition BinaryHeap.hpp:786
+
egoa::BinaryHeap::operator<<
friend std::ostream & operator<<(std::ostream &outputStream, BinaryHeap const &heap)
Writes the heap into an output stream.
Definition BinaryHeap.hpp:534
+
egoa::BinaryHeap::Comparator
std::function< bool(TElement const &, TElement const &) > const & Comparator() const
The comparator.
Definition BinaryHeap.hpp:410
+
egoa::BinaryHeap::BuildWith
void BuildWith(std::vector< TElement > const &elements)
Builds a heap.
Definition BinaryHeap.hpp:274
+
egoa::BinaryHeap::Pop
void Pop()
Deletes the top element.
Definition BinaryHeap.hpp:289
+
egoa::BinaryHeap::Insert
void Insert(InputIt first, InputIt last)
Inserts the elements from the range [first, last).
Definition BinaryHeap.hpp:231
+
egoa::BinaryHeap::MakeHeapProperty
void MakeHeapProperty()
Makes a heap property.
Definition BinaryHeap.hpp:751
+
egoa::BinaryHeap::Clear
void Clear()
Clears the heap.
Definition BinaryHeap.hpp:324
+
egoa::BinaryHeap::Front
TElement & Front()
The top element.
Definition BinaryHeap.hpp:684
+
egoa::BinaryHeap::SiftDown
void SiftDown(Types::index index)
Sift down the element at index.
Definition BinaryHeap.hpp:851
+
egoa::BinaryHeap::BinaryHeap
BinaryHeap()
Constructs an empty Min-heap.
Definition BinaryHeap.hpp:110
+
egoa::BinaryHeap::Maximize
void Maximize()
Changes the comparator to construct a max-heap.
Definition BinaryHeap.hpp:441
+
egoa::BinaryHeap::Insert
void Insert(TElement &&element)
Inserts an element into the heap.
Definition BinaryHeap.hpp:215
+
egoa::BinaryHeap::SiftUp
void SiftUp(Types::index index)
Sift up.
Definition BinaryHeap.hpp:819
+
egoa::BinaryHeap::Back
TElement & Back()
The last element.
Definition BinaryHeap.hpp:706
+
egoa::BinaryHeap::Front
TElement const & Front() const
The top element.
Definition BinaryHeap.hpp:695
+
egoa::BinaryHeap::SiftUp
void SiftUp()
Sift the last element up.
Definition BinaryHeap.hpp:807
+
egoa::internal::BinaryHeapCheck< Type, false >::IsEqualTo
static bool IsEqualTo(THeap const &lhs, THeap const &rhs)
Determines if it has same elements as the other binary heap.
Definition BinaryHeap.hpp:964
+
egoa::internal::BinaryHeapCheck< Type, true >::IsEqualTo
static bool IsEqualTo(THeap const &lhs, THeap const &rhs)
Determines if equal—in sense of order—to the \rhs binary heap.
Definition BinaryHeap.hpp:934
+
egoa::internal::BinaryHeapCheck
Class for binary heap check.
Definition BinaryHeap.hpp:44
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >::for_all_elements
static void for_all_elements(THeap &heap, FUNCTION function)
Iterate over all elements in the heap.
Definition BinaryHeap.hpp:1081
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >::for_all_elements
static void for_all_elements(THeap &heap, FUNCTION function)
Iterates over all elements in the heap.
Definition BinaryHeap.hpp:1006
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >::for_all_elements
static void for_all_elements(THeap &heap, FUNCTION function)
Iterate over all elements in the heap.
Definition BinaryHeap.hpp:1120
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >::for_all_elements
static void for_all_elements(THeap &heap, FUNCTION function)
Iterates over all elements in the heap.
Definition BinaryHeap.hpp:1045
+ +
egoa
Definition Color.cpp:15
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_block_cut_tree_8hpp_source.html b/_block_cut_tree_8hpp_source.html new file mode 100644 index 00000000..cea4d072 --- /dev/null +++ b/_block_cut_tree_8hpp_source.html @@ -0,0 +1,556 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/BlockCutTree.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BlockCutTree.hpp
+
+
+
1/*
+
2 * BlockCutTree.hpp
+
3 *
+
4 * Created on: May 14, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7#ifndef EGOA__DATA_STRUCTURES__GRAPHS__BLOCK_CUT_TREE__HPP
+
8#define EGOA__DATA_STRUCTURES__GRAPHS__BLOCK_CUT_TREE__HPP
+
9
+
10#include <functional>
+
11#include <stack>
+
12#include <utility>
+
13#include <vector>
+
14
+
15#include "Algorithms/GraphTraversal/ArticulationVertexDetection.hpp"
+
16#include "Algorithms/GraphTraversal/DepthFirstSearch.hpp"
+
17
+
18#include "Auxiliary/Constants.hpp"
+
19#include "Auxiliary/Types.hpp"
+
20
+
21#include "DataStructures/Graphs/Subgraph.hpp"
+
22
+
23#include "Exceptions/Assertions.hpp"
+
24
+
25namespace egoa {
+
26
+
34
+
35namespace internal {
+
36 template<typename GraphType>
+
37 class BlockCutTreeBuilder;
+
38} // namespace internal
+
39
+
51template<typename GraphType>
+
+
52class BlockCutTree final {
+
53public:
+
54 class Block;
+
55 class CutVertex;
+
56
+
57 using TGraph = GraphType;
+
58
+
59private:
+
60 BlockCutTree(TGraph const & graph)
+
61 : graph_(graph),
+
62 blocks_(),
+
63 cutVertices_(graph.NumberOfVertices()),
+
64 blockOfEdge_(graph.NumberOfEdges(), Const::NONE),
+
65 blocksOfVertex_(graph.NumberOfVertices()),
+
66 numberOfCutVertices_(0)
+
67 {}
+
68
+
69public:
+
70
+
+
78 static BlockCutTree Build(TGraph const & graph) {
+
79 internal::BlockCutTreeBuilder builder(graph);
+
80 return builder.Build();
+
81 }
+
+
82
+
85#pragma mark BASIC_PROPERTIES
+
+
91 Types::count NumberOfBlocks() const {
+
92 return blocks_.size();
+
93 }
+
+
94
+
+
100 Types::count NumberOfCutVertices() const {
+
101 return numberOfCutVertices_;
+
102 }
+
+
103
+
+
109 TGraph const & Graph() const {
+
110 return graph_;
+
111 }
+
+
113
+
116#pragma mark TOPOLOGY
+
+
125 std::vector<Types::blockId> const & BlocksOfVertex(Types::vertexId id) const {
+
126 return blocksOfVertex_[id];
+
127 }
+
+
128
+
+
136 Types::blockId BlockOfEdge(Types::edgeId id) const {
+
137 return blockOfEdge_[id];
+
138 }
+
+
139
+
+
147 bool IsCutVertex(Types::vertexId id) const {
+
148 return BlocksOfVertex(id).size() > 1;
+
149 }
+
+
150
+
+
158 Block const & BlockAt(Types::blockId id) const {
+
159 return blocks_[id];
+
160 }
+
+
161
+
+
171 CutVertex const & CutVertexAt(Types::vertexId id) const {
+
172 USAGE_ASSERT(IsCutVertex(id));
+
173 return cutVertices_[id];
+
174 }
+
+
176
+
+
182 class Block final {
+
183 public:
+
184 Block(Types::blockId identifier,
+
185 Subgraph<TGraph const> subgraph,
+
186 std::vector<Types::vertexId> cutVertices)
+
187 : identifier_(identifier),
+
188 subgraph_(std::move(subgraph)),
+
189 cutVertices_(std::move(cutVertices))
+
190 {}
+
191
+
+
197 Types::blockId Identifier() const {
+
198 return identifier_;
+
199 }
+
+
200
+
+
206 egoa::Subgraph<TGraph const> const & Subgraph() const {
+
207 return subgraph_;
+
208 }
+
+
209
+
+
215 std::vector<Types::vertexId> const & CutVertices() const {
+
216 return cutVertices_;
+
217 }
+
+
218
+
+
224 bool IsLeaf() const {
+
225 return CutVertices().size() <= 1;
+
226 }
+
+
227
+
+
235 bool IsBridge() const {
+
236 return Subgraph().Edges().size() == 1;
+
237 }
+
+
238
+
239 private:
+
240 friend class egoa::internal::BlockCutTreeBuilder<TGraph>;
+
241
+
242 Types::blockId identifier_;
+
243 egoa::Subgraph<TGraph const> subgraph_;
+
244 Types::vertexId parent_;
+
245 std::vector<Types::vertexId> cutVertices_;
+
246 };
+
+
247
+
+
253 class CutVertex {
+
254 public:
+
255 CutVertex()
+
256 : identifier_(Const::NONE),
+
257 blocks_()
+
258 {}
+
259
+
260 CutVertex(Types::vertexId identifier,
+
261 std::vector<Types::blockId> blocks)
+
262 : identifier_(identifier),
+
263 blocks_(blocks)
+
264 {}
+
265
+
+
273 Types::vertexId Identifier() const {
+
274 return identifier_;
+
275 }
+
+
276
+
+
282 std::vector<Types::blockId> const & Blocks() const {
+
283 return blocks_;
+
284 }
+
+
285
+
286 private:
+
287 friend class egoa::internal::BlockCutTreeBuilder<TGraph>;
+
288
+
289 Types::vertexId identifier_;
+
290 std::vector<Types::blockId> blocks_;
+
291 };
+
+
292
+
293 friend class egoa::internal::BlockCutTreeBuilder<TGraph>;
+
294
+
295#pragma mark MEMBERS
+
298private:
+
299
+
306 std::reference_wrapper<TGraph const> graph_;
+
311 std::vector<Block> blocks_;
+
319 std::vector<CutVertex> cutVertices_;
+
325 std::vector<Types::blockId> blockOfEdge_;
+
335 std::vector<std::vector<Types::blockId>> blocksOfVertex_;
+
336
+
343 Types::count numberOfCutVertices_;
+
345};
+
+
346
+
362template<typename GraphType>
+
+
363BlockCutTree<GraphType> buildBlockCutTree(GraphType const & graph) {
+
364 return BlockCutTree<GraphType>::Build(graph);
+
365}
+
+
366
+
367namespace internal {
+
368
+
376template<typename GraphType>
+
+
377class BlockCutTreeBuilder final : private ArticulationVertexDetection<GraphType, false> {
+
378 class BlockUnderConstruction;
+
379
+
380 using TGraph = GraphType;
+
381 using TVertexId = typename TGraph::TVertexId;
+
382 using TEdgeId = typename TGraph::TEdgeId;
+
383 using TDetection = ::egoa::ArticulationVertexDetection<TGraph, false>;
+
384 using TTime = typename DepthFirstSearch<GraphType, false>::TTime;
+
385
+
386 template<typename T>
+
387 using VectorStack = std::stack<T, std::vector<T>>;
+
388
+
389
+
390public:
+
+
396 BlockCutTreeBuilder(TGraph const & graph)
+
397 : TDetection(graph, graph.Vertices()[0].Identifier()),
+
398 graph_(graph),
+
399 bcTree_(graph)
+
400 {}
+
+
401
+
+
407 BlockCutTree<TGraph> && Build() {
+
408 this->Run();
+
409
+
410 ESSENTIAL_ASSERT(blockStack_.empty());
+
411 ESSENTIAL_ASSERT(bcTree_.cutVertices_.size() == graph_.NumberOfVertices());
+
412 ESSENTIAL_ASSERT(bcTree_.blocks_.size() == nextBlockId_);
+
413
+
414 SortBlocks();
+
415 return std::move(bcTree_);
+
416 }
+
+
417
+
418private:
+
419
+
422#pragma mark ALGORITHM_STEPS
+
+
426 void SortBlocks() {
+
427 auto compareById = [](auto const & lhs, auto const & rhs) {
+
428 return lhs.Identifier() < rhs.Identifier();
+
429 };
+
430 using std::begin, std::end;
+
431 std::sort(begin(bcTree_.blocks_), end(bcTree_.blocks_), compareById);
+
432 }
+
+
434
+
435protected:
+
438#pragma mark TRAVERSAL
+
439 virtual void PostprocessingEdgeWith(TVertexId source,
+
440 TVertexId target,
+
441 TEdgeId edgeId) override {
+
442 TDetection::PostprocessingEdgeWith(source, target, edgeId);
+
443
+
444 if (this->ParentOf(source) == target) {
+
445 // Ignore edges that directly return to the parent.
+
446 return;
+
447 }
+
448
+
449 auto type = this->TypifyEdge(source, target);
+
450 if (type == DfsEdgeType::forward) {
+
451 // The edge has already been considered in the other direction.
+
452 return;
+
453 }
+
454
+
455 auto targetTime = this->TimeOfOldestReachableAncestor(target);
+
456
+
457 ESSENTIAL_ASSERT(blockStack_.empty()
+
458 || CurrentBlock().timeOfOldestVertex <= targetTime);
+
459
+
460 if (blockStack_.empty() || CurrentBlock().timeOfOldestVertex < targetTime) {
+
461 // We reached a new block
+
462 PushNextBlock(targetTime);
+
463 }
+
464
+
465 ESSENTIAL_ASSERT(CurrentBlock().timeOfOldestVertex == targetTime);
+
466
+
467 AddEdgeToCurrentBlock(edgeId);
+
468
+
469 // Vertices are added as the targets of the tree edges in the block.
+
470 // All vertex except the one via which a block is reached are reached
+
471 // exactly once via a tree edge.
+
472 // The remaining vertex is added is added when the last tree
+
473 // edge of the block is backtracked.
+
474 if (type == DfsEdgeType::tree) {
+
475 AddVertexToCurrentBlock(target);
+
476 if (this->IsArticulationVertexAt(target)) {
+
477 AddCutVertexToBlock(target);
+
478 }
+
479 }
+
480
+
481 // If the source of the block was reached at or before
+
482 // CurrentBlock().timeOfOldestVertex, it is the oldest vertex of the block
+
483 // and all edges of the block have been collected.
+
484 if (this->EntryTimeAt(source) <= CurrentBlock().timeOfOldestVertex) {
+
485 AddVertexToCurrentBlock(source);
+
486 if (this->IsArticulationVertexAt(source)) {
+
487 AddCutVertexToBlock(source);
+
488 }
+
489 PopBlock();
+
490 }
+
491 }
+
492
+
493 virtual void PostprocessingVertexWith(Types::vertexId vertex) override {
+
494 TDetection::PostprocessingVertexWith(vertex);
+
495
+
496 if (this->IsArticulationVertexAt(vertex)) {
+
497 ++bcTree_.numberOfCutVertices_;
+
498 }
+
499 }
+
501
+
502private:
+
505#pragma mark ADDING_BLOCKS
+
+
509 void PushNextBlock(TTime time) {
+
510 blockStack_.emplace(nextBlockId_++, time);
+
511 }
+
+
512
+
+
516 void PopBlock() {
+
517 bcTree_.blocks_.push_back(std::move(blockStack_.top()).ToBlock(graph_));
+
518 blockStack_.pop();
+
519 }
+
+
520
+
+
526 void AddEdgeToCurrentBlock(TEdgeId edge) {
+
527 bcTree_.blockOfEdge_[edge] = CurrentBlockId();
+
528 CurrentBlock().edges.push_back(edge);
+
529 }
+
+
530
+
+
536 void AddVertexToCurrentBlock(TVertexId vertex) {
+
537 bcTree_.blocksOfVertex_[vertex].push_back(CurrentBlockId());
+
538 CurrentBlock().vertices.push_back(vertex);
+
539 }
+
+
540
+
541 void AddCutVertexToBlock(TVertexId vertex) {
+
542 ESSENTIAL_ASSERT(this->IsArticulationVertexAt(vertex));
+
543 bcTree_.cutVertices_[vertex].blocks_.push_back(CurrentBlockId());
+
544 bcTree_.cutVertices_[vertex].identifier_ = vertex;
+
545 CurrentBlock().cutVertices.push_back(vertex);
+
546 }
+
547
+
+
553 Types::index CurrentBlockId() const {
+
554 ESSENTIAL_ASSERT(!blockStack_.empty());
+
555 return blockStack_.top().identifier;
+
556 }
+
+
557
+
558 BlockUnderConstruction & CurrentBlock() {
+
559 ESSENTIAL_ASSERT(!blockStack_.empty());
+
560 return blockStack_.top();
+
561 }
+
563
+
+
564 struct BlockUnderConstruction {
+
565 using TBlock = typename BlockCutTree<TGraph>::Block;
+
566
+
567 BlockUnderConstruction(Types::blockId id, TTime time)
+
568 : identifier(id),
+
569 timeOfOldestVertex(time)
+
570 {}
+
571
+
572 Types::blockId identifier;
+
573 TTime timeOfOldestVertex;
+
574 std::vector<TVertexId> vertices;
+
575 std::vector<TEdgeId> edges;
+
576 std::vector<TVertexId> cutVertices;
+
577
+
578 TBlock ToBlock(TGraph const & graph) && {
+
579 return TBlock(identifier,
+
580 Subgraph(&graph, std::move(vertices), std::move(edges)),
+
581 std::move(cutVertices));
+
582 }
+
583 };
+
+
584
+
585#pragma mark MEMBERS
+
586
+
587 TGraph const & graph_;
+
588 egoa::BlockCutTree<TGraph> bcTree_;
+
589 Types::index nextBlockId_ = 0;
+
590 VectorStack<BlockUnderConstruction> blockStack_;
+
591};
+
+
592
+
593} // namespace internal
+
594
+
595} // namespace egoa
+
596
+
597
+
598#endif // EGOA__DATA_STRUCTURES__GRAPHS__BLOCK_CUT_TREE__HPP
+
egoa::ArticulationVertexDetection
Class to find articulation vertices.
Definition ArticulationVertexDetection.hpp:26
+
egoa::ArticulationVertexDetection::PostprocessingEdgeWith
virtual void PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) override
Post processing the edge with edgeId.
Definition ArticulationVertexDetection.hpp:100
+
egoa::ArticulationVertexDetection::PostprocessingVertexWith
virtual void PostprocessingVertexWith(TVertexId vertexId) override
Decide which vertices are articulation vertices.
Definition ArticulationVertexDetection.hpp:131
+
egoa::ArticulationVertexDetection< GraphType, false >::IsArticulationVertexAt
bool IsArticulationVertexAt(TVertexId const vertex) const
Whether the vertex is an articulation vertex.
Definition ArticulationVertexDetection.hpp:218
+ +
egoa::BlockCutTree::Block::Identifier
Types::blockId Identifier() const
The identifier of the block.
Definition BlockCutTree.hpp:197
+
egoa::BlockCutTree::Block::CutVertices
std::vector< Types::vertexId > const & CutVertices() const
The cut-vertices of the block.
Definition BlockCutTree.hpp:215
+
egoa::BlockCutTree::Block::IsLeaf
bool IsLeaf() const
Whether the block is a leaf of the block-cut tree.
Definition BlockCutTree.hpp:224
+
egoa::BlockCutTree::Block::IsBridge
bool IsBridge() const
Whether the block is a bridge.
Definition BlockCutTree.hpp:235
+
egoa::BlockCutTree::Block::Subgraph
egoa::Subgraph< TGraph const > const & Subgraph() const
The subgraph forming the block.
Definition BlockCutTree.hpp:206
+
egoa::BlockCutTree::CutVertex
Class for cut-vertices.
Definition BlockCutTree.hpp:253
+
egoa::BlockCutTree::CutVertex::Identifier
Types::vertexId Identifier() const
The vertex identifier.
Definition BlockCutTree.hpp:273
+
egoa::BlockCutTree::CutVertex::Blocks
std::vector< Types::blockId > const & Blocks() const
The blocks the cut-vertex belongs to.
Definition BlockCutTree.hpp:282
+
egoa::BlockCutTree
A block-cut tree.
Definition BlockCutTree.hpp:52
+
egoa::BlockCutTree::numberOfCutVertices_
Types::count numberOfCutVertices_
The number of cut-vertices.
Definition BlockCutTree.hpp:343
+
egoa::BlockCutTree::IsCutVertex
bool IsCutVertex(Types::vertexId id) const
Whether a vertex is a cut-vertex.
Definition BlockCutTree.hpp:147
+
egoa::BlockCutTree::blockOfEdge_
std::vector< Types::blockId > blockOfEdge_
For each edge the block it belongs to.
Definition BlockCutTree.hpp:325
+
egoa::BlockCutTree::NumberOfBlocks
Types::count NumberOfBlocks() const
The number of blocks in the block-cut tree.
Definition BlockCutTree.hpp:91
+
egoa::BlockCutTree::BlockOfEdge
Types::blockId BlockOfEdge(Types::edgeId id) const
The identifiers of the block an edge belongs to.
Definition BlockCutTree.hpp:136
+
egoa::BlockCutTree::BlocksOfVertex
std::vector< Types::blockId > const & BlocksOfVertex(Types::vertexId id) const
All identifiers of the blocks a vertex belongs to.
Definition BlockCutTree.hpp:125
+
egoa::BlockCutTree::Graph
TGraph const & Graph() const
The underlying graph of the block-cut tree.
Definition BlockCutTree.hpp:109
+
egoa::BlockCutTree::Build
static BlockCutTree Build(TGraph const &graph)
Builds a BlockCutTree for a given graph.
Definition BlockCutTree.hpp:78
+
egoa::BlockCutTree::blocksOfVertex_
std::vector< std::vector< Types::blockId > > blocksOfVertex_
For each vertex the blocks it belongs to.
Definition BlockCutTree.hpp:335
+
egoa::BlockCutTree::BlockAt
Block const & BlockAt(Types::blockId id) const
The block with identifier id.
Definition BlockCutTree.hpp:158
+
egoa::BlockCutTree::NumberOfCutVertices
Types::count NumberOfCutVertices() const
The number of cut-vertices in the block-cut tree.
Definition BlockCutTree.hpp:100
+
egoa::BlockCutTree::CutVertexAt
CutVertex const & CutVertexAt(Types::vertexId id) const
The cut-vertex with identifier id.
Definition BlockCutTree.hpp:171
+
egoa::BlockCutTree::cutVertices_
std::vector< CutVertex > cutVertices_
The cut-vertices in the graph.
Definition BlockCutTree.hpp:319
+
egoa::BlockCutTree::blocks_
std::vector< Block > blocks_
The blocks in the block-cut tree ordered by their component identifiers.
Definition BlockCutTree.hpp:311
+
egoa::BlockCutTree::graph_
std::reference_wrapper< TGraph const > graph_
The underlying graph.
Definition BlockCutTree.hpp:306
+
egoa::DepthFirstSearch< GraphType, IsDirected >::TypifyEdge
DfsEdgeType TypifyEdge(TVertexId source, TVertexId target)
Determine DFS edge type.
Definition DepthFirstSearch.hpp:127
+
egoa::DepthFirstSearch< GraphType, IsDirected >::EntryTimeAt
TTime EntryTimeAt(TVertexId vertexId) const
{ function_description }
Definition DepthFirstSearch.hpp:188
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
egoa::Subgraph::Edges
TEdgesView Edges() const
A view on the identifiers of the edges in the subgraph.
Definition Subgraph.hpp:99
+
egoa::Traversal< GraphType, IsDirected >::ParentOf
TVertexId & ParentOf(TVertexId vertexId)
Getter and setter for the parent relation.
Definition Traversal.hpp:152
+
egoa::internal::BlockCutTreeBuilder
A class to build BlockCutTree objects for a graph.
Definition BlockCutTree.hpp:377
+
egoa::internal::BlockCutTreeBuilder::CurrentBlockId
Types::index CurrentBlockId() const
The identifier of the current block.
Definition BlockCutTree.hpp:553
+
egoa::internal::BlockCutTreeBuilder::SortBlocks
void SortBlocks()
Sort all blocks in bcTree_.blocks_.
Definition BlockCutTree.hpp:426
+
egoa::internal::BlockCutTreeBuilder::PushNextBlock
void PushNextBlock(TTime time)
Initializes the next block.
Definition BlockCutTree.hpp:509
+
egoa::internal::BlockCutTreeBuilder::BlockCutTreeBuilder
BlockCutTreeBuilder(TGraph const &graph)
The constructor.
Definition BlockCutTree.hpp:396
+
egoa::internal::BlockCutTreeBuilder::PopBlock
void PopBlock()
Pops a block and adds it to the block-cut tree.
Definition BlockCutTree.hpp:516
+
egoa::internal::BlockCutTreeBuilder::Build
BlockCutTree< TGraph > && Build()
Builds the block-cut tree.
Definition BlockCutTree.hpp:407
+
egoa::internal::BlockCutTreeBuilder::AddVertexToCurrentBlock
void AddVertexToCurrentBlock(TVertexId vertex)
Adds a vertex to the current block.
Definition BlockCutTree.hpp:536
+
egoa::internal::BlockCutTreeBuilder::AddEdgeToCurrentBlock
void AddEdgeToCurrentBlock(TEdgeId edge)
Adds an edge to the current block.
Definition BlockCutTree.hpp:526
+
egoa::buildBlockCutTree
BlockCutTree< GraphType > buildBlockCutTree(GraphType const &graph)
Builds a block-cut tree.
Definition BlockCutTree.hpp:363
+
egoa
Definition Color.cpp:15
+ +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_block_cut_tree_traversal_8hpp_source.html b/_block_cut_tree_traversal_8hpp_source.html new file mode 100644 index 00000000..a1541a37 --- /dev/null +++ b/_block_cut_tree_traversal_8hpp_source.html @@ -0,0 +1,273 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/BlockCutTreeTraversal.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BlockCutTreeTraversal.hpp
+
+
+
1/*
+
2 * BlockCutTreeTraversal.hpp
+
3 *
+
4 * Created on: May 27, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__BLOCK_CUT_TREE_TRAVERSAL_HPP
+
9#define EGOA__ALGORITHMS__BLOCK_CUT_TREE_TRAVERSAL_HPP
+
10
+
11#include <functional>
+
12#include <utility>
+
13#include <variant>
+
14
+
15#include "DataStructures/Graphs/BlockCutTree.hpp"
+
16
+
17#include "Exceptions/Assertions.hpp"
+
18
+
19namespace egoa {
+
20
+
38template<typename GraphType>
+
+
39class BlockCutTreeTraversal {
+
40public:
+
41 using TGraph = GraphType;
+
42 using TTree = BlockCutTree<TGraph>;
+
43 using Block = typename TTree::Block;
+
44 using CutVertex = typename TTree::CutVertex;
+
45 using TNode = std::variant<std::reference_wrapper<Block const>,
+
46 std::reference_wrapper<CutVertex const>>;
+
47
+
48
+
51#pragma mark CONSTRUCTORS
+
+
60 BlockCutTreeTraversal(BlockCutTree<TGraph> const & bcTree)
+
61 : BlockCutTreeTraversal(bcTree, std::cref(bcTree.BlockAt(0)))
+
62 {}
+
+
63
+
+
71 BlockCutTreeTraversal(BlockCutTree<TGraph> const & bcTree,
+
72 TNode root)
+
73 : bcTree_(bcTree),
+
74 root_(std::move(root)),
+
75 rootId_(NodeToId(root_))
+
76 {}
+
+
77
+
+
85 BlockCutTreeTraversal(BlockCutTree<TGraph> const & bcTree,
+
86 CutVertex const & root)
+
87 : bcTree_(bcTree),
+
88 root_(root)
+
89 {}
+
+
91
+
94#pragma mark ACCESSORS
+
95 TNode & Root() {
+
96 return root_;
+
97 }
+
98
+
99 TNode const & Root() const {
+
100 return root_;
+
101 }
+
103
+
106#pragma mark ALGORITHM_EXECUTION
+
+
110 void Run() {
+
111 nodeStack_.push(rootId_);
+
112
+
113 while (!nodeStack_.empty()) {
+
114 Types::index currentId = nodeStack_.top();
+
115
+
116 if (visited_[currentId]) {
+
117 // All children of the current node have been visited.
+
118 nodeStack_.pop();
+
119 if (currentId == rootId_) {
+
120 VisitRoot(root_);
+
121 } else if (IsBlock(currentId)) {
+
122 auto const & block = BlockAt(currentId);
+
123 if (block.IsLeaf()) {
+
124 VisitLeaf(block);
+
125 } else {
+
126 VisitBlock(block);
+
127 }
+
128 } else {
+
129 VisitCutVertex(CutVertexAt(currentId));
+
130 }
+
131 } else {
+
132 // We are visiting the node for the first time and have to visit
+
133 // all its children first.
+
134 visited_[currentId] = true;
+
135 if (IsBlock(currentId)) {
+
136 auto const & block = BlockAt(currentId);
+
137 for (Types::vertexId neighbor : block.CutVertices()) {
+
138 if (visited_[neighbor]) continue;
+
139 nodeStack_.push(neighbor);
+
140 }
+
141 } else {
+
142 auto const & cutVertex = CutVertexAt(currentId);
+
143 for (Types::blockId neighbor : cutVertex.Blocks()) {
+
144 Types::index normalizedId = bcTree_.Graph().NumberOfVertices() + neighbor;
+
145 if (visited_[normalizedId]) continue;
+
146 nodeStack_.push(normalizedId);
+
147 }
+
148 }
+
149 }
+
150 }
+
151 }
+
+
153
+
154protected:
+
157#pragma mark VISITING
+
167 virtual void VisitLeaf(Block const & block) {};
+
168
+
177 virtual void VisitCutVertex(CutVertex const & cutVertex) {};
+
178
+
187 virtual void VisitBlock(Block const & block) {};
+
188
+
194 virtual void VisitRoot(TNode root) {};
+
196
+
197private:
+
198
+
201#pragma mark AUXILIARY
+
202 bool IsBlock(Types::index id) const {
+
203 ESSENTIAL_ASSERT(id < visited_.size());
+
204 return id >= bcTree_.Graph().NumberOfVertices();
+
205 }
+
206
+
207 bool IsCutVertex(Types::index id) const {
+
208 ESSENTIAL_ASSERT(id < visited_.size());
+
209 return id < bcTree_.Graph().NumberOfVertices();
+
210 }
+
211
+
212 Types::index NodeToId(TNode const & node) const {
+
213 if (std::holds_alternative<std::reference_wrapper<Block const>>(node)) {
+
214 return std::get<std::reference_wrapper<Block const>>(node).get().Identifier()
+
215 + bcTree_.Graph().NumberOfVertices();
+
216 } else {
+
217 return std::get<std::reference_wrapper<CutVertex const>>(node).get().Identifier();
+
218 }
+
219 }
+
220
+
221 Block const & BlockAt(Types::index identifier) const {
+
222 ESSENTIAL_ASSERT(IsBlock(identifier));
+
223 return bcTree_.BlockAt(identifier - bcTree_.Graph().NumberOfVertices());
+
224 }
+
225
+
226 CutVertex const & CutVertexAt(Types::index identifier) const {
+
227 ESSENTIAL_ASSERT(IsCutVertex(identifier));
+
228 return bcTree_.CutVertexAt(identifier);
+
229 }
+
231
+
234#pragma mark INPUT_MEMBERS
+
235 BlockCutTree<TGraph> const & bcTree_;
+
236 TNode root_;
+
237 Types::index rootId_;
+
239
+
242#pragma mark TRAVERSAL_MEMBERS
+
250 std::stack<Types::index, std::vector<Types::index>> nodeStack_;
+
254 std::vector<bool> visited_ = std::vector<bool>(bcTree_.Graph().NumberOfVertices() + bcTree_.NumberOfBlocks(), false);
+
256};
+
+
257
+
258} // namespace egoa
+
259
+
260#endif //EGOA__ALGORITHMS__BLOCK_CUT_TREE_TRAVERSAL_HPP
+ +
egoa::BlockCutTree::Graph
TGraph const & Graph() const
The underlying graph of the block-cut tree.
Definition BlockCutTree.hpp:109
+
egoa::BlockCutTree::BlockAt
Block const & BlockAt(Types::blockId id) const
The block with identifier id.
Definition BlockCutTree.hpp:158
+
egoa::BlockCutTree::CutVertexAt
CutVertex const & CutVertexAt(Types::vertexId id) const
The cut-vertex with identifier id.
Definition BlockCutTree.hpp:171
+
egoa::BlockCutTreeTraversal
Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly af...
Definition BlockCutTreeTraversal.hpp:39
+
egoa::BlockCutTreeTraversal::BlockCutTreeTraversal
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, TNode root)
A constructor.
Definition BlockCutTreeTraversal.hpp:71
+
egoa::BlockCutTreeTraversal::visited_
std::vector< bool > visited_
Whether the node with the given identifier has been visited.
Definition BlockCutTreeTraversal.hpp:254
+ +
egoa::BlockCutTreeTraversal::VisitRoot
virtual void VisitRoot(TNode root)
This function is called for the root.
Definition BlockCutTreeTraversal.hpp:194
+
egoa::BlockCutTreeTraversal::BlockCutTreeTraversal
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree)
A constructor.
Definition BlockCutTreeTraversal.hpp:60
+
egoa::BlockCutTreeTraversal::VisitLeaf
virtual void VisitLeaf(Block const &block)
This function is called for each leaf.
Definition BlockCutTreeTraversal.hpp:167
+
egoa::BlockCutTreeTraversal::VisitCutVertex
virtual void VisitCutVertex(CutVertex const &cutVertex)
This function is called for each cut-vertex.
Definition BlockCutTreeTraversal.hpp:177
+
egoa::BlockCutTreeTraversal::VisitBlock
virtual void VisitBlock(Block const &block)
This function is called for each inner block.
Definition BlockCutTreeTraversal.hpp:187
+
egoa::BlockCutTreeTraversal::BlockCutTreeTraversal
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, CutVertex const &root)
A constructor.
Definition BlockCutTreeTraversal.hpp:85
+
egoa::BlockCutTreeTraversal::nodeStack_
std::stack< Types::index, std::vector< Types::index > > nodeStack_
The identifiers of the nodes on the stack.
Definition BlockCutTreeTraversal.hpp:250
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_bound_8hpp_source.html b/_bound_8hpp_source.html new file mode 100644 index 00000000..58c712cb --- /dev/null +++ b/_bound_8hpp_source.html @@ -0,0 +1,214 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Bound.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Bound.hpp
+
+
+
1/*
+
2 * Bound.hpp
+
3 *
+
4 * Created on: Sep 06, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURE__BOUND_HPP
+
9#define EGOA__DATA_STRUCTURE__BOUND_HPP
+
10
+
11#include "Exceptions/Exceptions.hpp"
+
12#include "Exceptions/Assertions.hpp"
+
13
+
14namespace egoa {
+
15
+
21template<typename BoundType = double>
+
+
22class Bound {
+
23 private:
+
24#pragma mark TYPE_ALIASING
+
25 using TBound = BoundType;
+
27 public:
+
30#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
31
+
32 Bound() = delete;
+
33
+
+
40 Bound ( TBound const & minimum
+
41 , TBound const & maximum )
+
42 : minimum_(minimum)
+
43 , maximum_(maximum)
+
44 {
+
45#ifdef PGT_EXCEPTION_HANDLING
+
46 BoundMismatch::template Check<TBound>(minimum, maximum);
+
47#endif
+
48 USAGE_ASSERT ( minimum_ <= maximum_ );
+
49 }
+
+
51
+
54#pragma mark GETTER_AND_SETTER
+
55
+
+
61 inline TBound Minimum () const
+
62 {
+
63 return minimum_;
+
64 }
+
+
65
+
+
75 inline TBound & Minimum ()
+
76 {
+
77 return minimum_;
+
78 }
+
+
79
+
+
85 inline TBound Maximum() const
+
86 {
+
87 return maximum_;
+
88 }
+
+
89
+
+
99 inline TBound & Maximum()
+
100 {
+
101 return maximum_;
+
102 }
+
+
104
+
107#pragma mark MODIFIER
+
108
+
+
115 inline void Range ( TBound const & minimum
+
116 , TBound const & maximum )
+
117 {
+
118#ifdef PGT_EXCEPTION_HANDLING
+
119 BoundMismatch::template Check<TBound>(minimum, maximum);
+
120#endif
+
121 USAGE_ASSERT ( minimum <= maximum );
+
122 minimum_ = minimum;
+
123 maximum_ = maximum;
+
124
+
125 USAGE_ASSERT ( minimum_ <= maximum_ );
+
126 }
+
+
128
+
131#pragma mark COMPARATORS
+
132
+
+
144 inline bool operator== ( Bound<TBound> const & rhs ) const
+
145 {
+
146 return ( this->Minimum() == rhs.Minimum() )
+
147 && ( this->Maximum() == rhs.Maximum() );
+
148 }
+
+
149
+
150 inline bool operator!= ( Bound<TBound> const & rhs ) const
+
151 {
+
152 return !(*this == rhs);
+
153 }
+
155
+
156 private:
+
159#pragma mark MEMBERS
+
160
+
161 TBound minimum_;
+
162 TBound maximum_;
+
164};
+
+
165
+
166} // gpgt
+
167
+
168#endif // EGOA__DATA_STRUCTURE__BOUND_HPP
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+
egoa::Bound::operator==
bool operator==(Bound< TBound > const &rhs) const
Comparison operator.
Definition Bound.hpp:144
+
egoa::Bound::Bound
Bound(TBound const &minimum, TBound const &maximum)
Constructs the object.
Definition Bound.hpp:40
+
egoa::Bound::Range
void Range(TBound const &minimum, TBound const &maximum)
Set the range of the bound.
Definition Bound.hpp:115
+
egoa::Bound::Minimum
TBound Minimum() const
Getter of the minimum of the bound.
Definition Bound.hpp:61
+
egoa::Bound::Maximum
TBound Maximum() const
Getter of the maximum of the bound.
Definition Bound.hpp:85
+
egoa::Bound::TBound
BoundType TBound
Definition Bound.hpp:25
+
egoa::Bound::Maximum
TBound & Maximum()
Setter of the maximum of the bound.
Definition Bound.hpp:99
+
egoa::Bound::Minimum
TBound & Minimum()
Setter of the minimum of the bound.
Definition Bound.hpp:75
+
egoa::Bound::minimum_
TBound minimum_
Definition Bound.hpp:161
+
egoa::Bound::maximum_
TBound maximum_
Definition Bound.hpp:162
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_breadth_first_search_8hpp_source.html b/_breadth_first_search_8hpp_source.html new file mode 100644 index 00000000..05db313f --- /dev/null +++ b/_breadth_first_search_8hpp_source.html @@ -0,0 +1,207 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal/BreadthFirstSearch.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BreadthFirstSearch.hpp
+
+
+
1/*
+
2 * BreadthFirstSearch.hpp
+
3 *
+
4 * Created on: Jan 27, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__ALGORITHMS__GRAPH_TRAVERSAL__BREADTH_FIRST_SEARCH__HPP
+
8#define EGOA__ALGORITHMS__GRAPH_TRAVERSAL__BREADTH_FIRST_SEARCH__HPP
+
9
+
10#include "Algorithms/GraphTraversal/Traversal.hpp"
+
11#include "DataStructures/Container/Queues/StdQueue.hpp"
+
12
+
13namespace egoa {
+
14
+
36template< typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>
+
37 , typename QueueType = StdQueue<GraphType::TVertexId>
+
38 , bool IsDirected= false >
+
+
39class BFS final : Traversal<IsDirected> {
+
40 public:
+
41 // Type aliasing
+
42 using TQueue = QueueType;
+
43
+
44 public:
+
45#pragma mark CONSTRUCTOR_AND_DESTRUCTOR
+
46 BFS ( TGraph const & graph, TVertex source )
+
47 : TTraversal ( graph, source )
+
48 , queue_()
+
49 {}
+
50
+
51 virtual ~BFS() {}
+
52
+
53#pragma mark BREADTH_FIRST_SEARCH
+
+
57 virtual inline void Run() {
+
58 ESSENTIAL_ASSERT ( queue_.Empty() );
+
59
+
60 EnqueueVertexWith ( source_ );
+
61 SetVertexVisitedAt ( source_ );
+
62
+
63 while ( !queue_.Empty() ) {
+
64 ESSENTIAL_ASSERT ( queue_.Empty() );
+
65 TVertex sourceId = DequeueVertex();
+
66 ESSENTIAL_ASSERT ( graph_.VertexExists ( sourceId ) );
+
67 ESSENTIAL_ASSERT ( VisitedVertexAt ( sourceId ) );
+
68
+
69 PreprocessingVertexWith ( sourceId );
+
70 SetVertexProcessedAt ( sourceId );
+
71
+
72 for_all_edges_at( sourceId, []( ElectricalEdge & edge ) {
+
73 TVertex targetId = edge.Other ( sourceId );
+
74 ESSENTIAL_ASSERT ( graph_.VertexExists ( targetId ) );
+
75
+
76 if ( !ProcessedVertexAt( targetId ) || graph_.IsDirected() ) {
+
77 ProcessingEdgeWith ( edge.Identifier() );
+
78 }
+
79 if ( !VisitedVertexAt( targetId ) ) {
+
80 EnqueueVertexWith ( targetId );
+
81 SetVertexVisitedAt ( targetId );
+
82 ParentOf ( targetId ) = sourceId;
+
83 }
+
84 });
+
85 PostprocessingVertexWith ( sourceId );
+
86 }
+
87 }
+
+
88
+
89 private:
+
90#pragma mark QUEUE_METHODS
+
+
98 inline void EnqueueVertexWith ( TVertex vertexId ) {
+
99 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
100 queue_.Push ( vertexId );
+
101 }
+
+
102
+
+
110 inline TVertex DequeueVertex ( ) {
+
111 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
112 TVertex vertexId = queue_.front();
+
113 queue_.Pop();
+
114 return vertexId;
+
115 }
+
+
116
+
117//exact behavior of the Breadth-First Search (BFS) depends on the processing methods
+
118#pragma mark FURTHER_PROCESSING
+
119 virtual inline void PreprocessingVertexWith ( TVertex vertexId ) override {}
+
120 virtual inline void PostprocessingVertexWith ( TVertex vertexId ) override {}
+
121 virtual inline void ProcessingEdgeWith ( TVertex sourceId
+
122 , TVertex targetId ) override {}
+
123
+
124#pragma mark MEMBERS
+
125 private:
+
126 TQueue queue_;
+
128}; // class BFS
+
+
129
+
130} // namespace egoa
+
131
+
132
+
133#endif // EGOA__ALGORITHMS__GRAPH_TRAVERSAL__BREADTH_FIRST_SEARCH__HPP
+
egoa::BFS
Class for the Breadth-First Search (BFS).
Definition BreadthFirstSearch.hpp:39
+
egoa::BFS::DequeueVertex
TVertex DequeueVertex()
Get the next unprocessed vertex.
Definition BreadthFirstSearch.hpp:110
+
egoa::BFS::EnqueueVertexWith
void EnqueueVertexWith(TVertex vertexId)
Add a vertex to the queue.
Definition BreadthFirstSearch.hpp:98
+
egoa::BFS::Run
virtual void Run()
Run Breadth-First search (BFS).
Definition BreadthFirstSearch.hpp:57
+ +
egoa::Traversal
Interface for graph traversal.
Definition Traversal.hpp:36
+
egoa::Traversal::SetVertexProcessedAt
void SetVertexProcessedAt(TVertexId vertexId)
Sets the vertex at vertexId to processed.
Definition Traversal.hpp:119
+
egoa::Traversal::ProcessedVertexAt
bool ProcessedVertexAt(TVertexId vertexId) const
Getter and setter to access the process field.
Definition Traversal.hpp:135
+
egoa::Traversal::VisitedVertexAt
bool VisitedVertexAt(TVertexId vertexId) const
Getter and setter to access the visited field.
Definition Traversal.hpp:104
+
egoa::Traversal::ParentOf
TVertexId & ParentOf(TVertexId vertexId)
Getter and setter for the parent relation.
Definition Traversal.hpp:152
+
egoa::Traversal::graph_
TGraph const & graph_
Definition Traversal.hpp:271
+
egoa::Traversal::SetVertexVisitedAt
void SetVertexVisitedAt(TVertexId vertexId)
Sets the vertex at vertexId to visited.
Definition Traversal.hpp:89
+
egoa::Traversal::source_
TVertexId source_
Definition Traversal.hpp:273
+
egoa::Traversal::for_all_edges_at
void for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges.
Definition Traversal.hpp:257
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_bucket_8hpp_source.html b/_bucket_8hpp_source.html new file mode 100644 index 00000000..730b1b76 --- /dev/null +++ b/_bucket_8hpp_source.html @@ -0,0 +1,837 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/Bucket.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Bucket.hpp
+
+
+
1/*
+
2 * Bucket.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__QUEUES__BUCKET_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__QUEUES__BUCKET_HPP
+
10
+
11#include "Auxiliary/ExecutionPolicy.hpp"
+
12
+
13#include "Exceptions/Exceptions.hpp"
+
14#include "Exceptions/Assertions.hpp"
+
15
+
16#include "DataStructures/Container/DominationCriterion.hpp"
+
17
+
18#include "DataStructures/Container/Queues/PriorityQueue.hpp"
+
19#include "DataStructures/Container/Queues/BinaryHeap.hpp"
+
20
+
21#include "DataStructures/Labels/VoltageAngleDifferenceLabel.hpp"
+
22
+
23namespace egoa {
+
24
+
25namespace internal {
+
32template<typename BucketType, ExecutionPolicy Policy>
+
33class BucketLoopDifferentiation;
+
34} // namespace internal
+
35
+
64template< typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > > >
+
+
65class Bucket {
+
66 public:
+
67 // Type aliasing
+
68 using TPriorityQueue = PriorityQueue;
+
69 using TElement = typename TPriorityQueue::TElement;
+
70 using TBucket = Bucket< TPriorityQueue >;
+
71 using TIterator = std::iterator< std::input_iterator_tag
+
72 , TElement
+
73 , Types::largeNumber
+
74 , Types::largeNumber const *
+
75 , Types::largeNumber>; // @TODO deprecated
+
76 public:
+
79#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
80
+
+
84 Bucket ()
+
85 : processedElements_()
+
86 , unprocessedElements_()
+
87 , numberOfValidUnprocessedElements_(0)
+
88 {
+
89 Comparator( std::less<TElement>() );
+
90 }
+
+
92
+
107#pragma mark OPERATORS
+
108
+
109 inline bool operator< ( TBucket const & rhs ) const
+
110 {
+
111 USAGE_ASSERT ( !EmptyQueue() );
+
112 USAGE_ASSERT ( !rhs.EmptyQueue() );
+
113 return ( Top() < rhs.Top() );
+
114 }
+
115
+
116 inline bool operator> ( TBucket const & rhs ) const
+
117 {
+
118 USAGE_ASSERT ( !EmptyQueue() );
+
119 USAGE_ASSERT ( !rhs.EmptyQueue() );
+
120 return rhs < *this;
+
121 }
+
122
+
123 inline bool operator<= ( TBucket const & rhs ) const
+
124 {
+
125 USAGE_ASSERT ( !EmptyQueue() );
+
126 USAGE_ASSERT ( !rhs.EmptyQueue() );
+
127 return !(*this > rhs);
+
128 }
+
129
+
130 inline bool operator>= ( TBucket const & rhs ) const
+
131 {
+
132 USAGE_ASSERT ( !EmptyQueue() );
+
133 USAGE_ASSERT ( !rhs.EmptyQueue() );
+
134 return !(*this < rhs);
+
135 }
+
137
+
155#pragma mark MERGE_ELEMENTS
+
156
+
157 template<DominationCriterion Domination = DominationCriterion::weak>
+
158 inline bool Merge ( TElement && newElement )
+
159 {
+
160 newElement.Valid() = true;
+
161 for_all_elements<ExecutionPolicy::breakable>(
+
162 [&](TElement & element) -> bool
+
163 {
+
164 if ( internal::DominationDifferentiation<TElement, Domination>
+
165 ::Dominates( element, newElement, Comparator() ) ) {
+
166 newElement.Valid() = false;
+
167 return false; // break loop
+
168 } else if ( internal::DominationDifferentiation<TElement, Domination>
+
169 ::Dominates( newElement, element, Comparator() ) ) {
+
170 // Note that this can only be a label from the unprocessed range
+
171 element.Valid() = false;
+
172 --numberOfValidUnprocessedElements_;
+
173 }
+
174 // also covers DominationCriterion::none
+
175 return true;
+
176 }
+
177 );
+
178
+
179 if ( !newElement.Valid() )
+
180 {
+
181 PopInvalidUnprocessedElements();
+
182 return false;
+
183 }
+
184
+
185 // Add new element to the bucket
+
186 Insert( std::move(newElement) );
+
187 ++numberOfValidUnprocessedElements_;
+
188 PopInvalidUnprocessedElements();
+
189 return true;
+
190 }
+
191
+
192 template<DominationCriterion Domination = DominationCriterion::weak>
+
193 inline bool Merge ( TElement & newElement )
+
194 {
+
195 bool valid = Merge<Domination>( TElement(newElement) );
+
196 newElement.Valid() = valid;
+
197 return valid;
+
198 }
+
199
+
200 template<DominationCriterion Domination = DominationCriterion::weak>
+
201 inline bool Merge( TElement const & newElement )
+
202 {
+
203 return Merge<Domination>( TElement(newElement) );
+
204 }
+
206
+
+
208 inline bool HasElement ( TElement const & newElement
+
209 , TElement & existingElement )
+
210 {
+
211 bool hasElement = false;
+
212 for_all_elements<ExecutionPolicy::breakable>(
+
213 [ & newElement
+
214 , & existingElement
+
215 , & hasElement](TElement & element) -> bool
+
216 {
+
217 if ( newElement == element )
+
218 {
+
219 existingElement = element;
+
220 hasElement = true;
+
221 return false;
+
222 }
+
223 return true;
+
224 }
+
225 );
+
226 return hasElement;
+
227 }
+
+
228
+
231#pragma mark ELEMENT_ACCESS
+
232
+
+
242 inline bool HasElementAt ( Types::index index )
+
243 {
+
244 USAGE_ASSERT ( index >= 0 );
+
245 return ( index < NumberOfProcessedElements() );
+
246 }
+
+
247
+
+
258 inline TElement & ElementAt ( Types::index index )
+
259 {
+
260#ifdef PGT_EXCEPTION_HANDLING
+
261 throw_out_of_bound( index, NumberOfProcessedElements() );
+
262#endif
+
263 USAGE_ASSERT ( HasElementAt(index) );
+
264 return processedElements_.at( index );
+
265 }
+
+
266
+
+
277 inline TElement & operator[] ( Types::index index )
+
278 {
+
279#ifdef PGT_EXCEPTION_HANDLING
+
280 throw_out_of_bound( index, NumberOfProcessedElements() );
+
281#endif
+
282 USAGE_ASSERT ( HasElementAt(index) );
+
283 return processedElements_.at(index);
+
284 }
+
+
285
+
+
296 inline TElement & operator[] ( Types::index index ) const
+
297 {
+
298#ifdef PGT_EXCEPTION_HANDLING
+
299 throw_out_of_bound( index, NumberOfProcessedElements() );
+
300#endif
+
301 USAGE_ASSERT ( HasElementAt(index) );
+
302 return processedElements_.at( index );
+
303 }
+
+
304
+
+
315 inline TElement const & Top () const
+
316 {
+
317 USAGE_ASSERT ( !EmptyQueue() );
+
318 ESSENTIAL_ASSERT( unprocessedElements_.Top().Valid() );
+
319 return unprocessedElements_.Top();
+
320 }
+
+
321
+
+
336 inline std::vector<TElement> Optima () const
+
337 { //@todo This is a very bad implementation. Think about it again.
+
338 auto result = std::min_element( processedElements_.begin(), processedElements_.end(), [](TElement a, TElement b) { return a.Value() < b.Value(); } );
+
339 auto result2 = std::min_element( unprocessedElements_.begin(), unprocessedElements_.end(), [](TElement a, TElement b) { return a.Value() < b.Value(); } );
+
340 TElement minElement;
+
341 if ( result != processedElements_.end() )
+
342 {
+
343 if ( result2 != unprocessedElements_.end() )
+
344 {
+
345 ((*result)<(*result2))?(minElement = *result):(minElement = *result2);
+
346 } else {
+
347 minElement = *result;
+
348 }
+
349 } else if ( result2 != unprocessedElements_.end() ) {
+
350 minElement = *result2;
+
351 }
+
352
+
353 // Extract elements with the same optimum value
+
354 std::vector<TElement> optima;
+
355 for_all_elements<ExecutionPolicy::sequential> (
+
356 [ & minElement
+
357 , & optima ]( TElement const & element )
+
358 {
+
359 if ( element.Value() == minElement.Value() )
+
360 {
+
361 optima.emplace_back( element );
+
362 }
+
363 }
+
364 );
+
365 return optima;
+
366 }
+
+
368
+
371#pragma mark MODIFIERS
+
+
385 inline Types::index Pop ()
+
386 {
+
387 USAGE_ASSERT ( !EmptyQueue() );
+
388
+
389 TElement element = unprocessedElements_.DeleteTop();
+
390 --numberOfValidUnprocessedElements_;
+
391 ESSENTIAL_ASSERT( element.Valid() );
+
392 PopInvalidUnprocessedElements();
+
393
+
394 return MoveToProcessed ( std::move(element) );
+
395 }
+
+
396
+
+
410 inline std::pair<TElement, Types::index> DeleteTop ()
+
411 {
+
412 USAGE_ASSERT ( !EmptyQueue() );
+
413 Types::index index = Pop();
+
414 return std::make_pair( processedElements_.back(), index );
+
415 }
+
+
417
+
418
+
419#pragma mark CAPACITY
+
+
423 inline void Clear () noexcept
+
424 {
+
425 processedElements_.clear();
+
426 unprocessedElements_.Clear();
+
427 numberOfValidUnprocessedElements_ = 0;
+
428 }
+
+
429
+
447#pragma mark COMPARATOR
+
448
+
449 inline std::function<bool ( TElement const &
+
450 , TElement const & ) >
+
451 const & Comparator () const
+
452 {
+
453 return unprocessedElements_.Comparator();
+
454 }
+
455
+
456 inline void Comparator( std::function<bool ( TElement const &
+
457 , TElement const & )> comparator )
+
458 {
+
459 unprocessedElements_.Comparator ( comparator );
+
460 }
+
462
+
463#pragma mark OTHERS
+
+
469 inline bool Empty () const
+
470 {
+
471 return ( processedElements_.empty() && unprocessedElements_.Empty() );
+
472 }
+
+
473
+
+
479 inline bool EmptyQueue () const
+
480 {
+
481 return unprocessedElements_.Empty();
+
482 }
+
+
483
+
484 inline Types::count Size () const
+
485 {
+
486 return NumberOfProcessedElements() + NumberOfUnprocessedElements();
+
487 }
+
488
+
491#pragma mark LOOPS
+
492
+
510 template<ExecutionPolicy Policy, typename FUNCTION>
+
511 inline
+
+
512 void for_all_elements ( FUNCTION function )
+
513 {
+
514 internal::BucketLoopDifferentiation<Bucket, Policy>
+
515 ::for_all_elements ( *this, function );
+
516 PopInvalidUnprocessedElements();
+
517 }
+
+
518
+
537 template<ExecutionPolicy Policy, typename FUNCTION>
+
538 inline
+
+
539 void for_all_elements ( FUNCTION function ) const
+
540 {
+
541 internal::BucketLoopDifferentiation<Bucket const, Policy>
+
542 ::for_all_elements ( *this, function );
+
543 }
+
+
544
+
561 template<ExecutionPolicy Policy, typename FUNCTION>
+
562 inline
+
+
563 void for_all_processed_elements ( FUNCTION function )
+
564 {
+
565 internal::BucketLoopDifferentiation<Bucket, Policy>
+
566 ::for_all_processed_elements ( *this, function );
+
567 }
+
+
568
+
585 template<ExecutionPolicy Policy, typename FUNCTION>
+
586 inline
+
+
587 void for_all_processed_elements ( FUNCTION function ) const
+
588 {
+
589 internal::BucketLoopDifferentiation<Bucket const, Policy>
+
590 ::for_all_processed_elements ( *this, function );
+
591 }
+
+
592
+
612 template<ExecutionPolicy Policy, typename FUNCTION>
+
613 inline
+ +
620
+
640 template<ExecutionPolicy Policy, typename FUNCTION>
+
641 inline
+
+
642 void for_all_unprocessed_elements ( FUNCTION function ) const
+
643 {
+
644 internal::BucketLoopDifferentiation<Bucket const, Policy>
+
645 ::for_all_unprocessed_elements ( *this, function );
+
646 }
+
+
647
+
665 template<ExecutionPolicy Policy, typename FUNCTION>
+
666 inline
+
+
667 Types::real for_all_optima ( FUNCTION function )
+
668 {
+
669 return internal::BucketLoopDifferentiation<Bucket, Policy>
+
670 ::for_all_optima ( *this, function );
+
671 }
+
+
672
+
691 template<ExecutionPolicy Policy, typename FUNCTION>
+
692 inline
+
+
693 Types::real for_all_optima ( FUNCTION function ) const
+
694 {
+
695 return internal::BucketLoopDifferentiation<Bucket const, Policy>
+
696 ::for_all_optima ( *this, function );
+
697 }
+
+
699
+
700 private:
+
703#pragma mark ADD_ELEMENTS
+
704
+
+
714 inline Types::index MoveToProcessed ( TElement && element )
+
715 {
+
716 processedElements_.push_back ( std::move(element) );
+
717 processedElements_.back().Index() = processedElements_.size() - 1;
+
718 return processedElements_.back().Index();
+
719 }
+
+
720
+
+
726 inline void Insert ( TElement && element ) {
+
727 ESSENTIAL_ASSERT( element.Valid() );
+
728 unprocessedElements_.Insert ( std::move(element) );
+
729 }
+
+
731
+
734#pragma mark NUMBER_OF_ELEMENTS
+
+
740 inline Types::count NumberOfProcessedElements() const noexcept
+
741 {
+
742 return processedElements_.size();
+
743 }
+
+
744
+
+
750 inline Types::count NumberOfUnprocessedElements() const noexcept
+
751 {
+
752 return numberOfValidUnprocessedElements_;
+
753 }
+
+
755
+
758#pragma mark DOMINATION
+
769 template<DominationCriterion Domination>
+
+
770 inline bool Dominates ( TElement const & lhs, TElement const & rhs ) const
+
771 {
+
772 return internal::DominationDifferentiation<TElement, Domination>
+
773 ::Dominates( lhs, rhs, Comparator() );
+
774 }
+
+
776
+
779#pragma mark INVARIANTS
+
780
+
+
785 inline void PopInvalidUnprocessedElements()
+
786 {
+
787 while (!unprocessedElements_.Empty()
+
788 && !unprocessedElements_.Top().Valid())
+
789 {
+
790 unprocessedElements_.Pop();
+
791 }
+
792 }
+
+
794
+
795#pragma mark FRIENDS
+
796 friend internal::BucketLoopDifferentiation<Bucket, ExecutionPolicy::sequential>;
+
797 friend internal::BucketLoopDifferentiation<Bucket, ExecutionPolicy::breakable>;
+
798 friend internal::BucketLoopDifferentiation<Bucket, ExecutionPolicy::parallel>;
+
799 friend internal::BucketLoopDifferentiation<Bucket const, ExecutionPolicy::sequential>;
+
800 friend internal::BucketLoopDifferentiation<Bucket const, ExecutionPolicy::breakable>;
+
801 friend internal::BucketLoopDifferentiation<Bucket const, ExecutionPolicy::parallel>;
+
802
+
803#pragma mark MEMBERS
+
804 std::vector<TElement> processedElements_;
+
805 TPriorityQueue unprocessedElements_;
+
806 Types::count numberOfValidUnprocessedElements_;
+
807};
+
+
808
+
809namespace internal {
+
810
+
811#pragma mark SEQUENTIAL_LOOPS
+
812
+
813template<typename BucketType>
+
+
814class BucketLoopDifferentiation<BucketType, ExecutionPolicy::sequential> {
+
815
+
816 // Type aliasing
+
817 using TBucket = BucketType;
+
818 using TElement = typename TBucket::TElement;
+
819
+
820 public:
+
836 template<typename FUNCTION>
+
837 inline static
+
+
838 void for_all_elements ( BucketType & bucket
+
839 , FUNCTION function )
+
840 {
+
841 for_all_processed_elements ( bucket, function );
+
842 for_all_unprocessed_elements ( bucket, function );
+
843 }
+
+
844
+
859 template<typename FUNCTION>
+
860 inline static
+
+
861 void for_all_processed_elements ( BucketType & bucket
+
862 , FUNCTION function )
+
863 {
+
864 for ( auto & element : bucket.processedElements_ )
+
865 {
+
866 function ( element );
+
867 }
+
868 }
+
+
869
+
884 template<typename FUNCTION>
+
885 inline static
+
+
886 void for_all_unprocessed_elements ( BucketType & bucket
+
887 , FUNCTION function )
+
888 {
+
889 bucket.unprocessedElements_.template for_all_elements<ExecutionPolicy::sequential>(
+
890 [&function]( auto & element )
+
891 {
+
892 if (!element.Valid()) return;
+
893 function(element);
+
894 }
+
895 );
+
896 }
+
+
897
+
898
+
916 template<typename FUNCTION>
+
917 static inline
+
+
918 Types::real for_all_optima ( BucketType & bucket
+
919 , FUNCTION function )
+
920 {
+
921 std::vector<TElement> optima = bucket.Optima();
+
922 for ( TElement const & element : optima )
+
923 {
+
924 function ( element );
+
925 }
+
926 if ( !optima.empty() )
+
927 return optima[0].Value();
+
928 else
+
929 return Const::REAL_INFTY;
+
930 }
+
+
931};
+
+
932
+
933#pragma mark BREAKABLE_LOOPS
+
934template<typename BucketType>
+
+
935class BucketLoopDifferentiation<BucketType, ExecutionPolicy::breakable> {
+
936 using TElement = typename BucketType::TElement;
+
937 public:
+
938
+
939 template<typename FUNCTION>
+
940 static inline
+
941 void for_all_elements ( BucketType & bucket
+
942 , FUNCTION function )
+
943 {
+
944 for ( auto & element : bucket.processedElements_ )
+
945 {
+
946 bool toContinue = function( element );
+
947 if (!toContinue) return;
+
948 }
+
949
+
950 for_all_unprocessed_elements(bucket, function);
+
951 }
+
952
+
969 template<typename FUNCTION>
+
970 static inline
+
+
971 void for_all_processed_elements ( BucketType & bucket
+
972 , FUNCTION function )
+
973 {
+
974 bool toContinue = true;
+
975 for ( auto & element : bucket.processedElements_ )
+
976 {
+
977 toContinue = function ( element );
+
978 if ( !toContinue ) break;
+
979 }
+
980 }
+
+
981
+
998 template<typename FUNCTION>
+
999 static inline
+
+
1000 void for_all_unprocessed_elements ( BucketType & bucket
+
1001 , FUNCTION function )
+
1002 {
+
1003 bucket.unprocessedElements_.template for_all_elements<ExecutionPolicy::breakable>(
+
1004 [&function](auto & element) -> bool
+
1005 {
+
1006 if (!element.Valid()) return true;
+
1007 return function(element);
+
1008 }
+
1009 );
+
1010 }
+
+
1011
+
1012 template<typename FUNCTION>
+
1013 static inline
+
1014 Types::real for_all_optima ( BucketType & bucket
+
1015 , FUNCTION function )
+
1016 {
+
1017 std::vector<TElement> optima = bucket.Optima();
+
1018 for ( TElement const & element : optima )
+
1019 {
+
1020 bool toContinue = function ( element );
+
1021 if (!toContinue) break;
+
1022 }
+
1023 if ( !optima.empty() )
+
1024 return optima[0].Value();
+
1025 else
+
1026 return Const::REAL_INFTY;
+
1027 }
+
1028};
+
+
1029
+
1030#pragma mark PARALLEL_LOOPS
+
1031
+
1032#ifdef OPENMP_AVAILABLE
+
1033
+
1034
+
1035template<typename BucketType>
+
1036class BucketLoopDifferentiation<BucketType, ExecutionPolicy::parallel> {
+
1037
+
1038 // Type aliasing
+
1039 using TBucket = BucketType;
+
1040 using TElement = typename TBucket::TElement;
+
1041
+
1042 public:
+
1058 template<typename FUNCTION>
+
1059 static inline
+
1060 void for_all_elements ( BucketType & bucket
+
1061 , FUNCTION function )
+
1062 {
+
1063 for_all_processed_elements ( bucket, function );
+
1064 for_all_unprocessed_elements ( bucket, function );
+
1065 }
+
1066
+
1081 template<typename FUNCTION>
+
1082 static inline
+
1083 void for_all_processed_elements ( BucketType & bucket
+
1084 , FUNCTION function )
+
1085 {
+
1086 #pragma omp parallel for
+
1087 for ( Types::count counter = 0
+
1088 ; counter < bucket.processedElements_.size()
+
1089 ; ++counter )
+
1090 {
+
1091 function( bucket.processedElements_[counter] );
+
1092 }
+
1093 }
+
1094
+
1109 template<typename FUNCTION>
+
1110 static inline
+
1111 void for_all_unprocessed_elements ( BucketType & bucket
+
1112 , FUNCTION function )
+
1113 {
+
1114 bucket.unprocessedElements_.template for_all_elements<ExecutionPolicy::parallel>(
+
1115 [&function](auto & element)
+
1116 {
+
1117 if (!element.Valid()) return;
+
1118 function(element);
+
1119 }
+
1120 );
+
1121 }
+
1122
+
1140 template<typename FUNCTION>
+
1141 static inline
+
1142 Types::real for_all_optima ( BucketType & bucket
+
1143 , FUNCTION function )
+
1144 {
+
1145 std::vector<TElement> optima = bucket.Optima();
+
1146 #pragma omp parallel for
+
1147 for ( Types::count counter = 0
+
1148 ; counter < optima.size()
+
1149 ; ++counter )
+
1150 {
+
1151 function( optima[counter] );
+
1152 }
+
1153
+
1154 if ( !optima.empty() )
+
1155 return optima[0].Value();
+
1156 else
+
1157 return Const::REAL_INFTY;
+
1158 }
+
1159};
+
1160
+
1161#else // OPENMP_AVAILABLE
+
1167template<typename BucketType>
+
+
1168class BucketLoopDifferentiation<BucketType, ExecutionPolicy::parallel>
+
1169 : public BucketLoopDifferentiation<BucketType, ExecutionPolicy::sequential> {};
+
+
1170
+
1171#endif // OPENMP_AVAILABLE
+
1172
+
1173} // namespace internal
+
1174
+
1175} // namespace egoa
+
1176
+
1177#endif // EGOA__DATA_STRUCTURES__CONTAINER__QUEUES__BUCKET_HPP
+
egoa::Bucket
Class for bucket data structure.
Definition Bucket.hpp:65
+
egoa::Bucket::Optima
std::vector< TElement > Optima() const
All elements with an optimum value.
Definition Bucket.hpp:336
+
egoa::Bucket::HasElement
bool HasElement(TElement const &newElement, TElement &existingElement)
Definition Bucket.hpp:208
+
egoa::Bucket::Clear
void Clear() noexcept
Clear the bucket.
Definition Bucket.hpp:423
+
egoa::Bucket::ElementAt
TElement & ElementAt(Types::index index)
Processed element at a certain position index.
Definition Bucket.hpp:258
+
egoa::Bucket::for_all_optima
Types::real for_all_optima(FUNCTION function)
The for loop over all elements with optimal value.
Definition Bucket.hpp:667
+
egoa::Bucket::EmptyQueue
bool EmptyQueue() const
Determines if there are no unprocessed elements in the bucket.
Definition Bucket.hpp:479
+
egoa::Bucket::for_all_optima
Types::real for_all_optima(FUNCTION function) const
The for loop over all elements with optimal value with const access.
Definition Bucket.hpp:693
+
egoa::Bucket::NumberOfUnprocessedElements
Types::count NumberOfUnprocessedElements() const noexcept
Number of valid unprocessed elements.
Definition Bucket.hpp:750
+
egoa::Bucket::Pop
Types::index Pop()
Pop the first valid element.
Definition Bucket.hpp:385
+
egoa::Bucket::for_all_unprocessed_elements
void for_all_unprocessed_elements(FUNCTION function)
The for loop over all unprocessed elements in the bucket.
Definition Bucket.hpp:614
+
egoa::Bucket::numberOfValidUnprocessedElements_
Types::count numberOfValidUnprocessedElements_
Definition Bucket.hpp:806
+
egoa::Bucket::for_all_unprocessed_elements
void for_all_unprocessed_elements(FUNCTION function) const
The for loop over all unprocessed elements in the bucket.
Definition Bucket.hpp:642
+
egoa::Bucket::Empty
bool Empty() const
Determines if the bucket is empty.
Definition Bucket.hpp:469
+
egoa::Bucket::processedElements_
std::vector< TElement > processedElements_
Definition Bucket.hpp:804
+
egoa::Bucket::operator[]
TElement & operator[](Types::index index)
Processed element at a certain position index.
Definition Bucket.hpp:277
+
egoa::Bucket::Insert
void Insert(TElement &&element)
Insert an element.
Definition Bucket.hpp:726
+
egoa::Bucket::MoveToProcessed
Types::index MoveToProcessed(TElement &&element)
Move element to processed elements.
Definition Bucket.hpp:714
+
egoa::Bucket::Dominates
bool Dominates(TElement const &lhs, TElement const &rhs) const
Checks if lhs dominates rhs in a certain sense.
Definition Bucket.hpp:770
+
egoa::Bucket::Top
TElement const & Top() const
Returns the first valid and unprocessed element.
Definition Bucket.hpp:315
+
egoa::Bucket::unprocessedElements_
TPriorityQueue unprocessedElements_
Definition Bucket.hpp:805
+
egoa::Bucket::Bucket
Bucket()
Constructs the object.
Definition Bucket.hpp:84
+
egoa::Bucket::NumberOfProcessedElements
Types::count NumberOfProcessedElements() const noexcept
Number of processed elements.
Definition Bucket.hpp:740
+
egoa::Bucket::for_all_elements
void for_all_elements(FUNCTION function) const
The for loop over all elements in the bucket with const access.
Definition Bucket.hpp:539
+
egoa::Bucket::PopInvalidUnprocessedElements
void PopInvalidUnprocessedElements()
Pops invalid unprocessed elements until unprocessedElements_ is empty or the top element is valid.
Definition Bucket.hpp:785
+
egoa::Bucket::DeleteTop
std::pair< TElement, Types::index > DeleteTop()
Delete and return the first valid element.
Definition Bucket.hpp:410
+
egoa::Bucket::for_all_processed_elements
void for_all_processed_elements(FUNCTION function) const
The for loop over all processed elements in the bucket.
Definition Bucket.hpp:587
+
egoa::Bucket::for_all_processed_elements
void for_all_processed_elements(FUNCTION function)
The for loop over all processed elements in the bucket.
Definition Bucket.hpp:563
+
egoa::Bucket::HasElementAt
bool HasElementAt(Types::index index)
Determines if it has a processed element at position index.
Definition Bucket.hpp:242
+
egoa::Bucket::for_all_elements
void for_all_elements(FUNCTION function)
The for loop over all elements in the bucket.
Definition Bucket.hpp:512
+ +
egoa::PriorityQueue::Empty
virtual bool Empty() const override=0
+
egoa::PriorityQueue::Top
virtual TElement const & Top() const override=0
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_processed_elements
static void for_all_processed_elements(BucketType &bucket, FUNCTION function)
The for loop over all processed elements in the bucket.
Definition Bucket.hpp:971
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_unprocessed_elements
static void for_all_unprocessed_elements(BucketType &bucket, FUNCTION function)
The for loop over all unprocessed elements in the bucket.
Definition Bucket.hpp:1000
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_elements
static void for_all_elements(BucketType &bucket, FUNCTION function)
The for loop over all elements in the bucket.
Definition Bucket.hpp:838
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_unprocessed_elements
static void for_all_unprocessed_elements(BucketType &bucket, FUNCTION function)
The for loop over all unprocessed elements in the bucket.
Definition Bucket.hpp:886
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_processed_elements
static void for_all_processed_elements(BucketType &bucket, FUNCTION function)
The for loop over all processed elements in the bucket.
Definition Bucket.hpp:861
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_optima
static Types::real for_all_optima(BucketType &bucket, FUNCTION function)
The for loop over all elements with optimal value.
Definition Bucket.hpp:918
+
egoa::internal::BucketLoopDifferentiation
Class for bucket loop differentiation.
Definition Bucket.hpp:33
+
egoa::internal::DominationDifferentiation
Class for domination differentiation.
Definition DominationCriterion.hpp:54
+
egoa
Definition Color.cpp:15
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_bucket_element_8hpp_source.html b/_bucket_element_8hpp_source.html new file mode 100644 index 00000000..d8135a65 --- /dev/null +++ b/_bucket_element_8hpp_source.html @@ -0,0 +1,282 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Labels/BucketElement.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BucketElement.hpp
+
+
+
1/*
+
2 * BucketElement.hpp
+
3 *
+
4 * Created on: Feb 04, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__LABELS__BUCKET_ELEMENT_HPP
+
9#define EGOA__DATA_STRUCTURES__LABELS__BUCKET_ELEMENT_HPP
+
10
+
11namespace egoa {
+
12
+
26template<typename ElementType>
+
+
27class BucketElement {
+
28 public:
+
29 // Type aliasing
+
30 using TElement = ElementType;
+
31 using TBucketElement = BucketElement<TElement>;
+
32 public:
+
35#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
36
+
37 BucketElement ()
+
38 : BucketElement(TElement(),true)
+
39 {}
+
40
+
+
48 BucketElement ( TElement value
+
49 , bool valid )
+
50 : index_(Const::NONE)
+
51 , valid_(valid)
+
52 , value_(value)
+
53 {}
+
+
54
+
+
60 BucketElement( TElement element )
+
61 : BucketElement( element, true )
+
62 {}
+
+
63
+
67 ~BucketElement() {}
+
69
+
72#pragma mark DOMINATION_OPERATORS
+
+
80 inline bool operator<( BucketElement const & rhs ) const
+
81 {
+
82 return value_ < rhs.value_;
+
83 }
+
+
84
+
+
92 inline bool operator<=( BucketElement const & rhs ) const
+
93 {
+
94 return !(*this > rhs);
+
95 }
+
+
96
+
+
104 inline bool operator> ( BucketElement const & rhs ) const
+
105 {
+
106 return rhs < *this;
+
107 }
+
+
108
+
+
116 inline bool operator>=( BucketElement const & rhs ) const
+
117 {
+
118 return !(rhs > *this);
+
119 }
+
+
121
+
124#pragma mark COMPARISON_OPERATORS
+
125
+
+
133 inline bool operator==( BucketElement const & rhs ) const
+
134 {
+
135 return value_ == rhs.value_;
+
136 }
+
+
137
+
+
145 inline bool operator!=( BucketElement const & rhs ) const
+
146 {
+
147 return !(*this==rhs);
+
148 }
+
+
150
+
153#pragma mark CONCATENATION_OPERATORS
+
+
161 inline BucketElement & operator+=( TElement const & rhs )
+
162 {
+
163 this->Value() += rhs.Value();
+
164 return *this;
+
165 }
+
+
166
+
+
174 inline BucketElement operator+ ( TElement const & rhs ) const
+
175 {
+
176 BucketElement temp ( *this );
+
177 return temp += rhs;
+
178 }
+
+
180
+
183#pragma mark GETTER_AND_SETTER
+
184
+
+
192 inline Types::labelId Index() const
+
193 {
+
194 return index_;
+
195 }
+
+
196
+
+
209 inline Types::labelId & Index()
+
210 {
+
211 return index_;
+
212 }
+
+
213
+
+
219 inline bool Valid() const
+
220 {
+
221 return valid_;
+
222 }
+
+
223
+
+
233 inline bool & Valid()
+
234 {
+
235 return valid_;
+
236 }
+
+
237
+
+
243 inline TElement Value() const
+
244 {
+
245 return value_;
+
246 }
+
+
247
+
+
257 inline TElement & Value()
+
258 {
+
259 return value_;
+
260 }
+
+
262
+
263#pragma mark OUTPUT
+
+
272 friend std::ostream & operator<< ( std::ostream & os
+
273 , BucketElement const & rhs )
+
274 {
+
275 return os << "(" << rhs.Value() << "," << rhs.Valid() << ")";
+
276 }
+
+
277
+
278#pragma mark MEMBERS
+
279 private:
+
280 Types::index index_;
+
281 bool valid_;
+
282 TElement value_;
+
283};
+
+
284
+
285} // namespace egoa
+
286
+
287#endif // EGOA__DATA_STRUCTURES__LABELS__BUCKET_ELEMENT_HPP
+
egoa::BucketElement
Class representing the minimal bucket element.
Definition BucketElement.hpp:27
+
egoa::BucketElement::operator==
bool operator==(BucketElement const &rhs) const
Equality check.
Definition BucketElement.hpp:133
+
egoa::BucketElement::operator!=
bool operator!=(BucketElement const &rhs) const
Inequality check.
Definition BucketElement.hpp:145
+ +
egoa::BucketElement::Value
TElement & Value()
Setter for the value of the BucketElement.
Definition BucketElement.hpp:257
+
egoa::BucketElement::BucketElement
BucketElement(TElement value, bool valid)
Constructs the BucketElement object.
Definition BucketElement.hpp:48
+
egoa::BucketElement::operator+=
BucketElement & operator+=(TElement const &rhs)
In place addition.
Definition BucketElement.hpp:161
+
egoa::BucketElement::Valid
bool Valid() const
Getter for the valid flag.
Definition BucketElement.hpp:219
+
egoa::BucketElement::Value
TElement Value() const
Getter for the value of the BucketElement.
Definition BucketElement.hpp:243
+
egoa::BucketElement::operator<=
bool operator<=(BucketElement const &rhs) const
Weak domination using less or equal than.
Definition BucketElement.hpp:92
+
egoa::BucketElement::BucketElement
BucketElement(TElement element)
Constructs the object.
Definition BucketElement.hpp:60
+
egoa::BucketElement::Index
Types::labelId Index() const
Getter for the identifier.
Definition BucketElement.hpp:192
+
egoa::BucketElement::operator<
bool operator<(BucketElement const &rhs) const
Strict domination using less than.
Definition BucketElement.hpp:80
+
egoa::BucketElement::operator+
BucketElement operator+(TElement const &rhs) const
Adding an element to the BucketElement.
Definition BucketElement.hpp:174
+
egoa::BucketElement::operator>=
bool operator>=(BucketElement const &rhs) const
Weak domination using greater or equal than.
Definition BucketElement.hpp:116
+ +
egoa::BucketElement::operator<<
friend std::ostream & operator<<(std::ostream &os, BucketElement const &rhs)
Output stream.
Definition BucketElement.hpp:272
+
egoa::BucketElement::Valid
bool & Valid()
Setter for the valid flag.
Definition BucketElement.hpp:233
+
egoa::BucketElement::Index
Types::labelId & Index()
Setter for the identifier.
Definition BucketElement.hpp:209
+ +
egoa::BucketElement::operator>
bool operator>(BucketElement const &rhs) const
Strict domination using greater than.
Definition BucketElement.hpp:104
+
egoa::BucketElement::~BucketElement
~BucketElement()
Destroys the BucketElement object.
Definition BucketElement.hpp:67
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_callback_empty_8hpp_source.html b/_callback_empty_8hpp_source.html new file mode 100644 index 00000000..afc26817 --- /dev/null +++ b/_callback_empty_8hpp_source.html @@ -0,0 +1,138 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/MathematicalModel/Callbacks/CallbackEmpty.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
CallbackEmpty.hpp
+
+
+
1/*
+
2 * EmptyCallback.hpp
+
3 *
+
4 * Created on: May 21, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__MATHEMATICAL_MODEL__CALLBACKS__EMPTY_CALLBACK_HPP
+
9#define EGOA__MATHEMATICAL_MODEL__CALLBACKS__EMPTY_CALLBACK_HPP
+
10
+
11#include "gurobi_c++.h"
+
12// #include "MathematicalModel/Solver/GurobiSolver.hpp"
+
13
+
14namespace egoa {
+
15
+
16template<typename CallbackType>
+
17class GurobiSolver;
+
18
+
19template<typename LoggingType>
+
+
20class CallbackEmpty : public GRBCallback {
+
21 public:
+
22 using TLogging = LoggingType;
+
23 using TSolver = GurobiSolver<CallbackEmpty<TLogging>>;
+
24
+
+
30 CallbackEmpty (TSolver *solver) // @todo not a perfect solution
+
31 : solver_(solver) {}
+
+
32 private:
+
+
36 void callback() override {
+
37 return;
+
38 }
+
+
39 private:
+
40 TSolver * solver_;
+
41};
+
+
42
+
43} // namespace egoa
+
44
+
45#endif // EGOA__MATHEMATICAL_MODEL__CALLBACKS__EMPTY_CALLBACK_HPP
+ +
egoa::CallbackEmpty::callback
void callback() override
Do nothing.
Definition CallbackEmpty.hpp:36
+
egoa::CallbackEmpty::CallbackEmpty
CallbackEmpty(TSolver *solver)
Constructs the object.
Definition CallbackEmpty.hpp:30
+ +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_color_8cpp_source.html b/_color_8cpp_source.html new file mode 100644 index 00000000..84088aa8 --- /dev/null +++ b/_color_8cpp_source.html @@ -0,0 +1,610 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/IO/Appearance/Color.cpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Color.cpp
+
+
+
1/*
+
2 * Color.cpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#include "IO/Appearance/Color.hpp"
+
9
+
10#include <sstream>
+
11#include <iomanip>
+
12
+
13#include <Auxiliary/Types.hpp>
+
14
+
+
15namespace egoa {
+
16
+
17 using ubyte_array = std::array<Types::ubyte,3>;
+
18 using float_array = std::array<Types::real,3>;
+
19
+
20 std::array RGB = { // Types::ubyte RGB[][3]
+
21 // KITgreen
+
22 ubyte_array{ 0, 150, 130 } // KITgreen
+
23 , ubyte_array{ 77, 181, 167 } // KITgreen70
+
24 , ubyte_array{ 128, 202, 192 } // KITgreen50
+
25 , ubyte_array{ 179, 223, 217 } // KITgreen30
+
26 , ubyte_array{ 217, 239, 236 } // KITgreen15
+
27 // KITblue
+
28 , ubyte_array{ 70, 100, 170 } // KITblue
+
29 , ubyte_array{ 125, 146, 195 } // KITblue70
+
30 , ubyte_array{ 162, 177, 212 } // KITblue50
+
31 , ubyte_array{ 199, 208, 230 } // KITblue30
+
32 , ubyte_array{ 227, 232, 242 } // KITblue15
+
33 // KITblack
+
34 , ubyte_array{ 0, 0, 0 } // KITblack
+
35 , ubyte_array{ 77, 77, 77 } // KITblack70
+
36 , ubyte_array{ 128, 128, 128 } // KITblack50
+
37 , ubyte_array{ 179, 179, 179 } // KITblack32
+
38 , ubyte_array{ 179, 179, 179 } // KITblack31
+
39 , ubyte_array{ 179, 179, 179 } // KITblack30
+
40 , ubyte_array{ 181, 181, 181 } // KITblack29
+
41 , ubyte_array{ 184, 184, 184 } // KITblack28
+
42 , ubyte_array{ 186, 186, 186 } // KITblack27
+
43 , ubyte_array{ 189, 189, 189 } // KITblack26
+
44 , ubyte_array{ 191, 191, 191 } // KITblack25
+
45 , ubyte_array{ 194, 194, 194 } // KITblack24
+
46 , ubyte_array{ 196, 196, 196 } // KITblack23
+
47 , ubyte_array{ 199, 199, 199 } // KITblack22
+
48 , ubyte_array{ 201, 201, 201 } // KITblack21
+
49 , ubyte_array{ 204, 204, 204 } // KITblack20
+
50 , ubyte_array{ 207, 207, 207 } // KITblack19
+
51 , ubyte_array{ 209, 209, 209 } // KITblack18
+
52 , ubyte_array{ 212, 212, 212 } // KITblack17
+
53 , ubyte_array{ 214, 214, 214 } // KITblack16
+
54 , ubyte_array{ 217, 217, 217 } // KITblack15
+
55 , ubyte_array{ 219, 219, 219 } // KITblack14
+
56 , ubyte_array{ 222, 222, 222 } // KITblack13
+
57 , ubyte_array{ 224, 224, 224 } // KITblack12
+
58 , ubyte_array{ 227, 227, 227 } // KITblack11
+
59 , ubyte_array{ 230, 230, 230 } // KITblack10
+
60 , ubyte_array{ 232, 232, 232 } // KITblack09
+
61 , ubyte_array{ 235, 235, 235 } // KITblack08
+
62 , ubyte_array{ 237, 237, 237 } // KITblack07
+
63 , ubyte_array{ 240, 240, 240 } // KITblack06
+
64 , ubyte_array{ 242, 242, 242 } // KITblack05
+
65 , ubyte_array{ 245, 245, 245 } // KITblack04
+
66 , ubyte_array{ 247, 247, 247 } // KITblack03
+
67 , ubyte_array{ 250, 250, 250 } // KITblack02
+
68 , ubyte_array{ 252, 252, 252 } // KITblack01
+
69 // KITpalegreen
+
70 , ubyte_array{ 130, 190, 60 } // KITpalegreen
+
71 , ubyte_array{ 167, 209, 118 } // KITpalegreen70
+
72 , ubyte_array{ 192, 222, 157 } // KITpalegreen50
+
73 , ubyte_array{ 217, 235, 196 } // KITpalegreen30
+
74 , ubyte_array{ 236, 245, 226 } // KITpalegreen15
+
75 // KITyellow
+
76 , ubyte_array{ 250, 230, 20 } // KITyellow
+
77 , ubyte_array{ 251, 237, 90 } // KITyellow70
+
78 , ubyte_array{ 252, 242, 137 } // KITyellow50
+
79 , ubyte_array{ 253, 247, 184 } // KITyellow30
+
80 , ubyte_array{ 254, 251, 220 } // KITyellow15
+
81 // KITorange
+
82 , ubyte_array{ 220, 160, 30 } // KITorange
+
83 , ubyte_array{ 230, 188, 97 } // KITorange70
+
84 , ubyte_array{ 237, 207, 142 } // KITorange50
+
85 , ubyte_array{ 244, 226, 187 } // KITorange30
+
86 , ubyte_array{ 250, 241, 221 } // KITorange15
+
87 // KITbrown
+
88 , ubyte_array{ 160, 130, 50 } // KITbrown
+
89 , ubyte_array{ 188, 167, 111 } // KITbrown70
+
90 , ubyte_array{ 207, 192, 152 } // KITbrown50
+
91 , ubyte_array{ 226, 217, 193 } // KITbrown30
+
92 , ubyte_array{ 241, 236, 224 } // KITbrown15
+
93 // KITred
+
94 , ubyte_array{ 160, 30, 40 } // KITred
+
95 , ubyte_array{ 188, 97, 104 } // KITred70
+
96 , ubyte_array{ 207, 142, 147 } // KITred50
+
97 , ubyte_array{ 226, 187, 190 } // KITred30
+
98 , ubyte_array{ 241, 221, 223 } // KITred15
+
99 // KITlilac
+
100 , ubyte_array{ 160, 0, 120 } // KITlilac
+
101 , ubyte_array{ 188, 77, 160 } // KITlilac70
+
102 , ubyte_array{ 207, 128, 187 } // KITlilac50
+
103 , ubyte_array{ 226, 179, 214 } // KITlilac30
+
104 , ubyte_array{ 241, 217, 235 } // KITlilac15
+
105 // KITcyanblue
+
106 , ubyte_array{ 80, 170, 230 } // KITcyanblue
+
107 , ubyte_array{ 132, 195, 237 } // KITcyanblue70
+
108 , ubyte_array{ 167, 212, 242 } // KITcyanblue50
+
109 , ubyte_array{ 202, 230, 247 } // KITcyanblue30
+
110 , ubyte_array{ 229, 242, 251 } // KITcyanblue15
+
111 // KITseablue
+
112 , ubyte_array{ 50, 80, 140 } // KITseablue
+
113 , ubyte_array{ 111, 132, 174 } // KITseablue70
+
114 , ubyte_array{ 152, 167, 197 } // KITseablue50
+
115 , ubyte_array{ 193, 202, 220 } // KITseablue30
+
116 , ubyte_array{ 224, 229, 238 } // KITseablue15
+
117 //
+
118 // Thesis Colors
+
119 , ubyte_array{ 86, 151, 197 } // THESISblue
+
120 , ubyte_array{ 54, 120, 167 } // THESISblue_dark
+
121 , ubyte_array{ 125, 181, 221 } // THESISblue_light
+
122 , ubyte_array{ 222, 239, 252 } // THESISblue_vlight
+
123 //
+
124 , ubyte_array{ 198, 91, 101 } // THESISred
+
125 , ubyte_array{ 169, 60, 69 } // THESISred_dark
+
126 , ubyte_array{ 221, 128, 136 } // THESISred_light
+
127 , ubyte_array{ 251, 222, 224 } // THESISred_vlight
+
128 //
+
129 , ubyte_array{ 86, 195, 60 } // THESISgreen
+
130 , ubyte_array{ 68, 156, 47 } // THESISgreen_dark
+
131 , ubyte_array{ 112, 222, 87 } // THESISgreen_light
+
132 , ubyte_array{ 181, 251, 164 } // THESISgreen_vlight
+
133 //
+
134 , ubyte_array{ 206, 168, 67 } // THESISyellow
+
135 , ubyte_array{ 170, 135, 46 } // THESISyellow_dark
+
136 , ubyte_array{ 229, 195, 105 } // THESISyellow_light
+
137 , ubyte_array{ 253, 238, 198 } // THESISyellow_vlight
+
138 //
+
139 , ubyte_array{ 0, 0, 0 } // THESISblack
+
140 , ubyte_array{ 77, 77, 77 } // THESISblack70
+
141 , ubyte_array{ 128, 128, 128 } // THESISblack50
+
142 , ubyte_array{ 179, 179, 179 } // THESISblack30
+
143 , ubyte_array{ 217, 217, 217 } // THESISblack15
+
144 , ubyte_array{ 235, 235, 235 } // THESISblack7
+
145 // OGDF
+
146 , ubyte_array{ 218, 165, 32 } // Goldenrod
+
147 , ubyte_array{ 128, 128, 128 } // Gray
+
148 , ubyte_array{ 0, 128, 0 } // Green
+
149 , ubyte_array{ 173, 255, 47 } // Greenyellow
+
150 , ubyte_array{ 128, 128, 128 } // Grey
+
151 , ubyte_array{ 240, 255, 240 } // Honeydew
+
152 , ubyte_array{ 255, 105, 180 } // Hotpink
+
153 , ubyte_array{ 205, 92, 92 } // Indianred
+
154 , ubyte_array{ 75, 0, 130 } // Indigo
+
155 , ubyte_array{ 255, 255, 240 } // Ivory
+
156 , ubyte_array{ 240, 230, 140 } // Khaki
+
157 , ubyte_array{ 230, 230, 250 } // Lavender
+
158 , ubyte_array{ 255, 240, 245 } // Lavenderblush
+
159 , ubyte_array{ 124, 252, 0 } // Lawngreen
+
160 , ubyte_array{ 255, 250, 205 } // Lemonchiffon
+
161 , ubyte_array{ 173, 216, 230 } // Lightblue
+
162 , ubyte_array{ 240, 128, 128 } // Lightcoral
+
163 , ubyte_array{ 224, 255, 255 } // Lightcyan
+
164 , ubyte_array{ 250, 250, 210 } // Lightgoldenrodyellow
+
165 , ubyte_array{ 211, 211, 211 } // Lightgray
+
166 , ubyte_array{ 144, 238, 144 } // Lightgreen
+
167 , ubyte_array{ 211, 211, 211 } // Lightgrey
+
168 , ubyte_array{ 255, 182, 193 } // Lightpink
+
169 , ubyte_array{ 255, 160, 122 } // Lightsalmon
+
170 , ubyte_array{ 32, 178, 170 } // Lightseagreen
+
171 , ubyte_array{ 135, 206, 250 } // Lightskyblue
+
172 , ubyte_array{ 119, 136, 153 } // Lightslategray
+
173 , ubyte_array{ 119, 136, 153 } // Lightslategrey
+
174 , ubyte_array{ 176, 196, 222 } // Lightsteelblue
+
175 , ubyte_array{ 255, 255, 224 } // Lightyellow
+
176 , ubyte_array{ 0, 255, 0 } // Lime
+
177 , ubyte_array{ 50, 205, 50 } // Limegreen
+
178 , ubyte_array{ 250, 240, 230 } // Linen
+
179 , ubyte_array{ 255, 0, 255 } // Magenta
+
180 , ubyte_array{ 128, 0, 0 } // Maroon
+
181 , ubyte_array{ 102, 205, 170 } // Mediumaquamarine
+
182 , ubyte_array{ 0, 0, 205 } // Mediumblue
+
183 , ubyte_array{ 186, 85, 211 } // Mediumorchid
+
184 , ubyte_array{ 147, 112, 219 } // Mediumpurple
+
185 , ubyte_array{ 60, 179, 113 } // Mediumseagreen
+
186 , ubyte_array{ 123, 104, 238 } // Mediumslateblue
+
187 , ubyte_array{ 0, 250, 154 } // Mediumspringgreen
+
188 , ubyte_array{ 72, 209, 204 } // Mediumturquoise
+
189 , ubyte_array{ 199, 21, 133 } // Mediumvioletred
+
190 , ubyte_array{ 25, 25, 112 } // Midnightblue
+
191 , ubyte_array{ 245, 255, 250 } // Mintcream
+
192 , ubyte_array{ 255, 228, 225 } // Mistyrose
+
193 , ubyte_array{ 255, 228, 181 } // Moccasin
+
194 , ubyte_array{ 255, 222, 173 } // Navajowhite
+
195 , ubyte_array{ 0, 0, 128 } // Navy
+
196 , ubyte_array{ 253, 245, 230 } // Oldlace
+
197 , ubyte_array{ 128, 128, 0 } // Olive
+
198 , ubyte_array{ 107, 142, 35 } // Olivedrab
+
199 , ubyte_array{ 255, 165, 0 } // Orange
+
200 , ubyte_array{ 255, 69, 0 } // Orangered
+
201 , ubyte_array{ 218, 112, 214 } // Orchid
+
202 , ubyte_array{ 238, 232, 170 } // Palegoldenrod
+
203 , ubyte_array{ 152, 251, 152 } // Palegreen
+
204 , ubyte_array{ 175, 238, 238 } // Paleturquoise
+
205 , ubyte_array{ 219, 112, 147 } // Palevioletred
+
206 , ubyte_array{ 255, 239, 213 } // Papayawhip
+
207 , ubyte_array{ 255, 218, 185 } // Peachpuff
+
208 , ubyte_array{ 205, 133, 63 } // Peru
+
209 , ubyte_array{ 255, 192, 203 } // Pink
+
210 , ubyte_array{ 221, 160, 221 } // Plum
+
211 , ubyte_array{ 176, 224, 230 } // Powderblue
+
212 , ubyte_array{ 128, 0, 128 } // Purple
+
213 , ubyte_array{ 255, 0, 0 } // Red
+
214 , ubyte_array{ 188, 143, 143 } // Rosybrown
+
215 , ubyte_array{ 65, 105, 225 } // Royalblue
+
216 , ubyte_array{ 139, 69, 19 } // Saddlebrown
+
217 , ubyte_array{ 250, 128, 114 } // Salmon
+
218 , ubyte_array{ 244, 164, 96 } // Sandybrown
+
219 , ubyte_array{ 46, 139, 87 } // Seagreen
+
220 , ubyte_array{ 255, 245, 238 } // Seashell
+
221 , ubyte_array{ 160, 82, 45 } // Sienna
+
222 , ubyte_array{ 192, 192, 192 } // Silver
+
223 , ubyte_array{ 135, 206, 235 } // Skyblue
+
224 , ubyte_array{ 106, 90, 205 } // Slateblue
+
225 , ubyte_array{ 112, 128, 144 } // Slategray
+
226 , ubyte_array{ 112, 128, 144 } // Slategrey
+
227 , ubyte_array{ 255, 250, 250 } // Snow
+
228 , ubyte_array{ 0, 255, 127 } // Springgreen
+
229 , ubyte_array{ 70, 130, 180 } // Steelblue
+
230 , ubyte_array{ 210, 180, 140 } // Tan
+
231 , ubyte_array{ 0, 128, 128 } // Teal
+
232 , ubyte_array{ 216, 191, 216 } // Thistle
+
233 , ubyte_array{ 255, 99, 71 } // Tomato
+
234 , ubyte_array{ 64, 224, 208 } // Turquoise
+
235 , ubyte_array{ 238, 130, 238 } // Violet
+
236 , ubyte_array{ 245, 222, 179 } // Wheat
+
237 , ubyte_array{ 255, 255, 255 } // White
+
238 , ubyte_array{ 245, 245, 245 } // Whitesmoke
+
239 , ubyte_array{ 255, 255, 0 } // Yellow
+
240 , ubyte_array{ 154, 205, 50 } // Yellowgreen
+
241 };
+
242
+
243 std::array ArithmeticRGB = { // Types::real ArithmeticRGB[][3]
+
244 // KITgreen
+
245 float_array{ 0 , 0.588, 0.509 } // KITgreen
+
246 , float_array{ 0.3 , 0.711, 0.656 } // KITgreen70
+
247 , float_array{ 0.5 , 0.794, 0.754 } // KITgreen50
+
248 , float_array{ 0.7 , 0.876, 0.852 } // KITgreen30
+
249 , float_array{ 0.85 , 0.938, 0.926 } // KITgreen15
+
250 // KITblue
+
251 , float_array{ 0.274, 0.392, 0.666 } // KITblue
+
252 , float_array{ 0.492, 0.574, 0.766 } // KITblue70
+
253 , float_array{ 0.637, 0.696, 0.833 } // KITblue50
+
254 , float_array{ 0.782, 0.817, 0.9 } // KITblue30
+
255 , float_array{ 0.891, 0.908, 0.95 } // KITblue15
+
256 // KITblack
+
257 , float_array{ 0 , 0 , 0 } // KITblack
+
258 , float_array{ 0.3 , 0.3 , 0.3 } // KITblack70
+
259 , float_array{ 0.5 , 0.5 , 0.5 } // KITblack50
+
260 , float_array{ 0.7 , 0.7 , 0.7 } // KITblack32
+
261 , float_array{ 0.7 , 0.7 , 0.7 } // KITblack31
+
262 , float_array{ 0.7 , 0.7 , 0.7 } // KITblack30
+
263 , float_array{ 0.71 , 0.71 , 0.71 } // KITblack29
+
264 , float_array{ 0.72 , 0.72 , 0.72 } // KITblack28
+
265 , float_array{ 0.73 , 0.73 , 0.73 } // KITblack27
+
266 , float_array{ 0.74 , 0.74 , 0.74 } // KITblack26
+
267 , float_array{ 0.75 , 0.75 , 0.75 } // KITblack25
+
268 , float_array{ 0.76 , 0.76 , 0.76 } // KITblack24
+
269 , float_array{ 0.77 , 0.77 , 0.77 } // KITblack23
+
270 , float_array{ 0.78 , 0.78 , 0.78 } // KITblack22
+
271 , float_array{ 0.79 , 0.79 , 0.79 } // KITblack21
+
272 , float_array{ 0.80 , 0.80 , 0.80 } // KITblack20
+
273 , float_array{ 0.81 , 0.81 , 0.81 } // KITblack19
+
274 , float_array{ 0.82 , 0.82 , 0.82 } // KITblack18
+
275 , float_array{ 0.83 , 0.83 , 0.83 } // KITblack17
+
276 , float_array{ 0.84 , 0.84 , 0.84 } // KITblack16
+
277 , float_array{ 0.85 , 0.85 , 0.85 } // KITblack15
+
278 , float_array{ 0.86 , 0.86 , 0.86 } // KITblack14
+
279 , float_array{ 0.87 , 0.87 , 0.87 } // KITblack13
+
280 , float_array{ 0.88 , 0.88 , 0.88 } // KITblack12
+
281 , float_array{ 0.89 , 0.89 , 0.89 } // KITblack11
+
282 , float_array{ 0.90 , 0.90 , 0.90 } // KITblack10
+
283 , float_array{ 0.91 , 0.91 , 0.91 } // KITblack09
+
284 , float_array{ 0.92 , 0.92 , 0.92 } // KITblack08
+
285 , float_array{ 0.93 , 0.93 , 0.93 } // KITblack07
+
286 , float_array{ 0.94 , 0.94 , 0.94 } // KITblack06
+
287 , float_array{ 0.95 , 0.95 , 0.95 } // KITblack05
+
288 , float_array{ 0.96 , 0.96 , 0.96 } // KITblack04
+
289 , float_array{ 0.97 , 0.97 , 0.97 } // KITblack03
+
290 , float_array{ 0.98 , 0.98 , 0.98 } // KITblack02
+
291 , float_array{ 0.99 , 0.99 , 0.99 } // KITblack01
+
292 // KITpalegreen
+
293 , float_array{ 0.509, 0.745, 0.235 } // KITpalegreen
+
294 , float_array{ 0.656, 0.821, 0.464 } // KITpalegreen70
+
295 , float_array{ 0.754, 0.872, 0.617 } // KITpalegreen50
+
296 , float_array{ 0.852, 0.923, 0.77 } // KITpalegreen30
+
297 , float_array{ 0.926, 0.961, 0.885 } // KITpalegreen15
+
298 // KITyellow
+
299 , float_array{ 0.98 , 0.901, 0.078 } // KITyellow
+
300 , float_array{ 0.986, 0.931, 0.354 } // KITyellow70
+
301 , float_array{ 0.99 , 0.95 , 0.539 } // KITyellow50
+
302 , float_array{ 0.994, 0.97 , 0.723 } // KITyellow30
+
303 , float_array{ 0.997, 0.985, 0.861 } // KITyellow15
+
304 // KITorange
+
305 , float_array{ 0.862, 0.627, 0.117 } // KITorange
+
306 , float_array{ 0.903, 0.739, 0.382 } // KITorange70
+
307 , float_array{ 0.931, 0.813, 0.558 } // KITorange50
+
308 , float_array{ 0.958, 0.888, 0.735 } // KITorange30
+
309 , float_array{ 0.979, 0.944, 0.867 } // KITorange15
+
310 // KITbrown
+
311 , float_array{ 0.627, 0.509, 0.196 } // KITbrown
+
312 , float_array{ 0.739, 0.656, 0.437 } // KITbrown70
+
313 , float_array{ 0.813, 0.754, 0.598 } // KITbrown50
+
314 , float_array{ 0.888, 0.852, 0.758 } // KITbrown30
+
315 , float_array{ 0.944, 0.926, 0.879 } // KITbrown15
+
316 // KITred
+
317 , float_array{ 0.627, 0.117, 0.156 } // KITred
+
318 , float_array{ 0.739, 0.382, 0.409 } // KITred70
+
319 , float_array{ 0.813, 0.558, 0.578 } // KITred50
+
320 , float_array{ 0.888, 0.735, 0.747 } // KITred30
+
321 , float_array{ 0.944, 0.867, 0.873 } // KITred15
+
322 // KITlilac
+
323 , float_array{ 0.627, 0 , 0.47 } // KITlilac
+
324 , float_array{ 0.739, 0.3 , 0.629 } // KITlilac70
+
325 , float_array{ 0.813, 0.5 , 0.735 } // KITlilac50
+
326 , float_array{ 0.888, 0.7 , 0.841 } // KITlilac30
+
327 , float_array{ 0.944, 0.85 , 0.92 } // KITlilac15
+
328 // KITcyanblue
+
329 , float_array{ 0.313, 0.666, 0.901 } // KITcyanblue
+
330 , float_array{ 0.519, 0.766, 0.931 } // KITcyanblue70
+
331 , float_array{ 0.656, 0.833, 0.95 } // KITcyanblue50
+
332 , float_array{ 0.794, 0.9 , 0.97 } // KITcyanblue30
+
333 , float_array{ 0.897, 0.95 , 0.985 } // KITcyanblue15
+
334 // KITseablue
+
335 , float_array{ 0.196, 0.313, 0.549 } // KITseablue
+
336 , float_array{ 0.437, 0.519, 0.684 } // KITseablue70
+
337 , float_array{ 0.598, 0.656, 0.774 } // KITseablue50
+
338 , float_array{ 0.758, 0.794, 0.864 } // KITseablue30
+
339 , float_array{ 0.879, 0.897, 0.932 } // KITseablue15
+
340 //
+
341 // Thesis Colors
+
342 , float_array{ 0.337, 0.592, 0.773 } // THESISblue
+
343 , float_array{ 0.212, 0.471, 0.655 } // THESISblue_dark
+
344 , float_array{ 0.490, 0.710, 0.867 } // THESISblue_light
+
345 , float_array{ 0.871, 0.937, 0.988 } // THESISblue_vlight
+
346 //
+
347 , float_array{ 0.776, 0.357, 0.396 } // THESISred
+
348 , float_array{ 0.663, 0.235, 0.271 } // THESISred_dark
+
349 , float_array{ 0.867, 0.502, 0.533 } // THESISred_light
+
350 , float_array{ 0.984, 0.871, 0.878 } // THESISred_vlight
+
351 //
+
352 , float_array{ 0.337, 0.765, 0.235 } // THESISgreen
+
353 , float_array{ 0.267, 0.612, 0.184 } // THESISgreen_dark
+
354 , float_array{ 0.443, 0.871, 0.341 } // THESISgreen_light
+
355 , float_array{ 0.710, 0.984, 0.643 } // THESISgreen_vlight
+
356 //
+
357 , float_array{ 0.808, 0.659, 0.263 } // THESISyellow
+
358 , float_array{ 0.667, 0.529, 0.180 } // THESISyellow_dark
+
359 , float_array{ 0.898, 0.765, 0.412 } // THESISyellow_light
+
360 , float_array{ 0.992, 0.933, 0.776 } // THESISyellow_vlight
+
361 //
+
362 , float_array{ 0 , 0 , 0 } // THESISblack
+
363 , float_array{ 0.3 , 0.3 , 0.3 } // THESISblack70
+
364 , float_array{ 0.5 , 0.5 , 0.5 } // THESISblack50
+
365 , float_array{ 0.7 , 0.7 , 0.7 } // THESISblack30
+
366 , float_array{ 0.85 , 0.85 , 0.85 } // THESISblack15
+
367 , float_array{ 0.92 , 0.92 , 0.92 } // THESISblack7
+
368 // OGDF
+
369 , float_array{ 0.855, 0.647, 0.125 } // Goldenrod
+
370 , float_array{ 0.002, 0.002, 0.002 } // Gray
+
371 , float_array{ 0 , 0.002, 0 } // Green
+
372 , float_array{ 0.678, 1.0 , 0.184 } // Greenyellow
+
373 , float_array{ 0.002, 0.002, 0.002 } // Grey
+
374 , float_array{ 0.941, 1.0 , 0.941 } // Honeydew
+
375 , float_array{ 1.000, 0.412, 0.706 } // Hotpink
+
376 , float_array{ 0.804, 0.361, 0.361 } // Indianred
+
377 , float_array{ 0.294, 0.000, 0.510 } // Indigo
+
378 , float_array{ 1.000, 1.000, 0.941 } // Ivory
+
379 , float_array{ 0.941, 0.902, 0.549 } // Khaki
+
380 , float_array{ 0.902, 0.902, 0.980 } // Lavender
+
381 , float_array{ 1.000, 0.941, 0.961 } // Lavenderblush
+
382 , float_array{ 0.486, 0.988, 0.000 } // Lawngreen
+
383 , float_array{ 1.000, 0.980, 0.804 } // Lemonchiffon
+
384 , float_array{ 0.678, 0.847, 0.902 } // Lightblue
+
385 , float_array{ 0.941, 0.002, 0.002 } // Lightcoral
+
386 , float_array{ 0.878, 1.000, 1.000 } // Lightcyan
+
387 , float_array{ 0.980, 0.980, 0.824 } // Lightgoldenrodyellow
+
388 , float_array{ 0.827, 0.827, 0.827 } // Lightgray
+
389 , float_array{ 0.565, 0.933, 0.565 } // Lightgreen
+
390 , float_array{ 0.827, 0.827, 0.827 } // Lightgrey
+
391 , float_array{ 1.000, 0.714, 0.757 } // Lightpink
+
392 , float_array{ 1.000, 0.627, 0.478 } // Lightsalmon
+
393 , float_array{ 0.125, 0.698, 0.667 } // Lightseagreen
+
394 , float_array{ 0.529, 0.808, 0.980 } // Lightskyblue
+
395 , float_array{ 0.467, 0.533, 0.600 } // Lightslategray
+
396 , float_array{ 0.467, 0.533, 0.600 } // Lightslategrey
+
397 , float_array{ 0.690, 0.769, 0.871 } // Lightsteelblue
+
398 , float_array{ 1.000, 1.000, 0.878 } // Lightyellow
+
399 , float_array{ 0.000, 1.000, 0.000 } // Lime
+
400 , float_array{ 0.196, 0.804, 0.196 } // Limegreen
+
401 , float_array{ 0.980, 0.941, 0.902 } // Linen
+
402 , float_array{ 1.000, 0.000, 1.000 } // Magenta
+
403 , float_array{ 0.002, 0 , 0 } // Maroon
+
404 , float_array{ 0.400, 0.804, 0.667 } // Mediumaquamarine
+
405 , float_array{ 0.000, 0.000, 0.804 } // Mediumblue
+
406 , float_array{ 0.729, 0.333, 0.827 } // Mediumorchid
+
407 , float_array{ 0.576, 0.439, 0.859 } // Mediumpurple
+
408 , float_array{ 0.235, 0.700, 0.443 } // Mediumseagreen
+
409 , float_array{ 0.482, 0.408, 0.933 } // Mediumslateblue
+
410 , float_array{ 0.000, 0.980, 0.604 } // Mediumspringgreen
+
411 , float_array{ 0.282, 0.820, 0.800 } // Mediumturquoise
+
412 , float_array{ 0.780, 0.082, 0.522 } // Mediumvioletred
+
413 , float_array{ 0.098, 0.098, 0.439 } // Midnightblue
+
414 , float_array{ 0.961, 1.000, 0.980 } // Mintcream
+
415 , float_array{ 1.000, 0.894, 0.882 } // Mistyrose
+
416 , float_array{ 1.000, 0.894, 0.003 } // Moccasin
+
417 , float_array{ 1.000, 0.871, 0.678 } // Navajowhite
+
418 , float_array{ 0 , 0 , 0.002 } // Navy
+
419 , float_array{ 0.992, 0.961, 0.902 } // Oldlace
+
420 , float_array{ 0.002, 0.002, 0 } // Olive
+
421 , float_array{ 0.420, 0.557, 0.137 } // Olivedrab
+
422 , float_array{ 1.000, 0.647, 0.000 } // Orange
+
423 , float_array{ 1.000, 0.271, 0.000 } // Orangered
+
424 , float_array{ 0.855, 0.439, 0.839 } // Orchid
+
425 , float_array{ 0.933, 0.910, 0.667 } // Palegoldenrod
+
426 , float_array{ 0.596, 0.984, 0.596 } // Palegreen
+
427 , float_array{ 0.686, 0.933, 0.933 } // Paleturquoise
+
428 , float_array{ 0.859, 0.439, 0.576 } // Palevioletred
+
429 , float_array{ 1.0 , 0.937, 0.835 } // Papayawhip
+
430 , float_array{ 1.0 , 0.855, 0.725 } // Peachpuff
+
431 , float_array{ 0.804, 0.522, 0.247 } // Peru
+
432 , float_array{ 1.0 , 0.753, 0.796 } // Pink
+
433 , float_array{ 0.867, 0.627, 0.867 } // Plum
+
434 , float_array{ 0.690, 0.878, 0.902 } // Powderblue
+
435 , float_array{ 0.002, 0 , 0.002 } // Purple
+
436 , float_array{ 1.0 , 0 , 0 } // Red
+
437 , float_array{ 0.737, 0.561, 0.561 } // Rosybrown
+
438 , float_array{ 0.255, 0.412, 0.882 } // Royalblue
+
439 , float_array{ 0.545, 0.271, 0.075 } // Saddlebrown
+
440 , float_array{ 0.980, 0.002, 0.447 } // Salmon
+
441 , float_array{ 0.957, 0.643, 0.376 } // Sandybrown
+
442 , float_array{ 0.180, 0.545, 0.341 } // Seagreen
+
443 , float_array{ 1.0 , 0.961, 0.933 } // Seashell
+
444 , float_array{ 0.627, 0.322, 0.176 } // Sienna
+
445 , float_array{ 0.753, 0.753, 0.753 } // Silver
+
446 , float_array{ 0.529, 0.808, 0.922 } // Skyblue
+
447 , float_array{ 0.416, 0.353, 0.804 } // Slateblue
+
448 , float_array{ 0.439, 0.002, 0.565 } // Slategray
+
449 , float_array{ 0.439, 0.002, 0.565 } // Slategrey
+
450 , float_array{ 1.0 , 0.980, 0.980 } // Snow
+
451 , float_array{ 0 , 1.0 , 0.498 } // Springgreen
+
452 , float_array{ 0.275, 0.510, 0.706 } // Steelblue
+
453 , float_array{ 0.824, 0.706, 0.549 } // Tan
+
454 , float_array{ 0 , 0.002, 0.002 } // Teal
+
455 , float_array{ 0.847, 0.749, 0.847 } // Thistle
+
456 , float_array{ 1.0 , 0.388, 0.278 } // Tomato
+
457 , float_array{ 0.251, 0.878, 0.826 } // Turquoise
+
458 , float_array{ 0.933, 0.510, 0.933 } // Violet
+
459 , float_array{ 0.961, 0.871, 0.003 } // Wheat
+
460 , float_array{ 1.0 , 1.0 , 1.0 } // White
+
461 , float_array{ 0.961, 0.961, 0.961 } // Whitesmoke
+
462 , float_array{ 1.0 , 1.0 , 0 } // Yellow
+
463 , float_array{ 0.604, 0.804, 0.196 } // Yellowgreen
+
464 };
+
465
+
466 Color::Color(Color::Name name)
+
467 : red_( ArithmeticRGB[static_cast<Types::count>(name)][0])
+
468 , green_( ArithmeticRGB[static_cast<Types::count>(name)][1])
+
469 , blue_( ArithmeticRGB[static_cast<Types::count>(name)][2])
+
470 , alpha_(0)
+
471 {}
+
472
+
473 void Color::Red( Types::ubyte red ) {
+
474 this->red() = ( red / 255 );
+
475 }
+
476
+
477 Types::ubyte Color::Red() const {
+
478 return static_cast<Types::ubyte>( red_ * 255 >= 0.0 )?
+
479 ( red_ * 255 + 0.5 ):
+
480 ( red_ * 255 - 0.5 );
+
481 }
+
482
+
483 void Color::Green( Types::ubyte green ) {
+
484 this->green() = ( green / 255 );
+
485 }
+
486
+
487 Types::ubyte Color::Green() const {
+
488 return static_cast<Types::ubyte>( green_ * 255 >= 0.0 )?
+
489 ( green_ * 255 + 0.5 ):
+
490 ( green_ * 255 - 0.5 );
+
491 }
+
492
+
493 void Color::Blue( Types::ubyte blue ) {
+
494 this->blue() = ( blue / 255 );
+
495 }
+
496
+
497 Types::ubyte Color::Blue() const {
+
498 return static_cast<Types::ubyte>( blue_ * 255 >= 0.0 )?
+
499 ( blue_ * 255 + 0.5 ):
+
500 ( blue_ * 255 - 0.5 );
+
501 }
+
502
+
503 std::string Color::Hexadecimal( ) {
+
504 std::stringstream hexstring;
+
505 hexstring << "#" << std::setfill('0') << std::setw(2) << std::uppercase
+
506 << std::hex << static_cast<int>(Red())
+
507 << std::setfill('0') << std::setw(2) << std::uppercase
+
508 << std::hex << static_cast<int>(Green())
+
509 << std::setfill('0') << std::setw(2) << std::uppercase
+
510 << std::hex << static_cast<int>(Blue())
+
511 << std::endl;
+
512 return hexstring.str();
+
513 }
+
514
+
515} // namespace egoa
+
+ +
egoa::Color::red
Types::real red() const
Definition Color.hpp:425
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_color_8hpp_source.html b/_color_8hpp_source.html new file mode 100644 index 00000000..7e13926c --- /dev/null +++ b/_color_8hpp_source.html @@ -0,0 +1,729 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Appearance/Color.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Color.hpp
+
+
+
1/*
+
2 * Color.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__COLOR_HPP
+
9#define EGOA__IO__COLOR_HPP
+
10
+
11#include <iostream>
+
12#include "Auxiliary/Types.hpp"
+
13
+
14namespace egoa {
+
15
+
+
37class Color {
+
38 public:
+
+
39 enum class Name {
+
40 KITgreen
+
41 , KITgreen70
+
42 , KITgreen50
+
43 , KITgreen30
+
44 , KITgreen15
+
45 // KITblue
+
46 , KITblue
+
47 , KITblue70
+
48 , KITblue50
+
49 , KITblue30
+
50 , KITblue15
+
51 // KITblack
+
52 , KITblack
+
53 , KITblack70
+
54 , KITblack50
+
55 , KITblack32
+
56 , KITblack31
+
57 , KITblack30
+
58 , KITblack29
+
59 , KITblack28
+
60 , KITblack27
+
61 , KITblack26
+
62 , KITblack25
+
63 , KITblack24
+
64 , KITblack23
+
65 , KITblack22
+
66 , KITblack21
+
67 , KITblack20
+
68 , KITblack19
+
69 , KITblack18
+
70 , KITblack17
+
71 , KITblack16
+
72 , KITblack15
+
73 , KITblack14
+
74 , KITblack13
+
75 , KITblack12
+
76 , KITblack11
+
77 , KITblack10
+
78 , KITblack09
+
79 , KITblack08
+
80 , KITblack07
+
81 , KITblack06
+
82 , KITblack05
+
83 , KITblack04
+
84 , KITblack03
+
85 , KITblack02
+
86 , KITblack01
+
87 // KITpalegreen
+
88 , KITpalegreen
+
89 , KITpalegreen70
+
90 , KITpalegreen50
+
91 , KITpalegreen30
+
92 , KITpalegreen15
+
93 // KITyellow
+
94 , KITyellow
+
95 , KITyellow70
+
96 , KITyellow50
+
97 , KITyellow30
+
98 , KITyellow15
+
99 // KITorange
+
100 , KITorange
+
101 , KITorange70
+
102 , KITorange50
+
103 , KITorange30
+
104 , KITorange15
+
105 // KITbrown
+
106 , KITbrown
+
107 , KITbrown70
+
108 , KITbrown50
+
109 , KITbrown30
+
110 , KITbrown15
+
111 // KITred
+
112 , KITred
+
113 , KITred70
+
114 , KITred50
+
115 , KITred30
+
116 , KITred15
+
117 // KITlilac
+
118 , KITlilac
+
119 , KITlilac70
+
120 , KITlilac50
+
121 , KITlilac30
+
122 , KITlilac15
+
123 // KITcyanblue
+
124 , KITcyanblue
+
125 , KITcyanblue70
+
126 , KITcyanblue50
+
127 , KITcyanblue30
+
128 , KITcyanblue15
+
129 // KITseablue
+
130 , KITseablue
+
131 , KITseablue70
+
132 , KITseablue50
+
133 , KITseablue30
+
134 , KITseablue15
+
135 //
+
136 // Thesis Colors
+
137 , THESISblue
+
138 , THESISblue_dark
+
139 , THESISblue_light
+
140 , THESISblue_vlight
+
141 //
+
142 , THESISred
+
143 , THESISred_dark
+
144 , THESISred_light
+
145 , THESISred_vlight
+
146 //
+
147 , THESISgreen
+
148 , THESISgreen_dark
+
149 , THESISgreen_light
+
150 , THESISgreen_vlight
+
151 //
+
152 , THESISyellow
+
153 , THESISyellow_dark
+
154 , THESISyellow_light
+
155 , THESISyellow_vlight
+
156 //
+
157 , THESISblack
+
158 , THESISblack70
+
159 , THESISblack50
+
160 , THESISblack30
+
161 , THESISblack15
+
162 , THESISblack7
+
163 // OGDF
+
164 , Goldenrod
+
165 , Gray
+
166 , Green
+
167 , Greenyellow
+
168 , Grey
+
169 , Honeydew
+
170 , Hotpink
+
171 , Indianred
+
172 , Indigo
+
173 , Ivory
+
174 , Khaki
+
175 , Lavender
+
176 , Lavenderblush
+
177 , Lawngreen
+
178 , Lemonchiffon
+
179 , Lightblue
+
180 , Lightcoral
+
181 , Lightcyan
+
182 , Lightgoldenrodyellow
+
183 , Lightgray
+
184 , Lightgreen
+
185 , Lightgrey
+
186 , Lightpink
+
187 , Lightsalmon
+
188 , Lightseagreen
+
189 , Lightskyblue
+
190 , Lightslategray
+
191 , Lightslategrey
+
192 , Lightsteelblue
+
193 , Lightyellow
+
194 , Lime
+
195 , Limegreen
+
196 , Linen
+
197 , Magenta
+
198 , Maroon
+
199 , Mediumaquamarine
+
200 , Mediumblue
+
201 , Mediumorchid
+
202 , Mediumpurple
+
203 , Mediumseagreen
+
204 , Mediumslateblue
+
205 , Mediumspringgreen
+
206 , Mediumturquoise
+
207 , Mediumvioletred
+
208 , Midnightblue
+
209 , Mintcream
+
210 , Mistyrose
+
211 , Moccasin
+
212 , Navajowhite
+
213 , Navy
+
214 , Oldlace
+
215 , Olive
+
216 , Olivedrab
+
217 , Orange
+
218 , Orangered
+
219 , Orchid
+
220 , Palegoldenrod
+
221 , Palegreen
+
222 , Paleturquoise
+
223 , Palevioletred
+
224 , Papayawhip
+
225 , Peachpuff
+
226 , Peru
+
227 , Pink
+
228 , Plum
+
229 , Powderblue
+
230 , Purple
+
231 , Red
+
232 , Rosybrown
+
233 , Royalblue
+
234 , Saddlebrown
+
235 , Salmon
+
236 , Sandybrown
+
237 , Seagreen
+
238 , Seashell
+
239 , Sienna
+
240 , Silver
+
241 , Skyblue
+
242 , Slateblue
+
243 , Slategray
+
244 , Slategrey
+
245 , Snow
+
246 , Springgreen
+
247 , Steelblue
+
248 , Tan
+
249 , Teal
+
250 , Thistle
+
251 , Tomato
+
252 , Turquoise
+
253 , Violet
+
254 , Wheat
+
255 , White
+
256 , Whitesmoke
+
257 , Yellow
+
258 , Yellowgreen
+
259 };
+
+
260 public:
+
261 // Color ( Type::ubyte red = 0, Type::ubyte green = 0, Type::ubyte blue = 0, Type::ubyte alpha = 0 )
+
262 // : red_(red), green_(green), blue_(blue), alpha_(alpha) {}
+
263
+
264 Color ( Types::real red = 0.0, Types::real green = 0.0, Types::real blue = 0, Types::real alpha = 0 )
+
265 : red_(red), green_(green), blue_(blue), alpha_(alpha) {
+
266 if ( red_ > 1) {
+
267 red_ = red_ / 255;
+
268 }
+
269 if ( green_ > 1) {
+
270 green_ = green_ / 255;
+
271 }
+
272 if ( blue_ > 1) {
+
273 blue_ = blue_ / 255;
+
274 }
+
275 }
+
276
+
277 Color(Color::Name name);
+
278
+
279 ~Color(){}
+
280
+
281
+
282 bool operator== ( Color const & rhs ) {
+
283 return Red() == rhs.Red() && Green() == rhs.Green() && Blue() == rhs.Blue();
+
284 }
+
285
+
286 bool operator!= ( Color const & rhs ) {
+
287 return !operator==(rhs);
+
288 }
+
289
+
290 friend std::ostream& operator<<(std::ostream& os, Name const color ) {
+
291 switch ( color ) {
+
292 case Name::KITgreen: os << "KITgreen"; break;
+
293 case Name::KITgreen70: os << "KITgreen70"; break;
+
294 case Name::KITgreen50: os << "KITgreen50"; break;
+
295 case Name::KITgreen30: os << "KITgreen30"; break;
+
296 case Name::KITgreen15: os << "KITgreen15"; break;
+
297
+
298 case Name::KITblue: os << "KITgreen"; break;
+
299 case Name::KITblue70: os << "KITgreen70"; break;
+
300 case Name::KITblue50: os << "KITgreen50"; break;
+
301 case Name::KITblue30: os << "KITgreen30"; break;
+
302 case Name::KITblue15: os << "KITgreen15"; break;
+
303
+
304 case Name::KITblack: os << "KITblack"; break;
+
305 case Name::KITblack70: os << "KITblack70"; break;
+
306 case Name::KITblack50: os << "KITblack50"; break;
+
307 case Name::KITblack32: os << "KITblack32"; break;
+
308 case Name::KITblack31: os << "KITblack31"; break;
+
309 case Name::KITblack30: os << "KITblack30"; break;
+
310 case Name::KITblack29: os << "KITblack29"; break;
+
311 case Name::KITblack28: os << "KITblack28"; break;
+
312 case Name::KITblack27: os << "KITblack27"; break;
+
313 case Name::KITblack26: os << "KITblack26"; break;
+
314 case Name::KITblack25: os << "KITblack25"; break;
+
315 case Name::KITblack24: os << "KITblack24"; break;
+
316 case Name::KITblack23: os << "KITblack23"; break;
+
317 case Name::KITblack22: os << "KITblack22"; break;
+
318 case Name::KITblack21: os << "KITblack21"; break;
+
319 case Name::KITblack20: os << "KITblack20"; break;
+
320 case Name::KITblack19: os << "KITblack19"; break;
+
321 case Name::KITblack18: os << "KITblack18"; break;
+
322 case Name::KITblack17: os << "KITblack17"; break;
+
323 case Name::KITblack16: os << "KITblack16"; break;
+
324 case Name::KITblack15: os << "KITblack15"; break;
+
325 case Name::KITblack14: os << "KITblack14"; break;
+
326 case Name::KITblack13: os << "KITblack13"; break;
+
327 case Name::KITblack12: os << "KITblack12"; break;
+
328 case Name::KITblack11: os << "KITblack11"; break;
+
329 case Name::KITblack10: os << "KITblack10"; break;
+
330 case Name::KITblack09: os << "KITblack09"; break;
+
331 case Name::KITblack08: os << "KITblack08"; break;
+
332 case Name::KITblack07: os << "KITblack07"; break;
+
333 case Name::KITblack06: os << "KITblack06"; break;
+
334 case Name::KITblack05: os << "KITblack05"; break;
+
335 case Name::KITblack04: os << "KITblack04"; break;
+
336 case Name::KITblack03: os << "KITblack03"; break;
+
337 case Name::KITblack02: os << "KITblack02"; break;
+
338 case Name::KITblack01: os << "KITblack01"; break;
+
339
+
340 case Name::KITpalegreen: os << "KITpalegreen"; break;
+
341 case Name::KITpalegreen70: os << "KITpalegreen70"; break;
+
342 case Name::KITpalegreen50: os << "KITpalegreen50"; break;
+
343 case Name::KITpalegreen30: os << "KITpalegreen30"; break;
+
344 case Name::KITpalegreen15: os << "KITpalegreen15"; break;
+
345
+
346 case Name::KITyellow: os << "KITyellow"; break;
+
347 case Name::KITyellow70: os << "KITyellow70"; break;
+
348 case Name::KITyellow50: os << "KITyellow50"; break;
+
349 case Name::KITyellow30: os << "KITyellow30"; break;
+
350 case Name::KITyellow15: os << "KITyellow15"; break;
+
351
+
352 case Name::KITorange: os << "KITorange"; break;
+
353 case Name::KITorange70: os << "KITorange70"; break;
+
354 case Name::KITorange50: os << "KITorange50"; break;
+
355 case Name::KITorange30: os << "KITorange30"; break;
+
356 case Name::KITorange15: os << "KITorange15"; break;
+
357
+
358 case Name::KITbrown: os << "KITbrown"; break;
+
359 case Name::KITbrown70: os << "KITbrown70"; break;
+
360 case Name::KITbrown50: os << "KITbrown50"; break;
+
361 case Name::KITbrown30: os << "KITbrown30"; break;
+
362 case Name::KITbrown15: os << "KITbrown15"; break;
+
363
+
364 case Name::KITred: os << "KITred"; break;
+
365 case Name::KITred70: os << "KITred70"; break;
+
366 case Name::KITred50: os << "KITred50"; break;
+
367 case Name::KITred30: os << "KITred30"; break;
+
368 case Name::KITred15: os << "KITred15"; break;
+
369
+
370 case Name::KITlilac: os << "KITlilac"; break;
+
371 case Name::KITlilac70: os << "KITlilac70"; break;
+
372 case Name::KITlilac50: os << "KITlilac50"; break;
+
373 case Name::KITlilac30: os << "KITlilac30"; break;
+
374 case Name::KITlilac15: os << "KITlilac15"; break;
+
375
+
376 case Name::KITcyanblue: os << "KITcyanblue"; break;
+
377 case Name::KITcyanblue70: os << "KITcyanblue70"; break;
+
378 case Name::KITcyanblue50: os << "KITcyanblue50"; break;
+
379 case Name::KITcyanblue30: os << "KITcyanblue30"; break;
+
380 case Name::KITcyanblue15: os << "KITcyanblue15"; break;
+
381
+
382 case Name::KITseablue: os << "KITseablue"; break;
+
383 case Name::KITseablue70: os << "KITseablue70"; break;
+
384 case Name::KITseablue50: os << "KITseablue50"; break;
+
385 case Name::KITseablue30: os << "KITseablue30"; break;
+
386 case Name::KITseablue15: os << "KITseablue15"; break;
+
387
+
388 case Name::THESISblue: os << "THESISblue"; break;
+
389 case Name::THESISblue_dark: os << "THESISblue_dark"; break;
+
390 case Name::THESISblue_light: os << "THESISblue_light"; break;
+
391 case Name::THESISblue_vlight: os << "THESISblue_vlight"; break;
+
392
+
393 case Name::THESISred: os << "THESISred"; break;
+
394 case Name::THESISred_dark: os << "THESISred_dark"; break;
+
395 case Name::THESISred_light: os << "THESISred_light"; break;
+
396 case Name::THESISred_vlight: os << "THESISred_vlight"; break;
+
397
+
398 case Name::THESISgreen: os << "THESISgreen"; break;
+
399 case Name::THESISgreen_dark: os << "THESISgreen_dark"; break;
+
400 case Name::THESISgreen_light: os << "THESISgreen_light"; break;
+
401 case Name::THESISgreen_vlight: os << "THESISgreen_vlight"; break;
+
402
+
403 case Name::THESISyellow: os << "THESISyellow"; break;
+
404 case Name::THESISyellow_dark: os << "THESISyellow_dark"; break;
+
405 case Name::THESISyellow_light: os << "THESISyellow_light"; break;
+
406 case Name::THESISyellow_vlight: os << "THESISyellow_vlight"; break;
+
407
+
408 case Name::THESISblack: os << "THESISblack"; break;
+
409 case Name::THESISblack70: os << "THESISblack70"; break;
+
410 case Name::THESISblack50: os << "THESISblack50"; break;
+
411 case Name::THESISblack30: os << "THESISblack30"; break;
+
412 case Name::THESISblack15: os << "THESISblack15"; break;
+
413 case Name::THESISblack7: os << "THESISblack7"; break;
+
414 default: os << "unknown COLOR"; break;
+
415 }
+
416 return os;
+
417 }
+
418
+
419
+
420
+
423 // RGB color model
+
424 // Arithmetic
+
425 Types::real red() const { return red_; }
+
426 Types::real & red() { return red_; }
+
427
+
428 Types::real green() const { return green_; }
+
429 Types::real & green() { return green_; }
+
430
+
431 Types::real blue() const { return blue_; }
+
432 Types::real & blue() { return blue_; }
+
433
+
434 // Digital 8-bit per channel
+
435 Types::ubyte Red() const;
+
436 void Red( Types::ubyte red);
+
437
+
438 Types::ubyte Green() const;
+
439 void Green( Types::ubyte green);
+
440
+
441 Types::ubyte Blue() const;
+
442 void Blue( Types::ubyte blue );
+
444
+
445 std::string Hexadecimal();
+
446 private:
+
447 Types::real red_;
+
448 Types::real green_;
+
449 Types::real blue_;
+
450 Types::real alpha_;
+
451}; //Color
+
+
452
+
453} // egoa
+
454
+
455#endif // EGOA__IO__COLOR_HPP
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::Color::red
Types::real red() const
Definition Color.hpp:425
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_comparators_8hpp_source.html b/_comparators_8hpp_source.html new file mode 100644 index 00000000..687039cc --- /dev/null +++ b/_comparators_8hpp_source.html @@ -0,0 +1,133 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/Comparators.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Comparators.hpp
+
+
+
1/*
+
2 * Comparators.hpp
+
3 *
+
4 * Created on: May 09, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__AUXILIARY__COMPARATORS_HPP
+
9#define EGOA__AUXILIARY__COMPARATORS_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12
+
13namespace egoa {
+
14
+
22template<typename WeightType, typename ComparatorType = std::less<WeightType>>
+
+
23class VectorBasedComparator {
+
24public:
+
+
31 VectorBasedComparator(std::vector<WeightType> const & weights,
+
32 ComparatorType comparator = std::less<WeightType>())
+
33 : weights_(weights),
+
34 comparator_(std::move(comparator))
+
35 {}
+
+
36
+
37 bool operator()(Types::index lhs, Types::index rhs) const
+
38 {
+
39 return comparator_(weights_[lhs], weights_[rhs]);
+
40 }
+
41
+
42private:
+
43 std::vector<WeightType> const & weights_;
+
44 ComparatorType comparator_;
+
45};
+
+
46
+
47} // namespace egoa
+
48
+
49#endif // EGOA__AUXILIARY__COMPARATORS_HPP
+
egoa::VectorBasedComparator
A comparator that compares based on elements in the vector.
Definition Comparators.hpp:23
+
egoa::VectorBasedComparator::VectorBasedComparator
VectorBasedComparator(std::vector< WeightType > const &weights, ComparatorType comparator=std::less< WeightType >())
The constructor.
Definition Comparators.hpp:31
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_constants_8hpp_source.html b/_constants_8hpp_source.html new file mode 100644 index 00000000..c6dba6a1 --- /dev/null +++ b/_constants_8hpp_source.html @@ -0,0 +1,125 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/Constants.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Constants.hpp
+
+
+
1/*
+
2 * Constants.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__AUXILIARY__CONSTANTS_HPP
+
8#define EGOA__AUXILIARY__CONSTANTS_HPP
+
9
+
10#define _USE_MATH_DEFINES
+
11#include <cmath>
+
12
+
13#include "Auxiliary/Types.hpp"
+
14#ifdef GUROBI_AVAILABLE
+
15 #include "gurobi_c++.h"
+
16#endif
+
17
+
18namespace egoa::Const {
+
21 constexpr Types::count SEC_PER_DAY = 24 * 60 * 60;
+
22 constexpr Types::count SEC_PER_MIN = 60 * 60;
+
23 // 1 ns (for nanosecond) correspond to 1,000,000,000 s (for seconds)
+
24 constexpr Types::count NSEC_PER_SEC = 1000000000; // pow(10,9)
+
25 // 1 ns (for nanosecond) correspond to 1,000,000 ms (for milliseconds)
+
26 constexpr Types::count NSEC_PER_MILLISEC = 1000000;
+
27 constexpr Types::count MILLISEC_PER_SEC = 1000;
+
28
+
29 constexpr Types::real EPSILON = std::numeric_limits<Types::real>::epsilon();
+
30 constexpr Types::index NONE = std::numeric_limits<Types::posInteger>::max();
+
31 constexpr Types::count INFTY = std::numeric_limits<Types::posInteger>::max();
+
32 constexpr Types::real REAL_INFTY = std::numeric_limits<Types::real>::max();
+
33
+
34 constexpr Types::real PI = M_PI;
+
36} // namespace egoa::Const
+
37
+
38#endif // EGOA__AUXILIARY__CONSTANTS_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_container_loop_8hpp_source.html b/_container_loop_8hpp_source.html new file mode 100644 index 00000000..c71f7b21 --- /dev/null +++ b/_container_loop_8hpp_source.html @@ -0,0 +1,189 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/ContainerLoop.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ContainerLoop.hpp
+
+
+
1/*
+
2 * ContainerLoop.hpp
+
3 *
+
4 * Created on: Mar 8, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__AUXILIARY__CONTAINER_LOOP_HPP
+
9#define EGOA__DATA_STRUCTURES__AUXILIARY__CONTAINER_LOOP_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif
+
14
+
15#include <algorithm>
+
16
+
17#include "Auxiliary/ExecutionPolicy.hpp"
+
18#include "Auxiliary/Types.hpp"
+
19
+
20namespace egoa::internal {
+
21
+
27template<ExecutionPolicy Policy>
+
28struct ContainerLoop;
+
29
+
33template<>
+
+
34struct ContainerLoop<ExecutionPolicy::sequential> {
+
35
+
46 template<typename Container, typename FUNCTION>
+
+
47 static void for_each ( Container const & container, FUNCTION function )
+
48 {
+
49 using std::begin, std::end;
+
50 std::for_each(begin(container), end(container), function);
+
51 }
+
+
52};
+
+
53
+
57template<>
+
+
58struct ContainerLoop<ExecutionPolicy::breakable> {
+
59
+
69 template<typename Container, typename FUNCTION>
+
+
70 static void for_each ( Container const & container, FUNCTION function )
+
71 {
+
72 using std::begin, std::end;
+
73
+
74 bool toContinue = true;
+
75 auto last = end(container);
+
76 for ( auto it = begin(container)
+
77 ; toContinue && it != last
+
78 ; ++it )
+
79 {
+
80 toContinue = function(*it);
+
81 }
+
82 }
+
+
83};
+
+
84
+
85#ifdef OPENMP_AVAILABLE
+
86
+
90template<>
+
91struct ContainerLoop<ExecutionPolicy::parallel> {
+
92
+
102 template<typename Container, typename FUNCTION>
+
103 static void for_each ( Container const & container, FUNCTION function )
+
104 {
+
105 #pragma omp parallel for
+
106 for ( Types::index i = 0
+
107 ; i < container.size()
+
108 ; ++i )
+
109 {
+
110 function(container[i]);
+
111 }
+
112 }
+
113};
+
114
+
115#else // OPENMP_AVAILABLE
+
119template<>
+
+
120struct ContainerLoop<ExecutionPolicy::parallel>
+
121 : public ContainerLoop<ExecutionPolicy::sequential> {};
+
+
122
+
123#endif // OPENMP_AVAILABLE
+
124
+
125} // namespace egoa::internal
+
126
+
127#endif // EGOA__DATA_STRUCTURES__AUXILIARY__CONTAINER_LOOP_HPP
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
egoa::internal::ContainerLoop< ExecutionPolicy::breakable >::for_each
static void for_each(Container const &container, FUNCTION function)
Breakable loop over all elements in the container.
Definition ContainerLoop.hpp:70
+
egoa::internal::ContainerLoop< ExecutionPolicy::sequential >::for_each
static void for_each(Container const &container, FUNCTION function)
Sequential loop over all elements in the container.
Definition ContainerLoop.hpp:47
+
egoa::internal::ContainerLoop
Loops over containers.
Definition ContainerLoop.hpp:28
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_cycle_detection_8hpp_source.html b/_cycle_detection_8hpp_source.html new file mode 100644 index 00000000..12028e7a --- /dev/null +++ b/_cycle_detection_8hpp_source.html @@ -0,0 +1,124 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal/CycleDetection.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
CycleDetection.hpp
+
+
+
1/*
+
2 * CycleDetection.hpp
+
3 *
+
4 * Created on: Feb 17, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__ALGORITHMS__GRAPH_TRAVERSAL__CYCLE_DETECTION__HPP
+
8#define EGOA__ALGORITHMS__GRAPH_TRAVERSAL__CYCLE_DETECTION__HPP
+
9
+
10#include "Algorithms/GraphTraversal/DepthFirstSearch.hpp"
+
11
+
12namespace egoa {
+
13
+
26template< typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>
+
27 , bool IsDirected = false >
+
28class CycleDetection final : public DFS<GraphType, IsDirected> {
+
29 public:
+
30#pragma mark CONSTRUCTOR_AND_DESTRUCTOR
+
31 CycleDetection ( TGraph const & graph, TVertex source )
+
32 : DFS ( graph, source ){}
+
33
+
34#pragma mark FURTHER_PROCESSING
+
45 virtual inline void ProcessingEdgeWith ( TVertex const source
+
46 , TVertex const target ) override
+
47 {
+
48 if ( source != ParentOf ( target ) ) {
+
49 ExtractPath ( source, target );
+
50 SetTerminate();
+
51 }
+
52 }
+
53};
+
54
+
55#endif // EGOA__ALGORITHMS__GRAPH_TRAVERSAL__CYCLE_DETECTION__HPP
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_data_structures_2_graphs_2_edges_2_edge_8hpp_source.html b/_data_structures_2_graphs_2_edges_2_edge_8hpp_source.html new file mode 100644 index 00000000..231da9bd --- /dev/null +++ b/_data_structures_2_graphs_2_edges_2_edge_8hpp_source.html @@ -0,0 +1,197 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Edges/Edge.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Edge.hpp
+
+
+
1/*
+
2 * Edge.hpp
+
3 *
+
4 * Created on: Mar 8, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__EDGES__EDGE_HPP
+
9#define EGOA__DATA_STRUCTURES__EDGES__EDGE_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12#include "Auxiliary/Constants.hpp"
+
13
+
14namespace egoa {
+
15 template<typename, typename>
+
16 class DynamicGraph;
+
17}
+
18
+
19namespace egoa::Edges {
+
20
+
26template<typename PropertiesType>
+
+
27class Edge {
+
28 public:
+
29 using TProperties = PropertiesType;
+
30
+
33#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
34
+
35 Edge(Types::edgeId identifier,
+
36 Types::vertexId source,
+
37 Types::vertexId target,
+
38 TProperties properties)
+
39 : identifier_(identifier),
+
40 source_(source),
+
41 target_(target),
+
42 properties_(std::move(properties)) {
+
43 }
+
45
+
48#pragma mark GETTER_AND_SETTER
+
49 inline Types::index Identifier() const { return identifier_; }
+
50 inline Types::vertexId Source() const { return source_; }
+
51 inline Types::vertexId Target() const { return target_; }
+
52
+
53 inline TProperties & Properties() { return properties_; }
+
54 inline TProperties const & Properties() const { return properties_; }
+
56
+
+
64 inline Types::vertexId Other( Types::vertexId vertexId ) const
+
65 {
+
66 return ( Source() == vertexId )?Target():Source();
+
67 }
+
+
68
+
+
75 friend void swap( Edge & lhs, Edge & rhs )
+
76 {
+
77 using std::swap;
+
78 swap( lhs.Identifier(), rhs.Identifier() );
+
79 swap( lhs.Source(), rhs.Source() );
+
80 swap( lhs.Target(), lhs.Target() );
+
81 swap( lhs.Properties(), rhs.Properties() );
+
82 }
+
+
83
+
86#pragma mark COMPARATORS
+
+
95 friend bool operator==(Edge const & lhs, Edge const & rhs)
+
96 {
+
97 return ( lhs.Identifier() == rhs.Identifier() )
+
98 && ( lhs.Source() == rhs.Source() )
+
99 && ( lhs.Target() == rhs.Target() )
+
100 && ( lhs.Properties() == rhs.Properties() );
+
101 }
+
+
102
+
+
111 friend bool operator!=(Edge const & lhs, Edge const & rhs)
+
112 {
+
113 return !(lhs == rhs);
+
114 }
+
+
116
+
117 private:
+
118 template<typename,typename> friend class egoa::DynamicGraph;
+
119
+
122#pragma mark MEMBER
+
123 Types::edgeId identifier_;
+
124 Types::vertexId source_;
+
125 Types::vertexId target_;
+
126 TProperties properties_;
+
128};
+
+
129
+
130} // namespace egoa::Edges
+
131
+
132#endif // EGOA__DATA_STRUCTURES__EDGES__EDGE_HPP
+
egoa::DynamicGraph
A graph data structure that supports adding and removing vertices and edges.
Definition DynamicGraph.hpp:50
+
egoa::Edges::Edge
Class for edge.
Definition Edge.hpp:27
+
egoa::Edges::Edge::identifier_
Types::edgeId identifier_
Definition Edge.hpp:123
+
egoa::Edges::Edge::operator!=
friend bool operator!=(Edge const &lhs, Edge const &rhs)
Comparator.
Definition Edge.hpp:111
+
egoa::Edges::Edge::source_
Types::vertexId source_
Definition Edge.hpp:124
+
egoa::Edges::Edge::operator==
friend bool operator==(Edge const &lhs, Edge const &rhs)
Comparator.
Definition Edge.hpp:95
+
egoa::Edges::Edge::properties_
TProperties properties_
Definition Edge.hpp:126
+
egoa::Edges::Edge::Other
Types::vertexId Other(Types::vertexId vertexId) const
Return the adjacent vertex to vertexId.
Definition Edge.hpp:64
+
egoa::Edges::Edge::target_
Types::vertexId target_
Definition Edge.hpp:125
+
egoa::Edges::Edge::swap
friend void swap(Edge &lhs, Edge &rhs)
Swap two edges.
Definition Edge.hpp:75
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_data_validation_8hpp_source.html b/_data_validation_8hpp_source.html new file mode 100644 index 00000000..e9a6a745 --- /dev/null +++ b/_data_validation_8hpp_source.html @@ -0,0 +1,212 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Helper/DataValidation.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DataValidation.hpp
+
+
+
1/*
+
2 * DataValidation.hpp
+
3 *
+
4 * Created on: May 09, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__HELPER__DATA_VALIDATION_HPP
+
9#define EGOA__IO__HELPER__DATA_VALIDATION_HPP
+
10
+
11#include "Auxiliary/ExecutionPolicy.hpp"
+
12
+
13namespace egoa::IO::Helper {
+
14
+
15 template<typename TGraph>
+
16 inline bool HasGraphCorrectBounds ( TGraph const & graph )
+
17 {
+
18 using TVertex = typename TGraph::TVertex;
+
19 using TEdge = typename TGraph::TEdge;
+
20
+
21 bool hasCorrectBound = true;
+
22 // Check voltage bounds
+
23 graph.template for_all_vertices<ExecutionPolicy::sequential>(
+
24 [&hasCorrectBound]( TVertex const & vertex )
+
25 {
+
26 USAGE_ASSERT ( vertex.Properties().MinimumVoltage()
+
27 <= vertex.Properties().MaximumVoltage() );
+
28 if ( vertex.Properties().MinimumVoltage()
+
29 > vertex.Properties().MaximumVoltage() )
+
30 {
+
31 hasCorrectBound = false;
+
32 }
+
33 });
+
34
+
35 graph.template for_all_edges<ExecutionPolicy::sequential> (
+
36 [&hasCorrectBound]( TEdge const & edge )
+
37 {
+
38 // thetaBound
+
39 USAGE_ASSERT ( edge.Properties().ThetaBound().Minimum()
+
40 <= edge.Properties().ThetaBound().Maximum() );
+
41 if ( edge.Properties().ThetaBound().Minimum()
+
42 > edge.Properties().ThetaBound().Maximum() )
+
43 {
+
44 hasCorrectBound = false;
+
45 return;
+
46 }
+
47 // nominalApparentPowerBound
+
48 USAGE_ASSERT ( edge.Properties().NominalApparentPowerBound().Minimum()
+
49 <= edge.Properties().NominalApparentPowerBound().Maximum() );
+
50 if ( edge.Properties().NominalApparentPowerBound().Minimum()
+
51 > edge.Properties().NominalApparentPowerBound().Maximum() )
+
52 {
+
53 hasCorrectBound = false;
+
54 return;
+
55 }
+
56 });
+
57 return hasCorrectBound;
+
58 }
+
59
+
60 template<typename TNetwork>
+
61 inline bool HasNetworkCorrectBounds ( TNetwork const & network )
+
62 {
+
63 using TGraph = typename TNetwork::TGraph;
+
64 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
65
+
66 bool hasCorrectBound = true;
+
67
+
68 network.template for_all_generators<ExecutionPolicy::sequential> (
+
69 [&hasCorrectBound]( TGeneratorProperties const & properties )
+
70 {
+
71 // nominalRealPowerBound
+
72 USAGE_ASSERT ( properties.NominalRealPowerBound().Minimum()
+
73 <= properties.NominalRealPowerBound().Maximum() );
+
74 if ( properties.NominalRealPowerBound().Minimum()
+
75 > properties.NominalRealPowerBound().Maximum() )
+
76 {
+
77 hasCorrectBound = false;
+
78 }
+
79 // realPowerBound
+
80 USAGE_ASSERT ( properties.RealPowerBound().Minimum()
+
81 <= properties.RealPowerBound().Maximum() );
+
82 if ( properties.RealPowerBound().Minimum()
+
83 > properties.RealPowerBound().Maximum() )
+
84 {
+
85 hasCorrectBound = false;
+
86 }
+
87 // reactivePowerBound
+
88 USAGE_ASSERT ( properties.ReactivePowerBound().Minimum()
+
89 <= properties.ReactivePowerBound().Maximum() );
+
90 if ( properties.ReactivePowerBound().Minimum()
+
91 > properties.ReactivePowerBound().Maximum() )
+
92 {
+
93 hasCorrectBound = false;
+
94 return;
+
95 }
+
96 // qc1Bound
+
97 USAGE_ASSERT ( properties.Qc1Bound().Minimum()
+
98 <= properties.Qc1Bound().Maximum() );
+
99 if ( properties.Qc1Bound().Minimum()
+
100 > properties.Qc1Bound().Maximum() )
+
101 {
+
102 hasCorrectBound = false;
+
103 return;
+
104 }
+
105 // qc2Bound
+
106 USAGE_ASSERT ( properties.Qc2Bound().Minimum()
+
107 <= properties.Qc2Bound().Maximum() );
+
108 if ( properties.Qc2Bound().Minimum()
+
109 > properties.Qc2Bound().Maximum() )
+
110 {
+
111 hasCorrectBound = false;
+
112 return;
+
113 }
+
114 });
+
115
+
116 return hasCorrectBound
+
117 && HasGraphCorrectBounds<TGraph>( network.Graph() );
+
118 }
+
119
+
120} // namespace egoa::IO::Helper
+
121
+
122#endif // EGOA__IO__HELPER__DATA_VALIDATION_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_depth_first_search_8hpp_source.html b/_depth_first_search_8hpp_source.html new file mode 100644 index 00000000..5bc48e65 --- /dev/null +++ b/_depth_first_search_8hpp_source.html @@ -0,0 +1,339 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal/DepthFirstSearch.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DepthFirstSearch.hpp
+
+
+
1/*
+
2 * DFS.hpp
+
3 *
+
4 * Created on: Feb 17, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__ALGORITHMS__GRAPH_TRAVERSAL__DEPTH_FIRST_SEARCH__HPP
+
8#define EGOA__ALGORITHMS__GRAPH_TRAVERSAL__DEPTH_FIRST_SEARCH__HPP
+
9
+
10#include "Algorithms/GraphTraversal/Traversal.hpp"
+
11
+
12#include "Exceptions/Assertions.hpp"
+
13
+
14namespace egoa {
+
15
+
16enum class DfsEdgeType {
+
17 tree = 0
+
18 , backward = 1
+
19 , forward = 2
+
20 , cross = 3
+
21 , none = 99
+
22};
+
23
+
32template< typename GraphType
+
33 , bool IsDirected = false
+
34 , bool Recursive = true >
+
+
35class DepthFirstSearch : public Traversal<GraphType, IsDirected> {
+
36 public:
+
37 using TGraph = GraphType;
+
38 using TVertexId = typename TGraph::TVertexId;
+
39 using TTime = Types::count;
+
40
+
43#pragma mark CONSTRUCTOR_AND_DESTRUCTOR
+
44
+
+
51 DepthFirstSearch ( TGraph const & graph
+
52 , TVertexId source )
+
53 : Traversal<TGraph, IsDirected> ( graph, source )
+
54 , time_( 0 )
+
55 , terminate_( false )
+
56 , entryTime_( std::vector<TTime>( graph.NumberOfVertices(), 0 ) )
+
57 , exitTime_( std::vector<TTime>( graph.NumberOfVertices(), 0 ) )
+
58 {}
+
+
59
+
60 virtual ~DepthFirstSearch () {}
+
62
+
63#pragma mark DEPTH_FIRST_SEARCH
+
64 inline void Run()
+
65 {
+
66 // Recursive call
+
67 auto dfs = [this] ( TVertexId source, auto const & dfs )
+
68 {
+
69 if ( Terminate() ) return; // Search termination
+
70
+
71 entryTime_[source] = Time();
+
72 ++Time();
+
73
+
74 this->SetVertexVisitedAt( source );
+
75 PreprocessingVertexWith ( source );
+
76
+
77 this->breakable_for_all_edges_at ( source,
+
78 [source, &dfs, this]( typename GraphType::TEdge const & edge )
+
79 {
+
80 TVertexId target = edge.Other ( source );
+
81
+
82 // Ignore edges that directly lead back to the parent
+
83 if ( this->ParentOf( source ) == target ) return true;
+
84
+
85 bool targetVisited = this->VisitedVertexAt( target );
+
86
+
87 if ( !targetVisited )
+
88 {
+
89 this->ParentOf( target ) = source;
+
90 dfs ( target, dfs );
+
91 } else /* not processed */
+
92 { // Cycle edge
+
93 ProcessingEdgeWith( source, target, edge.Identifier() );
+
94 }
+
95
+
96 PostprocessingEdgeWith( source, target, edge.Identifier() );
+
97
+
98 // Search termination by returning false in the breakable loop
+
99 bool toContinue = !this->Terminate();
+
100 return toContinue;
+
101 }
+
102 );
+
103 if ( Terminate() ) return; // Search termination
+
104
+
105 exitTime_[ source ] = Time();
+
106 ++Time();
+
107
+
108 PostprocessingVertexWith ( source );
+
109 this->SetVertexProcessedAt ( source );
+
110 };
+
111
+
112 dfs ( this->Source(), dfs );
+
113 }
+
114
+
115 public:
+
116#pragma mark DFS_EDGE_TYPE
+
+
127 inline DfsEdgeType TypifyEdge ( TVertexId source, TVertexId target )
+
128 {
+
129 // Tree edge
+
130 if ( source == this->ParentOf ( target ) )
+
131 {
+
132 return DfsEdgeType::tree;
+
133 }
+
134
+
135 // Backward edge
+
136 if ( this->VisitedVertexAt ( target )
+
137 && !this->ProcessedVertexAt ( target ) )
+
138 {
+
139 return DfsEdgeType::backward;
+
140 }
+
141
+
142 // Forward edge
+
143 if ( this->ProcessedVertexAt ( target )
+
144 && EntryTimeAt ( target ) > EntryTimeAt ( source ) )
+
145 {
+
146 return DfsEdgeType::forward;
+
147 }
+
148
+
149 // Cross edge
+
150 if ( this->ProcessedVertexAt ( target )
+
151 && EntryTimeAt ( target ) < EntryTimeAt ( source ) ) return DfsEdgeType::cross;
+
152
+
153 // None of them -> should not happening
+
154 ESSENTIAL_ASSERT( false && "DFS edge type is none." );
+
155 }
+
+
156
+
157#pragma mark GETTER_AND_SETTER
+
158
+
164 inline bool Terminate() const { return terminate_; }
+
165 inline void SetTerminate() { terminate_ = true; }
+
166
+
167 private:
+
168
+
169#pragma mark TIMERS
+
176 inline TTime Time() const { return time_; }
+
177 inline TTime & Time() { return time_; }
+
179
+
180 public:
+
+
188 inline TTime EntryTimeAt ( TVertexId vertexId ) const
+
189 {
+
190 return entryTime_[vertexId];
+
191 }
+
+
192
+
+
200 inline TTime ExitTimeAt ( TVertexId const vertexId ) const
+
201 {
+
202 return exitTime_[vertexId];
+
203 }
+
+
204
+
205
+
206//exact behavior of the Depth-First Search (DFS) depends on the processing methods
+
207#pragma mark FURTHER_PROCESSING
+
208
+
219 // template<typename FUNCTION>
+
220 virtual
+
221 inline
+
+
222 void PreprocessingVertexWith ( TVertexId vertexId
+
223 // , FUNCTION function
+
224 )
+
225 {
+
226 // function ( vertexId );
+
227 }
+
+
228
+
239 // template<typename FUNCTION>
+
240 virtual
+
241 inline
+
+
242 void PostprocessingVertexWith ( TVertexId vertexId
+
243 // , FUNCTION function
+
244 )
+
245 {
+
246 // function ( vertexId );
+
247 }
+
+
248
+
249 // template<typename FUNCTION>
+
250 virtual
+
251 inline
+
252 void ProcessingEdgeWith ( TVertexId source
+
253 , TVertexId target
+
254 , Types::edgeId edgeId
+
255 // , FUNCTION function
+
256 )
+
257 {
+
258 // function ( source, target, edgeId );
+
259 }
+
260
+
271 // template<typename FUNCTION>
+
272 virtual
+
273 inline
+
+
274 void PostprocessingEdgeWith ( TVertexId source
+
275 , TVertexId target
+
276 , Types::edgeId edgeId
+
277 // , FUNCTION function
+
278 )
+
279 {
+
280 // function ( source, target, edgeId );
+
281 }
+
+
282
+
283#pragma mark MEMBERS
+
284 private:
+
285 TTime time_;
+
286 bool terminate_;
+
288 std::vector<TTime> entryTime_;
+
289 std::vector<TTime> exitTime_;
+
290}; // class DepthFirstSearch
+
+
291
+
292} // namespace egoa
+
293
+
294#endif // EGOA__ALGORITHMS__GRAPH_TRAVERSAL__DEPTH_FIRST_SEARCH__HPP
+
egoa::DepthFirstSearch
Class for the Depth-First Search (DFS).
Definition DepthFirstSearch.hpp:35
+
egoa::DepthFirstSearch::ExitTimeAt
TTime ExitTimeAt(TVertexId const vertexId) const
Returns the exit time of a vertex.
Definition DepthFirstSearch.hpp:200
+
egoa::DepthFirstSearch::Time
TTime Time() const
Modify time counter.
Definition DepthFirstSearch.hpp:176
+
egoa::DepthFirstSearch::exitTime_
std::vector< TTime > exitTime_
Definition DepthFirstSearch.hpp:289
+
egoa::DepthFirstSearch::PostprocessingVertexWith
virtual void PostprocessingVertexWith(TVertexId vertexId)
Post processing the vertex with vertexId.
Definition DepthFirstSearch.hpp:242
+ +
egoa::DepthFirstSearch::entryTime_
std::vector< TTime > entryTime_
Definition DepthFirstSearch.hpp:288
+
egoa::DepthFirstSearch::TypifyEdge
DfsEdgeType TypifyEdge(TVertexId source, TVertexId target)
Determine DFS edge type.
Definition DepthFirstSearch.hpp:127
+
egoa::DepthFirstSearch::EntryTimeAt
TTime EntryTimeAt(TVertexId vertexId) const
{ function_description }
Definition DepthFirstSearch.hpp:188
+
egoa::DepthFirstSearch::DepthFirstSearch
DepthFirstSearch(TGraph const &graph, TVertexId source)
Constructs a new DFS instance.
Definition DepthFirstSearch.hpp:51
+
egoa::DepthFirstSearch::PreprocessingVertexWith
virtual void PreprocessingVertexWith(TVertexId vertexId)
Preprocessing the vertex with vertexId.
Definition DepthFirstSearch.hpp:222
+
egoa::DepthFirstSearch::Terminate
bool Terminate() const
Terminate the DFS.
Definition DepthFirstSearch.hpp:164
+ +
egoa::DepthFirstSearch::PostprocessingEdgeWith
virtual void PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId)
Post processing the edge with edgeId.
Definition DepthFirstSearch.hpp:274
+
egoa::Traversal
Interface for graph traversal.
Definition Traversal.hpp:36
+
egoa::Traversal::breakable_for_all_edges_at
void breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges that is breakable.
Definition Traversal.hpp:231
+
egoa::Traversal::SetVertexProcessedAt
void SetVertexProcessedAt(TVertexId vertexId)
Sets the vertex at vertexId to processed.
Definition Traversal.hpp:119
+
egoa::Traversal::ProcessedVertexAt
bool ProcessedVertexAt(TVertexId vertexId) const
Getter and setter to access the process field.
Definition Traversal.hpp:135
+
egoa::Traversal::VisitedVertexAt
bool VisitedVertexAt(TVertexId vertexId) const
Getter and setter to access the visited field.
Definition Traversal.hpp:104
+
egoa::Traversal::ParentOf
TVertexId & ParentOf(TVertexId vertexId)
Getter and setter for the parent relation.
Definition Traversal.hpp:152
+
egoa::Traversal::SetVertexVisitedAt
void SetVertexVisitedAt(TVertexId vertexId)
Sets the vertex at vertexId to visited.
Definition Traversal.hpp:89
+
egoa::Traversal::Source
TVertexId Source() const
Getter and setter for the source vertex.
Definition Traversal.hpp:68
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_dominating_theta_path_8hpp_source.html b/_dominating_theta_path_8hpp_source.html new file mode 100644 index 00000000..a4d63058 --- /dev/null +++ b/_dominating_theta_path_8hpp_source.html @@ -0,0 +1,719 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/PathFinding/DominatingThetaPath.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DominatingThetaPath.hpp
+
+
+
1/*
+
2 * DominatingThetaPath.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__PATH_FINDING__DOMINATING_THETA_PATH_HPP
+
9#define EGOA__ALGORITHMS__PATH_FINDING__DOMINATING_THETA_PATH_HPP
+
10
+
11#include <unordered_set>
+
12
+
13#include "Exceptions/Assertions.hpp"
+
14
+
15#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
16#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
17
+
18#include "DataStructures/Networks/PowerGrid.hpp"
+
19
+
20#include "DataStructures/Graphs/StaticGraph.hpp"
+
21#include "DataStructures/Graphs/Subgraph.hpp"
+
22
+
23#include "DataStructures/Labels/VoltageAngleDifferenceLabel.hpp"
+
24
+
25#include "DataStructures/Container/Queues/Bucket.hpp"
+
26#include "DataStructures/Container/Queues/BinaryHeap.hpp"
+
27#include "DataStructures/Container/Queues/MappingBinaryHeap.hpp"
+
28
+
29#include "DataStructures/Container/DominationCriterion.hpp"
+
30
+
31#include "IO/Statistics/DtpRuntimeRow.hpp"
+
32
+
33#include "Auxiliary/Timer.hpp"
+
34
+
35namespace egoa {
+
36
+
53template < typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >
+
54 , typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >
+
55 , typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >
+
56 , typename LabelSetType = Bucket< BinaryHeap< LabelType > >
+
57 , DominationCriterion Domination = DominationCriterion::strict >
+
+
58class DominatingThetaPath final {
+
59 public:
+
60#pragma mark TYPE_ALIASING
+
61 // Graph specific types
+
62 using TGraph = GraphType;
+
63 using TVertex = typename GraphType::TVertex;
+
64 using TVertexId = typename GraphType::TVertexId;
+
65 using TEdge = typename GraphType::TEdge;
+
66 using TEdgeId = typename GraphType::TEdgeId;
+
67 // Label specific types
+
68 using TLabel = LabelType;
+
69 using TQueue = QueueType;
+
70 using TLabelSet = LabelSetType;
+
72 public:
+
75#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
76
+
+
82 DominatingThetaPath ( TGraph const & graph )
+
83 : graph_( graph )
+
84 , labelSets_( graph.NumberOfVertices(), TLabelSet() )
+
85 , queue_( )
+
86 {
+
87#ifdef EGOA_ENABLE_STATISTIC_DTP // NAME OF THE PROBLEM
+
88 dtpRuntimeRow_.NameOfProblem = "DtpStandard";
+
89#endif
+
90 }
+
+
91
+
+
98 DominatingThetaPath ( TGraph const & graph
+
99 , TVertexId source )
+
100 : DominatingThetaPath ( graph )
+
101 {
+
102 Clear ();
+
103 Source( source );
+
104 }
+
+
106
+
109#pragma mark EXECUTE_ALGORITHM
+
110
+
+
114 inline void Run () {
+
115#ifdef EGOA_ENABLE_STATISTIC_DTP // GRAPH INFORMATION
+
116 dtpRuntimeRow_.Name = graph_.Name();
+
117 dtpRuntimeRow_.NumberOfVertices = graph_.NumberOfVertices();
+
118 dtpRuntimeRow_.NumberOfEdges = graph_.NumberOfEdges();
+
119#endif
+
120
+
121 Auxiliary::Timer dtpTime;
+
122
+
123 while ( !QueueEmpty() )
+
124 { // Q != {}
+
125 TLabel const label = QueueDeleteMinimum();
+
126 const TVertexId u = label.Vertex();
+
127 ESSENTIAL_ASSERT ( u < graph_.NumberOfVertices() );
+
128
+
129 // For all incident edges
+
130 graph_.template for_all_edges_at<ExecutionPolicy::sequential>( u,
+
131 [&]( TEdge const & edge )
+
132 {
+
133 ESSENTIAL_ASSERT ( u < graph_.NumberOfVertices() );
+
134
+
135 TVertexId v = edge.Other(u);
+
136
+
137 ESSENTIAL_ASSERT ( v < graph_.NumberOfVertices() );
+
138
+
139#ifdef EGOA_ENABLE_STATISTIC_DTP // NUMBER OF SCANNED EDGES -> TOTAL NUMBER
+
140 ++dtpRuntimeRow_.NumberOfScannedEdges;
+
141#endif
+
142 TLabel newlabel;
+
143
+
144 if ( ProduceCycle( newlabel, label + edge ) ) return;
+
145 SetParentOf( newlabel, label );
+
146
+
147#ifdef EGOA_ENABLE_STATISTIC_DTP // NUMBER OF EDGES NOT PRODUCING A CYCLE
+
148 ++dtpRuntimeRow_.NumberOfEdgesProducingNoCycle;
+
149#endif
+
150 if ( ! MergeLabelAt( v, newlabel ) ) return;
+
151
+
152#ifdef EGOA_ENABLE_STATISTIC_DTP // NUMBER OF RELAXED EDGES
+
153 ++dtpRuntimeRow_.NumberOfRelaxedEdges;
+
154#endif
+
155 UpdateQueueWith ( newlabel );
+
156 }
+
157 );
+
158
+
159#ifdef EGOA_ENABLE_STATISTIC_DTP // TOTAL NUMBER OF LABELS
+
160 dtpRuntimeRow_.GlobalElapsedMilliseconds = dtpTime.ElapsedMilliseconds();
+
161 dtpRuntimeRow_.NumberOfLabels = NumberOfLabels();
+
162#endif
+
163
+
164#if !defined(NDEBUG) && defined(EGOA_ENABLE_STATISTIC_DTP)
+
165 // IO::DtpRuntimeRow::Header(std::cout);
+
166 // std::cout << std::endl << dtpRuntimeRow_ << std::endl;
+
167 std::cout << "Number of relaxed edges: " << dtpRuntimeRow_.NumberOfRelaxedEdges << std::endl;
+
168 std::cout << "Number of labels: " << dtpRuntimeRow_.NumberOfLabels << std::endl<< std::endl;
+
169 // ESSENTIAL_ASSERT ( ( 1 + dtpRuntimeRow_.NumberOfRelaxedEdges )
+
170 // == dtpRuntimeRow_.NumberOfLabels );
+
171#endif
+
172 }
+
173 }
+
+
175
+
178#pragma mark ACCESS_INFORMATION
+
179
+
+
191 inline Types::real Result(Subgraph<TGraph const> & resultSubgraph,
+
192 TVertexId const target)
+
193 {
+
194 USAGE_ASSERT( graph_.VertexExists( target ) );
+
195
+
196 std::vector<bool> isVertexInSubgraph(graph_.NumberOfVertices(), false);
+
197 std::vector<bool> isEdgeInSubgraph(graph_.NumberOfEdges(), false);
+
198
+
199 std::vector<TVertexId> vertices;
+
200 std::vector<TEdgeId> edges;
+
201
+
202 Types::real result = \
+
203 labelSets_[target].for_all_optima(
+
204 [ this, &vertices, &edges, &isVertexInSubgraph, &isEdgeInSubgraph ]( TLabel const & optLabel )
+
205 {
+
206 Types::labelId labelId = optLabel.Index();
+
207 TVertexId vertexId = optLabel.Vertex();
+
208
+
209 do
+
210 {
+
211 TLabel const & label = LabelAt( vertexId, labelId );
+
212 labelId = label.Index();
+
213
+
214 ESSENTIAL_ASSERT ( graph_.VertexExists( vertexId ) );
+
215
+
216 if ( !isVertexInSubgraph[vertexId] )
+
217 {
+
218 isVertexInSubgraph[vertexId] = true;
+
219 vertices.push_back(vertexId);
+
220 }
+
221
+
222 if ( label.PreviousVertex() != Const::NONE )
+
223 { // @todo multiple edges? It would be easier if the labels stored edges
+
224 Types::edgeId edge = graph_.EdgeId ( vertexId, label.PreviousVertex() );
+
225 if ( edge == Const::NONE )
+
226 {
+
227 edge = graph_.EdgeId ( label.PreviousVertex(), vertexId );
+
228 ESSENTIAL_ASSERT( edge != Const::NONE );
+
229 }
+
230
+
231 if (!isEdgeInSubgraph[edge])
+
232 {
+
233 isEdgeInSubgraph[edge] = true;
+
234 edges.push_back(edge);
+
235 }
+
236 }
+
237
+
238 vertexId = label.PreviousVertex();
+
239 labelId = label.PreviousLabel();
+
240
+
241 } while ( labelId != Const::NONE
+
242 && vertexId != Const::NONE );
+
243 });
+
244
+
245 resultSubgraph = Subgraph<TGraph const>(&graph_, vertices, edges);
+
246 return result;
+
247 }
+
+
248
+
+
260 inline Types::real Result ( std::vector<std::vector<TVertexId>> & parent
+
261 , TVertexId const target )
+
262 {
+
263 USAGE_ASSERT ( graph_.VertexExists( target ) );
+
264
+
265 // Iterate over all optima
+
266 Types::real result = \
+
267 labelSets_[target].for_all_optima([ this, & parent = parent ]( TLabel const & optLabel )
+
268 {
+
269 // Add a row for another label path from target t
+
270 parent.emplace_back( std::vector<TVertexId>() );
+
271
+
272 // Define function pointer for recursive call
+
273 std::function<void(TLabel const &)> FindPath;
+
274
+
275 // Construct path from the source to the sink
+
276 FindPath = [this, &FindPath, & parent = parent] ( TLabel const & label )
+
277 {
+
278 if ( ( Const::NONE == label.PreviousVertex() ) )
+
279 {
+
280 parent.back().emplace_back ( label.Vertex() );
+
281 } else
+
282 {
+
283 TVertexId vertexId = label.Vertex();
+
284
+
285 FindPath ( LabelAt( label.PreviousVertex(), label.PreviousLabel() ) );
+
286 parent.back().emplace_back ( vertexId );
+
287 }
+
288 };
+
289 FindPath( optLabel );
+
290
+
291 }); // For all labels on the DTP at target vertex
+
292 return result;
+
293 }
+
+
294
+
+
300 inline Types::count NumberOfLabels ()
+
301 {
+
302 Types::count numberOfLabels = 0;
+
303
+
304 for ( TLabelSet const & labelSet : labelSets_ )
+
305 {
+
306 numberOfLabels += labelSet.Size();
+
307 }
+
308 return numberOfLabels;
+
309 }
+
+
311
+
314#pragma mark MODIFIERS
+
315
+
+
321 inline void Source ( TVertexId source )
+
322 {
+
323 USAGE_ASSERT ( source < labelSets_.size() );
+
324 Clear();
+
325#ifdef EGOA_ENABLE_STATISTIC_DTP // SOURCE ID
+
326 dtpRuntimeRow_.SourceId = source;
+
327#endif
+
328 TLabel sourceLabel = TLabel::SourceLabel ( source );
+
329 labelSets_[source].template Merge<Domination>( sourceLabel );
+
330 Insert( sourceLabel );
+
331 }
+
+
332
+
+
336 inline void Clear()
+
337 {
+
338 labelSets_.clear();
+
339 labelSets_.assign( graph_.NumberOfVertices(), TLabelSet() );
+
340
+
341 queue_.Clear();
+
342#ifdef EGOA_ENABLE_STATISTIC_DTP // CLEAR
+
343 dtpRuntimeRow_.Clear();
+
344#endif
+
345 }
+
+
346
+
+
352 inline IO::DtpRuntimeRow & Statistic ()
+
353 {
+
354 return dtpRuntimeRow_;
+
355 }
+
+
356
+
+
362 inline IO::DtpRuntimeRow const & Statistic () const
+
363 {
+
364 return dtpRuntimeRow_;
+
365 }
+
+
367
+
370#pragma mark LABEL_OPERATIONS
+
371
+
+
378 inline void TotalNumberOfPathsThroughVertex ( std::vector<Types::count> & numberOfPathsPerVertex
+
379 , std::vector<Types::real> & relativeNumberOfPathsPerVertex )
+
380 {
+
381 graph_.template for_all_vertex_identifiers<ExecutionPolicy::sequential> ( [ this
+
382 , & numberOfPathsPerVertex
+
383 , & relativeNumberOfPathsPerVertex ] ( TVertexId vertexId )
+
384 {
+
385 NumberOfPathsThroughVertex ( vertexId, numberOfPathsPerVertex, relativeNumberOfPathsPerVertex );
+
386 });
+
387 }
+
+
388
+
+
402 inline void NumberOfPathsThroughVertex ( TVertexId target
+
403 , std::vector<Types::count> & numberOfPathsPerVertex
+
404 , std::vector<Types::real> & relativeNumberOfPathsPerVertex )
+
405 {
+
406 //@todo This is inefficient.
+
407 Types::count numberOfOptimalLabels = LabelSetAt(target).Optima().size(); // Divide by this value
+
408 Types::real weightOfPath = static_cast<Types::real>(1) / numberOfOptimalLabels;
+
409
+
410 numberOfPathsPerVertex.resize( graph_.NumberOfVertices(), 0 );
+
411
+
412 labelSets_[target].for_all_optima (
+
413 [&]( TLabel const & optLabel )
+
414 {
+
415 Types::labelId labelId = optLabel.Index();
+
416 TVertexId vertexId = target;
+
417
+
418 do {
+
419 TLabel & label = LabelAt( vertexId, labelId );
+
420 labelId = label.Index();
+
421
+
422 ESSENTIAL_ASSERT ( graph_.VertexExists( vertexId ) );
+
423
+
424 // Increase number of paths
+
425 ++numberOfPathsPerVertex[vertexId];
+
426 relativeNumberOfPathsPerVertex[vertexId] += weightOfPath;
+
427
+
428 // Extract next label on the DTP
+
429 vertexId = label.PreviousVertex();
+
430 labelId = label.PreviousLabel();
+
431
+
432 } while ( labelId != Const::NONE
+
433 && vertexId != Const::NONE );
+
434 }
+
435 ); // For all labels in DTP at target vertex
+
436 }
+
+
437
+
+
444 inline void TotalNumberOfPathsThroughEdge ( std::vector<Types::count> & numberOfPathsPerEdge
+
445 , std::vector<Types::real> & relativeNumberOfPathsPerEdge )
+
446 {
+
447 graph_.template for_all_vertex_identifiers<ExecutionPolicy::sequential> ( [ this
+
448 , & numberOfPathsPerEdge
+
449 , & relativeNumberOfPathsPerEdge ] ( TVertexId vertexId )
+
450 {
+
451 NumberOfPathsThroughEdge ( vertexId, numberOfPathsPerEdge, relativeNumberOfPathsPerEdge );
+
452 });
+
453 }
+
+
454
+
+
471 inline void NumberOfPathsThroughEdge ( TVertexId target
+
472 , std::vector<Types::count> & numberOfPathsPerEdge
+
473 , std::vector<Types::real> & relativeNumberOfPathsPerEdge )
+
474 {
+
475 //@todo This is inefficient.
+
476 Types::count numberOfOptimalLabels = LabelSetAt(target).Optima().size(); // Divide by this value
+
477 Types::real weightOfPath = static_cast<Types::real>(1) / numberOfOptimalLabels;
+
478
+
479 labelSets_[target].template for_all_optima<ExecutionPolicy::sequential>( [&]( TLabel const & optLabel )
+
480 {
+
481 Types::labelId labelId = optLabel.Index();
+
482 TVertexId vertexId = target;
+
483
+
484 do {
+
485 TLabel & label = LabelAt( vertexId, labelId );
+
486 labelId = label.Index();
+
487
+
488 if ( ( label.PreviousLabel() == Const::NONE )
+
489 || ( label.PreviousVertex() == Const::NONE )
+
490 || ( vertexId == Const::NONE )
+
491 ) break; // Label is already on path
+
492
+
493 // Increase number of paths at "edgeId"
+
494 TEdgeId edgeId = ( graph_.EdgeId( label.PreviousVertex(), vertexId ) != Const::NONE )
+
495 ? graph_.EdgeId( label.PreviousVertex(), vertexId )
+
496 : graph_.EdgeId( vertexId, label.PreviousVertex() );
+
497
+
498 ESSENTIAL_ASSERT ( edgeId != Const::NONE );
+
499
+
500 ++numberOfPathsPerEdge[edgeId];
+
501
+
502 relativeNumberOfPathsPerEdge[edgeId] += weightOfPath;
+
503
+
504 // Extract next label on the DTP
+
505 vertexId = label.PreviousVertex();
+
506 labelId = label.PreviousLabel();
+
507
+
508 } while ( labelId != Const::NONE
+
509 && vertexId != Const::NONE );
+
510 }); // For all labels in DTP at target vertex
+
511 }
+
+
513
+
514 private:
+
517#pragma mark ACCESSORS
+
518
+
+
526 inline TVertexId VertexIdOf ( TLabel const & label ) const
+
527 {
+
528 USAGE_ASSERT ( !label.Empty() );
+
529 return label.Vertex();
+
530 }
+
+
531
+
+
539 inline TLabelSet const & LabelSetAt ( TVertexId const vertexId ) const
+
540 {
+
541 USAGE_ASSERT ( vertexId < labelSets_.size() );
+
542 return labelSets_[vertexId];
+
543 }
+
+
544
+
+
554 inline TLabelSet & LabelSetAt ( TVertexId const vertexId )
+
555 {
+
556 USAGE_ASSERT ( vertexId < labelSets_.size() );
+
557 return labelSets_[vertexId];
+
558 }
+
+
559
+
+
569 inline TLabel & LabelAt ( TVertexId const vertexId
+
570 , Types::labelId const labelId )
+
571 {
+
572 USAGE_ASSERT ( vertexId < labelSets_.size() );
+
573 USAGE_ASSERT ( labelId < Const::NONE );
+
574
+
575 return labelSets_[vertexId].ElementAt ( labelId );
+
576 }
+
+
578
+
581#pragma mark LABEL_SET_AND_QUEUE_OPERATIONS
+
582
+
+
588 inline bool QueueEmpty() const
+
589 {
+
590 return queue_.Empty();
+
591 }
+
+
592
+
+
602 inline void Insert( TLabel const & label )
+
603 {
+
604 queue_.Emplace( label.Vertex(), label );
+
605 }
+
+
606
+
+
618 inline void UpdateQueueWith ( TLabel const & newLabel )
+
619 {
+
620 if ( !queue_.HasKeyOf ( newLabel.Vertex() ) )
+
621 { // There is no label of vertex v in the queue
+
622 Insert ( newLabel );
+
623 } else if ( queue_.KeyOf( newLabel.Vertex() ) > newLabel )
+
624 { // The new label is better than the existing one
+
625 queue_.ChangeKey ( newLabel.Vertex(), newLabel );
+
626 }
+
627 }
+
+
628
+
+
639 inline TLabel QueueDeleteMinimum ()
+
640 {
+
641 USAGE_ASSERT ( !queue_.Empty() );
+
642
+
643 TVertexId vertexId;
+
644 TLabel label;
+
645
+
646 std::tie ( vertexId, label ) = queue_.DeleteTop();
+
647
+
648 ESSENTIAL_ASSERT ( !LabelSetEmptyAt(vertexId) );
+
649 label.Index() = UpdateLabelSetAt ( vertexId );
+
650
+
651 return label;
+
652 }
+
+
653
+
+
662 inline bool LabelSetEmptyAt( TVertexId const vertexId ) const
+
663 {
+
664 USAGE_ASSERT ( vertexId < labelSets_.size() );
+
665 return labelSets_[vertexId].EmptyQueue();
+
666 }
+
+
667
+
+
677 inline bool LabelSetEmptyAt( TLabel const & label ) const
+
678 {
+
679 USAGE_ASSERT ( !label.Empty() );
+
680 return LabelSetEmptyAt( VertexIdOf ( label ) );
+
681 }
+
+
682
+
+
697 inline Types::labelId UpdateLabelSet ( TLabelSet & labelSet )
+
698 {
+
699 USAGE_ASSERT ( !labelSet.Empty() );
+
700
+
701 Types::labelId labelId = labelSet.Pop();
+
702
+
703 if ( ! labelSet.EmptyQueue() ) {
+
704 Insert ( labelSet.Top() );
+
705 }
+
706
+
707 return labelId;
+
708 }
+
+
709
+
+
724 inline Types::labelId UpdateLabelSetAt ( TVertexId vertexId )
+
725 {
+
726 USAGE_ASSERT ( vertexId < labelSets_.size() );
+
727 return UpdateLabelSet ( labelSets_[vertexId] );
+
728 }
+
+
730
+
733#pragma mark LABEL_OPERATIONS
+
734
+
+
742 inline void SetParentOf ( TLabel & label
+
743 , TLabel const & previousLabel )
+
744 {
+
745 label.PreviousVertex() = previousLabel.Vertex();
+
746 label.PreviousLabel() = previousLabel.Index();
+
747 }
+
+
748
+
+
765 inline bool MergeLabelAt( TVertexId vertexId
+
766 , TLabel & label )
+
767 {
+
768 return labelSets_[vertexId].template Merge<Domination>( label );
+
769 }
+
+
770
+
+
785 inline bool ProduceCycle ( TLabel & label
+
786 , std::pair<TLabel, bool> && pair )
+
787 {
+
788 label = std::get<0>(pair);
+
789 return !( std::get<1>(pair) );
+
790 }
+
+
792
+
793#pragma mark MEMBERS
+
794 private:
+
795 TGraph const & graph_;
+
796 std::vector<TLabelSet> labelSets_;
+
797 TQueue queue_;
+
799 IO::DtpRuntimeRow dtpRuntimeRow_;
+
800};
+
+
801
+
802} // egoa
+
803
+
804#endif // EGOA__ALGORITHMS__PATH_FINDING__DOMINATING_THETA_PATH_HPP
+ +
egoa::DominatingThetaPath
Class for dominating theta path.
Definition DominatingThetaPath.hpp:58
+ + +
egoa::DominatingThetaPath::TVertex
typename GraphType::TVertex TVertex
Definition DominatingThetaPath.hpp:63
+
egoa::DominatingThetaPath::TEdgeId
typename GraphType::TEdgeId TEdgeId
Definition DominatingThetaPath.hpp:66
+
egoa::DominatingThetaPath::LabelSetEmptyAt
bool LabelSetEmptyAt(TVertexId const vertexId) const
Check if a label set is empty at vertex .
Definition DominatingThetaPath.hpp:662
+
egoa::DominatingThetaPath::LabelSetAt
TLabelSet const & LabelSetAt(TVertexId const vertexId) const
Getter for the set of labels of a vertex .
Definition DominatingThetaPath.hpp:539
+
egoa::DominatingThetaPath::NumberOfPathsThroughEdge
void NumberOfPathsThroughEdge(TVertexId target, std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)
Number of paths through an edge.
Definition DominatingThetaPath.hpp:471
+
egoa::DominatingThetaPath::Source
void Source(TVertexId source)
Set the source.
Definition DominatingThetaPath.hpp:321
+
egoa::DominatingThetaPath::LabelAt
TLabel & LabelAt(TVertexId const vertexId, Types::labelId const labelId)
The label at a vertex with vertexId and the label's identifier labelId.
Definition DominatingThetaPath.hpp:569
+
egoa::DominatingThetaPath::UpdateLabelSet
Types::labelId UpdateLabelSet(TLabelSet &labelSet)
Update a label set at a vertex .
Definition DominatingThetaPath.hpp:697
+
egoa::DominatingThetaPath::Statistic
IO::DtpRuntimeRow const & Statistic() const
Getter for the statistic.
Definition DominatingThetaPath.hpp:362
+ +
egoa::DominatingThetaPath::TVertexId
typename GraphType::TVertexId TVertexId
Definition DominatingThetaPath.hpp:64
+
egoa::DominatingThetaPath::SetParentOf
void SetParentOf(TLabel &label, TLabel const &previousLabel)
Sets the parent of label to previousLabel .
Definition DominatingThetaPath.hpp:742
+
egoa::DominatingThetaPath::NumberOfLabels
Types::count NumberOfLabels()
Current number of labels.
Definition DominatingThetaPath.hpp:300
+
egoa::DominatingThetaPath::LabelSetEmptyAt
bool LabelSetEmptyAt(TLabel const &label) const
Check if a label set is empty at vertex .
Definition DominatingThetaPath.hpp:677
+
egoa::DominatingThetaPath::labelSets_
std::vector< TLabelSet > labelSets_
Definition DominatingThetaPath.hpp:796
+ +
egoa::DominatingThetaPath::Result
Types::real Result(Subgraph< TGraph const > &resultSubgraph, TVertexId const target)
Extracts the subgraph formed by the DTPs from the source to the given target.
Definition DominatingThetaPath.hpp:191
+
egoa::DominatingThetaPath::Run
void Run()
Run the DTP algorithm.
Definition DominatingThetaPath.hpp:114
+
egoa::DominatingThetaPath::MergeLabelAt
bool MergeLabelAt(TVertexId vertexId, TLabel &label)
Merge label with the set of labels. at vertex .
Definition DominatingThetaPath.hpp:765
+
egoa::DominatingThetaPath::TotalNumberOfPathsThroughEdge
void TotalNumberOfPathsThroughEdge(std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)
Total number of paths through an edge.
Definition DominatingThetaPath.hpp:444
+ +
egoa::DominatingThetaPath::VertexIdOf
TVertexId VertexIdOf(TLabel const &label) const
Access vertex identifier of a label.
Definition DominatingThetaPath.hpp:526
+
egoa::DominatingThetaPath::Clear
void Clear()
Clear all data structures.
Definition DominatingThetaPath.hpp:336
+
egoa::DominatingThetaPath::Result
Types::real Result(std::vector< std::vector< TVertexId > > &parent, TVertexId const target)
Extract result graph and value.
Definition DominatingThetaPath.hpp:260
+
egoa::DominatingThetaPath::Statistic
IO::DtpRuntimeRow & Statistic()
Setter for the statistic.
Definition DominatingThetaPath.hpp:352
+ +
egoa::DominatingThetaPath::QueueEmpty
bool QueueEmpty() const
Check if the main queue is empty.
Definition DominatingThetaPath.hpp:588
+ +
egoa::DominatingThetaPath::TotalNumberOfPathsThroughVertex
void TotalNumberOfPathsThroughVertex(std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)
Total number of paths through a vertex.
Definition DominatingThetaPath.hpp:378
+
egoa::DominatingThetaPath::NumberOfPathsThroughVertex
void NumberOfPathsThroughVertex(TVertexId target, std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)
Number of paths at each vertex.
Definition DominatingThetaPath.hpp:402
+
egoa::DominatingThetaPath::ProduceCycle
bool ProduceCycle(TLabel &label, std::pair< TLabel, bool > &&pair)
Check if the new label produces a cycle.
Definition DominatingThetaPath.hpp:785
+
egoa::DominatingThetaPath::Insert
void Insert(TLabel const &label)
Adds a label to the main queue.
Definition DominatingThetaPath.hpp:602
+
egoa::DominatingThetaPath::QueueDeleteMinimum
TLabel QueueDeleteMinimum()
Delete the minimum key from the queue .
Definition DominatingThetaPath.hpp:639
+
egoa::DominatingThetaPath::UpdateQueueWith
void UpdateQueueWith(TLabel const &newLabel)
Update queue with new label .
Definition DominatingThetaPath.hpp:618
+
egoa::DominatingThetaPath::LabelSetAt
TLabelSet & LabelSetAt(TVertexId const vertexId)
Setter for the set of labels of a vertex .
Definition DominatingThetaPath.hpp:554
+
egoa::DominatingThetaPath::TEdge
typename GraphType::TEdge TEdge
Definition DominatingThetaPath.hpp:65
+
egoa::DominatingThetaPath::DominatingThetaPath
DominatingThetaPath(TGraph const &graph)
Constructs the object.
Definition DominatingThetaPath.hpp:82
+
egoa::DominatingThetaPath::UpdateLabelSetAt
Types::labelId UpdateLabelSetAt(TVertexId vertexId)
Update a label set at a vertex.
Definition DominatingThetaPath.hpp:724
+
egoa::DominatingThetaPath::DominatingThetaPath
DominatingThetaPath(TGraph const &graph, TVertexId source)
Constructs the object.
Definition DominatingThetaPath.hpp:98
+
egoa::IO::DtpRuntimeRow
Statistics about one execution of the DTP algorithm.
Definition DtpRuntimeRow.hpp:25
+ +
egoa::IO::DtpRuntimeRow::NumberOfRelaxedEdges
Types::count NumberOfRelaxedEdges
Definition DtpRuntimeRow.hpp:38
+
egoa::IO::DtpRuntimeRow::NumberOfEdgesProducingNoCycle
Types::count NumberOfEdgesProducingNoCycle
Definition DtpRuntimeRow.hpp:37
+
egoa::IO::DtpRuntimeRow::GlobalElapsedMilliseconds
Types::real GlobalElapsedMilliseconds
Definition DtpRuntimeRow.hpp:42
+ + +
egoa::IO::DtpRuntimeRow::NumberOfScannedEdges
Types::count NumberOfScannedEdges
Definition DtpRuntimeRow.hpp:39
+ + + +
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_domination_criterion_8hpp_source.html b/_domination_criterion_8hpp_source.html new file mode 100644 index 00000000..dc8a4cb5 --- /dev/null +++ b/_domination_criterion_8hpp_source.html @@ -0,0 +1,174 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/DominationCriterion.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DominationCriterion.hpp
+
+
+
1/*
+
2 * DominationCriterion.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__DOMINATION_CRITERION_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__DOMINATION_CRITERION_HPP
+
10
+
11namespace egoa {
+
12
+
+
24enum class DominationCriterion {
+
25 weak = 0
+
26 , strict = 1
+
27 , none = 2
+
28};
+
+
29
+
30namespace internal {
+
31
+
53template<typename ElementType, DominationCriterion Domination>
+
54class DominationDifferentiation;
+
55
+
56#pragma mark WEAK_DOMINATION
+
57template<typename ElementType>
+
+
58class DominationDifferentiation<ElementType, DominationCriterion::weak> {
+
59 // Type aliasing
+
60 using TElement = ElementType;
+
61
+
62 public:
+
63 static inline bool Dominates ( TElement const & lhs
+
64 , TElement const & rhs
+
65 , std::function<bool(TElement, TElement)> const & comparator )
+
66 {
+
67 return comparator(lhs, rhs) || (lhs == rhs);
+
68 }
+
69};
+
+
70
+
71#pragma mark STRICT_DOMINATION
+
72template<typename ElementType>
+
+
73class DominationDifferentiation<ElementType, DominationCriterion::strict> {
+
74 // Type aliasing
+
75 using TElement = ElementType;
+
76
+
77 public:
+
78 static inline bool Dominates ( TElement const & lhs
+
79 , TElement const & rhs
+
80 , std::function<bool(TElement, TElement)> const & comparator )
+
81 {
+
82 return comparator(lhs, rhs);
+
83 }
+
84};
+
+
85
+
86#pragma mark NO_DOMINATION
+
87template<typename ElementType>
+
+
88class DominationDifferentiation<ElementType, DominationCriterion::none> {
+
89 // Type aliasing
+
90 using TElement = ElementType;
+
91
+
92 public:
+
93 static inline bool Dominates ( TElement const & lhs
+
94 , TElement const & rhs
+
95 , std::function<bool(TElement, TElement)> const & comparator )
+
96 {
+
97 return false;
+
98 }
+
99};
+
+
100
+
101} // namespace internal
+
102
+
103} // namespace egoa
+
104
+
105#endif // EGOA__DATA_STRUCTURES__CONTAINER__DOMINATION_CRITERION_HPP
+
egoa::internal::DominationDifferentiation
Class for domination differentiation.
Definition DominationCriterion.hpp:54
+
egoa
Definition Color.cpp:15
+
egoa::DominationCriterion
DominationCriterion
Domination criterion.
Definition DominationCriterion.hpp:24
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_dtp_runtime_collection_8hpp_source.html b/_dtp_runtime_collection_8hpp_source.html new file mode 100644 index 00000000..bae5e6e0 --- /dev/null +++ b/_dtp_runtime_collection_8hpp_source.html @@ -0,0 +1,182 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Statistics/DtpRuntimeCollection.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DtpRuntimeCollection.hpp
+
+
+
1/*
+
2 * DtpRuntimeCollection.hpp
+
3 *
+
4 * Created on: Feb 26, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__IO__STATISTICS__DTP_RUNTIME_COLLECTION_HPP
+
9#define EGOA__IO__STATISTICS__DTP_RUNTIME_COLLECTION_HPP
+
10
+
11#include <fstream>
+
12#include <iostream>
+
13#include <vector>
+
14
+
15#include "IO/Statistics/DtpRuntimeRow.hpp"
+
16
+
17namespace egoa::IO {
+
18
+
+
23class DtpRuntimeCollection {
+
24 public:
+
25 using TRow = DtpRuntimeRow;
+
26 public:
+
29
+
+
36 inline DtpRuntimeCollection & operator+=( TRow const & rhs )
+
37 {
+
38 collection_.emplace_back ( rhs );
+
39 return *this;
+
40 }
+
+
41
+
+
45 inline void Clear ()
+
46 {
+
47 collection_.clear();
+
48 }
+
+
50
+
53 inline std::vector<TRow> const & Collection () const
+
54 {
+
55 return collection_;
+
56 }
+
58
+
61 friend std::ostream & operator<<( std::ostream & os, DtpRuntimeCollection const & collection )
+
62 {
+
63 for ( const auto & row : collection.collection_ )
+
64 {
+
65 row.Content(os);
+
66 }
+
67 return os;
+
68 }
+
69
+
+
82 inline void WriteCollectionToFileWith ( Types::string const filename
+
83 , bool overwrite = true )
+
84 {
+
85#ifndef NDEBUG
+
86 std::cout << "Write DTP runtime information row to: " << filename << std::endl;
+
87#endif
+
88 // Open output stream.
+
89 std::ofstream fileStream;
+
90 fileStream.open( filename, overwrite ? std::ofstream::trunc : std::ofstream::app );
+
91 if ( !fileStream.is_open() ) return;
+
92
+
93 // Check if the file is empty
+
94 fileStream.seekp(0, std::ios::end);
+
95 if ( fileStream.tellp() == 0 )
+
96 {
+
97 TRow::Header ( fileStream );
+
98 }
+
99
+
100 for ( const auto & row : collection_ )
+
101 {
+
102 row.Content(fileStream);
+
103 }
+
104 }
+
+
106
+
107 private:
+
108 std::vector<TRow> collection_;
+
109};
+
+
110
+
111} // namespace egoa::IO
+
112
+
113#endif // EGOA__IO__STATISTICS__DTP_RUNTIME_COLLECTION_HPP
+
egoa::IO::DtpRuntimeCollection
A collections of DtpRuntimeRow objects for multiple runs of the DTP-algorithm.
Definition DtpRuntimeCollection.hpp:23
+
egoa::IO::DtpRuntimeCollection::Clear
void Clear()
Clears the content of the collection.
Definition DtpRuntimeCollection.hpp:45
+
egoa::IO::DtpRuntimeCollection::operator+=
DtpRuntimeCollection & operator+=(TRow const &rhs)
Adds a DtpRuntimeRow to the collection.
Definition DtpRuntimeCollection.hpp:36
+
egoa::IO::DtpRuntimeCollection::WriteCollectionToFileWith
void WriteCollectionToFileWith(Types::string const filename, bool overwrite=true)
Writes the data in the collection to a file.
Definition DtpRuntimeCollection.hpp:82
+
egoa::IO::DtpRuntimeRow
Statistics about one execution of the DTP algorithm.
Definition DtpRuntimeRow.hpp:25
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_dtp_runtime_row_8hpp_source.html b/_dtp_runtime_row_8hpp_source.html new file mode 100644 index 00000000..0753b92d --- /dev/null +++ b/_dtp_runtime_row_8hpp_source.html @@ -0,0 +1,265 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Statistics/DtpRuntimeRow.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DtpRuntimeRow.hpp
+
+
+
1/*
+
2 * DtpRuntimeRow.hpp
+
3 *
+
4 * Created on: Feb 03, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__STATISTICS__DTP_RUNTIME_ROW_HPP
+
9#define EGOA__IO__STATISTICS__DTP_RUNTIME_ROW_HPP
+
10
+
11#include <fstream>
+
12#include <iostream>
+
13#include <vector>
+
14
+
15#include "Auxiliary/Constants.hpp"
+
16#include "Auxiliary/Types.hpp"
+
17
+
18namespace egoa::IO {
+
19
+
+
25class DtpRuntimeRow {
+
26 public:
+
27 Types::string NameOfProblem;
+
28 Types::name Name;
+
30 Types::vertexId SourceId;
+
32 Types::count NumberOfVertices;
+
33 Types::count NumberOfGenerators;
+
34 Types::count NumberOfLoads;
+
35 Types::count NumberOfEdges;
+
37 Types::count NumberOfEdgesProducingNoCycle;
+
38 Types::count NumberOfRelaxedEdges;
+
39 Types::count NumberOfScannedEdges;
+
40 Types::count NumberOfLabels;
+
42 Types::real GlobalElapsedMilliseconds;
+
44 DtpRuntimeRow() :
+
45 NameOfProblem("DTP")
+
46 , Name("")
+
47
+
48 , SourceId(0)
+
49
+
50 , NumberOfVertices(0)
+
51 , NumberOfGenerators(0)
+
52 , NumberOfLoads(0)
+
53 , NumberOfEdges(0)
+
54
+
55 , NumberOfEdgesProducingNoCycle(0)
+
56 , NumberOfRelaxedEdges(0)
+
57 , NumberOfScannedEdges(0)
+
58 , NumberOfLabels(0)
+
59
+
60 , GlobalElapsedMilliseconds(0.0)
+
61 {}
+
62
+
63 inline void Clear () {
+
64 NameOfProblem = "DTP";
+
65 Name = "";
+
66 SourceId = 0;
+
67 NumberOfVertices = 0;
+
68 NumberOfGenerators = 0;
+
69 NumberOfLoads = 0;
+
70 NumberOfEdges = 0;
+
71 NumberOfScannedEdges = 0;
+
72 NumberOfEdgesProducingNoCycle = 0;
+
73 NumberOfRelaxedEdges = 0;
+
74 GlobalElapsedMilliseconds = 0;
+
75 NumberOfLabels = 0;
+
76 }
+
77
+
78 inline static void Header ( std::ostream & os )
+
79 {
+
80 os
+
81 << "NameOfProblem" << ",\t"
+
82 << "Name" << ",\t"
+
83
+
84 << "SourceId" << ",\t"
+
85
+
86 << "NumberOfVertices" << ",\t"
+
87 << "NumberOfGenerators" << ",\t"
+
88 << "NumberOfLoads" << ",\t"
+
89 << "NumberOfEdges" << ",\t"
+
90
+
91 << "NumberOfScannedEdges" << ",\t"
+
92 << "NumberOfEdgesProducingNoCycle"<< ",\t"
+
93 << "NumberOfRelaxedEdges" << ",\t"
+
94
+
95 << "NumberOfLabels" << ",\t"
+
96
+
97 << "GlobalElapsedMilliseconds" << ",\t"
+
98
+
99 << "\n";
+
100 }
+
101
+
102 inline void Content ( std::ostream & os ) const
+
103 {
+
104 os
+
105 << NameOfProblem << ",\t"
+
106 << Name << ",\t"
+
107
+
108 << SourceId << ",\t"
+
109
+
110 << NumberOfVertices << ",\t"
+
111 << NumberOfGenerators << ",\t"
+
112 << NumberOfLoads << ",\t"
+
113 << NumberOfEdges << ",\t"
+
114
+
115 << NumberOfScannedEdges << ",\t"
+
116 << NumberOfEdgesProducingNoCycle<< ",\t"
+
117 << NumberOfRelaxedEdges << ",\t"
+
118
+
119 << NumberOfLabels << ",\t"
+
120
+
121 << GlobalElapsedMilliseconds
+
122
+
123 << "\n";
+
124 }
+
125
+
126 inline DtpRuntimeRow & operator+= ( const DtpRuntimeRow & rhs )
+
127 {
+
128 NumberOfEdgesProducingNoCycle += rhs.NumberOfEdgesProducingNoCycle;
+
129 NumberOfRelaxedEdges += rhs.NumberOfRelaxedEdges;
+
130 NumberOfScannedEdges += rhs.NumberOfScannedEdges;
+
131 NumberOfLabels += rhs.NumberOfLabels;
+
132
+
133 GlobalElapsedMilliseconds += rhs.GlobalElapsedMilliseconds;
+
134
+
135 return *this;
+
136 }
+
137
+
138 friend std::ostream & operator<< ( std::ostream & os
+
139 , DtpRuntimeRow & dtpRuntimeRow )
+
140 {
+
141 dtpRuntimeRow.Content ( os );
+
142 return os;
+
143 }
+
144
+
145 inline void WriteRowToFileWith ( Types::string const filename
+
146 , bool overwrite = false )
+
147 {
+
148#ifndef NDEBUG
+
149 std::cout << "Write DTP runtime information row to: " << filename << std::endl;
+
150#endif
+
151 // Open output stream.
+
152 // ofstream fileStream(filename);
+
153 std::ofstream fileStream;
+
154 overwrite?fileStream.open(filename, std::ofstream::trunc):fileStream.open(filename, std::ofstream::app);
+
155 if (!fileStream.is_open()) return;
+
156
+
157 // file is empty
+
158 fileStream.seekp(0, std::ios::end);
+
159 if ( fileStream.tellp() == 0 )
+
160 {
+
161 DtpRuntimeRow::Header(fileStream);
+
162 }
+
163
+
164 fileStream << *this;
+
165 }
+
166};
+
+
167
+
168} // namespace egoa::IO
+
169
+
170#endif // EGOA__IO__STATISTICS__DTP_RUNTIME_ROW_HPP
+
egoa::IO::DtpRuntimeRow
Statistics about one execution of the DTP algorithm.
Definition DtpRuntimeRow.hpp:25
+
egoa::IO::DtpRuntimeRow::NumberOfGenerators
Types::count NumberOfGenerators
Definition DtpRuntimeRow.hpp:33
+ +
egoa::IO::DtpRuntimeRow::NumberOfRelaxedEdges
Types::count NumberOfRelaxedEdges
Definition DtpRuntimeRow.hpp:38
+
egoa::IO::DtpRuntimeRow::NumberOfEdgesProducingNoCycle
Types::count NumberOfEdgesProducingNoCycle
Definition DtpRuntimeRow.hpp:37
+
egoa::IO::DtpRuntimeRow::GlobalElapsedMilliseconds
Types::real GlobalElapsedMilliseconds
Definition DtpRuntimeRow.hpp:42
+ + + +
egoa::IO::DtpRuntimeRow::NumberOfScannedEdges
Types::count NumberOfScannedEdges
Definition DtpRuntimeRow.hpp:39
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_dynamic_graph_8hpp_source.html b/_dynamic_graph_8hpp_source.html new file mode 100644 index 00000000..6174505f --- /dev/null +++ b/_dynamic_graph_8hpp_source.html @@ -0,0 +1,1256 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/DynamicGraph.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DynamicGraph.hpp
+
+
+
1/*
+
2 * DynamicGraph.hpp
+
3 *
+
4 * Created on: Nov 04, 2018
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__DYNAMIC_GRAPH_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__DYNAMIC_GRAPH_HPP
+
10
+
11#include <algorithm>
+
12#include <type_traits>
+
13
+
14#include "Auxiliary/Constants.hpp"
+
15#include "Auxiliary/Types.hpp"
+
16
+
17#include "DataStructures/Iterators/DynamicGraphIterators.hpp"
+
18
+
19#include "Exceptions/Assertions.hpp"
+
20
+
21#include "DataStructures/Graphs/Edges/Edge.hpp"
+
22#include "DataStructures/Graphs/Vertices/Vertex.hpp"
+
23#include "DataStructures/Iterators/OmittingIterator.hpp"
+
24
+
25namespace egoa {
+
26
+
49template <typename VertexProperties, typename EdgeProperties>
+
+
50class DynamicGraph {
+
51 template<typename ElementType, bool Const> class OmittingVectorView;
+
52public:
+
53
+
54 // Template type aliasing
+
55 using TGraph = DynamicGraph<VertexProperties, EdgeProperties>;
+
56 // Vertices
+
57 using TVertexProperties = VertexProperties;
+
58 using TVertex = Vertices::Vertex<TVertexProperties>;
+
59 using TVertexId = Types::vertexId;
+
60 // Edges
+
61 using TEdgeProperties = EdgeProperties;
+
62 using TEdge = Edges::Edge<TEdgeProperties>;
+
63 using TEdgeId = Types::edgeId;
+
64 //
+
65 using TVerticesView = OmittingVectorView<TVertex, false>;
+
66 using TConstVerticesView = OmittingVectorView<TVertex, true>;
+
67 using TEdgesView = OmittingVectorView<TEdge, false>;
+
68 using TConstEdgesView = OmittingVectorView<TEdge, true>;
+
69
+
+
75 explicit DynamicGraph(Types::name name = "")
+
76 : name_(std::move(name))
+
77 {}
+
+
78
+
81#pragma mark SETTER_AND_GETTER
+
85 inline Types::name Name() const { return name_; }
+
89 inline Types::count NumberOfVertices() const { return numberOfVertices_; }
+
93 inline Types::count NumberOfEdges() const { return numberOfEdges_; }
+
95
+
98#pragma mark VERTEX_RELATED_METHODS
+
+
109 inline TVerticesView Vertices()
+
110 {
+
111 return TVerticesView ( & vertices_
+
112 , & vertexExists_
+
113 , & numberOfVertices_ );
+
114 }
+
+
115
+
+
126 inline TConstVerticesView Vertices() const
+
127 {
+
128 return TConstVerticesView ( & vertices_
+
129 , & vertexExists_
+
130 , & numberOfVertices_ );
+
131 }
+
+
132
+
+
141 inline bool VertexExists ( Types::vertexId id ) const
+
142 {
+
143 return id < vertexExists_.size() && vertexExists_[id];
+
144 }
+
+
145
+
+
155 inline TVertex & VertexAt ( Types::vertexId id )
+
156 {
+
157 USAGE_ASSERT ( VertexExists(id) );
+
158 return vertices_[id];
+
159 }
+
+
160
+
+
170 inline TVertex const & VertexAt ( Types::vertexId id ) const
+
171 {
+
172 USAGE_ASSERT ( VertexExists(id) );
+
173 return vertices_[id];
+
174 }
+
+
175
+
176 // Avoid implicit conversions on non-constructing functions
+
177 inline TVertex & VertexAt ( int id ) = delete;
+
178 inline TVertex & VertexAt ( char id ) = delete;
+
179 inline const TVertex & VertexAt ( int id ) const = delete;
+
180 inline const TVertex & VertexAt ( char id ) const = delete;
+
181
+
+
190 inline Types::vertexId VertexId ( TVertex const & vertex ) const
+
191 {
+
192 return vertex.Identifier();
+
193 }
+
+
194
+
+
204 inline Types::vertexId AddVertex ( TVertexProperties & properties )
+
205 {
+
206 return AddVertex ( TVertexProperties(properties) );
+
207 }
+
+
208
+
+
216 inline Types::vertexId AddVertex ( TVertexProperties const & properties )
+
217 {
+
218 return AddVertex ( TVertexProperties(properties) );
+
219 }
+
+
220
+
+
228 inline Types::vertexId AddVertex ( TVertexProperties && properties )
+
229 {
+
230 // TODO: Find a free place in the vector if it exists.
+
231 auto id = vertices_.size();
+
232
+
233 vertices_.emplace_back(id, std::move(properties));
+
234
+
235 vertexExists_.push_back(true);
+
236 ++numberOfVertices_;
+
237
+
238 inEdgeIds_.emplace_back();
+
239 outEdgeIds_.emplace_back();
+
240
+
241 return id;
+
242 }
+
+
243
+
244 // TODO: maybe write EmplaceVertex?
+
245
+
+
253 inline void RemoveVertexAt ( Types::vertexId id )
+
254 {
+
255 USAGE_ASSERT ( VertexExists(id) );
+
256
+
257 RemoveAllIncidentEdgesAt(id);
+
258
+
259 vertexExists_[id] = false;
+
260 --numberOfVertices_;
+
261 }
+
+
262
+
276 template<typename FUNCTION>
+
+
277 inline auto MapVertices ( FUNCTION function ) const
+
278 -> std::vector<decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()))>
+
279 {
+
280 using TResult = decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()));
+
281 std::vector<TResult> result;
+
282
+
283 for_all_vertex_tuples<ExecutionPolicy::sequential>(
+
284 [&]( Types::vertexId id, TVertex const & vertex )
+
285 {
+
286 result.push_back ( function(id, vertex) );
+
287 }
+
288 );
+
289
+
290 return result;
+
291 }
+
+
292
+
+
305 inline std::vector<Types::vertexId> NeighborsOf ( Types::vertexId id ) const
+
306 {
+
307 USAGE_ASSERT ( VertexExists(id) );
+
308
+
309 std::vector<Types::vertexId> result;
+
310 NeighborsOf(id, result);
+
311 return result;
+
312 }
+
+
313
+
+
327 inline void NeighborsOf ( Types::vertexId id
+
328 , std::vector<Types::vertexId> & vertexIds ) const
+
329 {
+
330 USAGE_ASSERT ( VertexExists(id) );
+
331
+
332 std::vector<bool> vertexVisited(vertices_.size(), false);
+
333
+
334 for (Types::edgeId edgeId : OutEdgeIdsAt(id)) {
+
335 Types::vertexId otherVertex = EdgeAt(edgeId).Target();
+
336 if (!vertexVisited[otherVertex]) {
+
337 vertexIds.push_back(otherVertex);
+
338 vertexVisited[otherVertex] = true;
+
339 }
+
340 }
+
341 for (Types::edgeId edgeId : InEdgeIdsAt(id)) {
+
342 Types::vertexId otherVertex = EdgeAt(edgeId).Source();
+
343 if (!vertexVisited[otherVertex]) {
+
344 vertexIds.push_back(otherVertex);
+
345 vertexVisited[otherVertex] = true;
+
346 }
+
347 }
+
348 }
+
+
349
+
+
359 inline Types::count InDegreeAt ( Types::vertexId id ) const
+
360 {
+
361 USAGE_ASSERT ( VertexExists(id) );
+
362 return InEdgeIdsAt(id).size();
+
363 }
+
+
364
+
+
374 inline Types::count OutDegreeAt ( Types::vertexId id ) const
+
375 {
+
376 USAGE_ASSERT ( VertexExists(id) );
+
377 return OutEdgeIdsAt(id).size();
+
378 }
+
+
379
+
+
389 inline Types::count DegreeAt ( Types::vertexId id ) const
+
390 {
+
391 USAGE_ASSERT ( VertexExists(id) );
+
392 return InDegreeAt(id) + OutDegreeAt(id);
+
393 }
+
+
394
+
+
404 inline std::vector<Types::edgeId> const & InEdgeIdsAt ( Types::vertexId id ) const
+
405 {
+
406 USAGE_ASSERT ( VertexExists(id) );
+
407 return inEdgeIds_[id];
+
408 }
+
+
409
+
+
419 inline std::vector<Types::edgeId> const & OutEdgeIdsAt ( Types::vertexId id ) const
+
420 {
+
421 USAGE_ASSERT ( VertexExists(id) );
+
422 return outEdgeIds_[id];
+
423 }
+
+
424
+
+
435 inline std::vector<Types::edgeId> EdgeIdsAt ( Types::vertexId id ) const
+
436 {
+
437 USAGE_ASSERT ( VertexExists(id) );
+
438
+
439 std::vector<Types::edgeId> edgeIds;
+
440 EdgeIdsAt(id, edgeIds);
+
441 return edgeIds;
+
442 }
+
+
443
+
+
454 inline void EdgeIdsAt ( Types::vertexId id
+
455 , std::vector<Types::edgeId> & edgeIds ) const
+
456 {
+
457 USAGE_ASSERT ( VertexExists(id) );
+
458
+
459 auto & inIds = InEdgeIdsAt(id);
+
460 auto & outIds = OutEdgeIdsAt(id);
+
461 edgeIds.insert( edgeIds.end(), inIds.begin(), inIds.end() );
+
462 edgeIds.insert( edgeIds.end(), outIds.begin(), outIds.end() );
+
463 }
+
+
464
+
466
+
469#pragma mark EDGE_RELATED_METHODS
+
470
+
+
481 inline TEdgesView Edges()
+
482 {
+
483 return TEdgesView ( & edges_
+
484 , & edgeExists_
+
485 , & numberOfEdges_ );
+
486 }
+
+
487
+
+
498 inline TConstEdgesView Edges() const
+
499 {
+
500 return TConstEdgesView ( & edges_
+
501 , & edgeExists_
+
502 , & numberOfEdges_ );
+
503 }
+
+
504
+
+
514 inline bool EdgeExists ( Types::edgeId id ) const
+
515 {
+
516 return id < edgeExists_.size() && edgeExists_[id];
+
517 }
+
+
518
+
+
528 inline TEdge & EdgeAt ( Types::edgeId id )
+
529 {
+
530 USAGE_ASSERT ( EdgeExists(id) );
+
531 return edges_[id];
+
532 }
+
+
533
+
+
543 inline TEdge const & EdgeAt ( Types::edgeId id ) const
+
544 {
+
545 USAGE_ASSERT ( EdgeExists(id) );
+
546 return edges_[id];
+
547 }
+
+
548
+
+
564 inline Types::edgeId EdgeId ( Types::vertexId source
+
565 , Types::vertexId target ) const
+
566 {
+
567 USAGE_ASSERT ( VertexExists(source) );
+
568 USAGE_ASSERT ( VertexExists(target) );
+
569
+
570 if ( OutDegreeAt(source) <= InDegreeAt(target) )
+
571 {
+
572 for ( Types::edgeId id : outEdgeIds_[source] )
+
573 {
+
574 if ( EdgeAt(id).Target() == target )
+
575 return id;
+
576 }
+
577 } else {
+
578 for (Types::edgeId id : inEdgeIds_[target])
+
579 {
+
580 if ( EdgeAt(id).Source() == source )
+
581 return id;
+
582 }
+
583 }
+
584
+
585 return Const::NONE;
+
586 }
+
+
587
+
+
602 inline TEdge & Edge ( Types::vertexId source
+
603 , Types::vertexId target )
+
604 {
+
605 USAGE_ASSERT ( VertexExists(source) );
+
606 USAGE_ASSERT ( VertexExists(target) );
+
607 Types::edgeId id = EdgeId( source, target );
+
608 USAGE_ASSERT ( id != Const::NONE );
+
609
+
610 return EdgeAt( id );
+
611 }
+
+
612
+
+
627 inline const TEdge & Edge ( Types::vertexId source
+
628 , Types::vertexId target ) const
+
629 {
+
630 USAGE_ASSERT ( VertexExists(source) );
+
631 USAGE_ASSERT ( VertexExists(target) );
+
632 Types::edgeId id = EdgeId( source, target );
+
633 USAGE_ASSERT ( id != Const::NONE );
+
634
+
635 return EdgeAt( id );
+
636 }
+
+
637
+
+
649 inline Types::edgeId AddEdge ( Types::vertexId source
+
650 , Types::vertexId target
+
651 , TEdgeProperties & properties )
+
652 {
+
653 USAGE_ASSERT( VertexExists( source ) );
+
654 USAGE_ASSERT( VertexExists( target ) );
+
655 return AddEdge ( source, target, TEdgeProperties(properties) );
+
656 }
+
+
657
+
+
669 inline Types::edgeId AddEdge ( Types::vertexId source
+
670 , Types::vertexId target
+
671 , TEdgeProperties const & properties )
+
672 {
+
673 USAGE_ASSERT( VertexExists(source) );
+
674 USAGE_ASSERT( VertexExists(target) );
+
675 return AddEdge( source, target, TEdgeProperties(properties) );
+
676 }
+
+
677
+
+
689 inline Types::edgeId AddEdge ( Types::vertexId source
+
690 , Types::vertexId target
+
691 , TEdgeProperties && properties )
+
692 {
+
693 USAGE_ASSERT ( VertexExists(source) );
+
694 USAGE_ASSERT ( VertexExists(target) );
+
695
+
696 // TODO: Find empty slot instead of always adding to the end?
+
697 Types::edgeId edgeId = edges_.size();
+
698 edges_.emplace_back(edgeId, source, target, std::move(properties));
+
699
+
700 edgeExists_.emplace_back(true);
+
701 ++numberOfEdges_;
+
702
+
703 ESSENTIAL_ASSERT ( edgeExists_.size() == edges_.size() );
+
704 ESSENTIAL_ASSERT ( numberOfEdges_ <= edges_.size() );
+
705
+
706 ESSENTIAL_ASSERT ( source < outEdgeIds_.size() );
+
707 ESSENTIAL_ASSERT ( target < inEdgeIds_.size() );
+
708
+
709 outEdgeIds_[source].push_back(edgeId);
+
710 inEdgeIds_[target].push_back(edgeId);
+
711
+
712 return edgeId;
+
713 }
+
+
714
+
+
722 inline void RemoveEdgeAt ( Types::edgeId id )
+
723 {
+
724 USAGE_ASSERT( EdgeExists(id) );
+
725 // remove edge
+
726 Types::vertexId source = EdgeAt(id).Source();
+
727 Types::vertexId target = EdgeAt(id).Target();
+
728
+
729 //edges_.erase( edges_.begin() + id );
+
730 edgeExists_[id] = false;
+
731 --numberOfEdges_;
+
732
+
733 //in/out edges
+
734 auto iteratorIn = std::find( inEdgeIds_[target].begin(), inEdgeIds_[target].end(), id );
+
735 auto iteratorOut = std::find( outEdgeIds_[source].begin(), outEdgeIds_[source].end(), id );
+
736 inEdgeIds_[target].erase( iteratorIn );
+
737 outEdgeIds_[source].erase( iteratorOut );
+
738 }
+
+
739
+
+
747 inline void RemoveAllIncidentEdgesAt ( Types::vertexId id )
+
748 {
+
749 USAGE_ASSERT ( VertexExists(id) );
+
750
+
751 using std::begin, std::end;
+
752
+
753 for (Types::edgeId edgeId : inEdgeIds_[id])
+
754 {
+
755 ESSENTIAL_ASSERT( EdgeExists(edgeId) );
+
756
+
757 Types::vertexId other = EdgeAt(edgeId).Source();
+
758 auto & edgesAtOther = outEdgeIds_[other];
+
759 auto it = std::find( begin(edgesAtOther), end(edgesAtOther), edgeId );
+
760 ESSENTIAL_ASSERT( it != end(edgesAtOther) );
+
761 edgesAtOther.erase(it);
+
762
+
763 edgeExists_[edgeId] = false;
+
764 }
+
765
+
766 for (Types::edgeId edgeId : outEdgeIds_[id])
+
767 {
+
768 ESSENTIAL_ASSERT( EdgeExists(edgeId) );
+
769
+
770 Types::vertexId other = EdgeAt(edgeId).Target();
+
771 auto & edgesAtOther = inEdgeIds_[other];
+
772 auto it = std::find( begin(edgesAtOther), end(edgesAtOther), edgeId );
+
773 ESSENTIAL_ASSERT( it != end(edgesAtOther) );
+
774 edgesAtOther.erase(it);
+
775
+
776 edgeExists_[edgeId] = false;
+
777 }
+
778
+
779 numberOfEdges_ -= inEdgeIds_[id].size();
+
780 numberOfEdges_ -= outEdgeIds_[id].size();
+
781 inEdgeIds_[id].clear();
+
782 outEdgeIds_[id].clear();
+
783 }
+
+
784
+
798 template<typename FUNCTION>
+
+
799 inline auto MapEdges(FUNCTION function) const
+
800 -> std::vector<decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()))>
+
801 {
+
802 using TResult = decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()));
+
803 std::vector<TResult> result;
+
804
+
805 for_all_edge_tuples<ExecutionPolicy::sequential>(
+
806 [&]( Types::edgeId id, TEdge const & edge )
+
807 {
+
808 result.push_back(function(id, edge));
+
809 }
+
810 );
+
811
+
812 return result;
+
813 }
+
+
814
+
815 // Avoid implicit conversions on non-constructing functions
+
816 inline TEdge &EdgeAt ( int index ) = delete;
+
817 inline TEdge &EdgeAt ( char index ) = delete;
+
818 inline const TEdge &EdgeAt ( int index ) const = delete;
+
819 inline const TEdge &EdgeAt ( char index ) const = delete;
+
820 inline Types::edgeId EdgeId ( int source, int target ) const = delete;
+
821 inline Types::edgeId EdgeId ( char source, char target ) const = delete;
+
822 inline Types::edgeId EdgeId ( int source, char target ) const = delete;
+
823 inline Types::edgeId EdgeId ( char source, int target ) const = delete;
+
824 inline TEdge &Edge ( int source, int target ) = delete;
+
825 inline TEdge &Edge ( char source, char target ) = delete;
+
826 inline TEdge &Edge ( char source, int target ) = delete;
+
827 inline TEdge &Edge ( int source, char target ) = delete;
+
828 inline const TEdge &Edge ( int source, int target ) const = delete;
+
829 inline const TEdge &Edge ( char source, char target ) const = delete;
+
830 inline const TEdge &Edge ( int source, char target ) const = delete;
+
831 inline const TEdge &Edge ( char source, int target ) const = delete;
+
833
+
836#pragma mark UPDATE_METHODS
+
837
+
+
842 inline void UpdateVertices()
+
843 {
+
844 if (NumberOfVertices() == vertices_.size())
+
845 {
+
846 // There are no edges marked as deleted
+
847 return;
+
848 }
+
849
+
850 using std::swap;
+
851
+
852 for ( Types::vertexId id = 0
+
853 ; id < vertices_.size()
+
854 ; ++id)
+
855 {
+
856 if (vertexExists_[id]) continue;
+
857
+
858 while ( !vertexExists_.back() )
+
859 {
+
860 vertices_.pop_back();
+
861 vertexExists_.pop_back();
+
862 inEdgeIds_.pop_back();
+
863 outEdgeIds_.pop_back();
+
864 }
+
865
+
866 if ( id == vertices_.size() )
+
867 {
+
868 // All vertices behind the one at position id were marked as
+
869 // deleted and have been removed. There is nothing left to do.
+
870 break;
+
871 }
+
872
+
873 ESSENTIAL_ASSERT ( vertexExists_.back() );
+
874 ESSENTIAL_ASSERT ( vertices_.size() == vertexExists_.size() );
+
875 ESSENTIAL_ASSERT ( inEdgeIds_.size() == vertexExists_.size() );
+
876 ESSENTIAL_ASSERT ( outEdgeIds_.size() == vertexExists_.size() );
+
877
+
878 swap(vertexExists_[id], vertexExists_.back());
+
879 vertexExists_.pop_back();
+
880
+
881 swap(vertices_[id], vertices_.back());
+
882 vertices_.pop_back();
+
883 vertices_[id].identifier_ = id;
+
884
+
885 swap(inEdgeIds_[id], inEdgeIds_.back());
+
886 inEdgeIds_.pop_back();
+
887 for ( auto & edge : inEdgeIds_[id] )
+
888 {
+
889 EdgeAt(edge).target_ = id;
+
890 }
+
891
+
892 swap(outEdgeIds_[id], outEdgeIds_.back());
+
893 outEdgeIds_.pop_back();
+
894 for ( auto & edge : outEdgeIds_[id] )
+
895 {
+
896 EdgeAt(edge).source_ = id;
+
897 }
+
898
+
899 }
+
900
+
901 ESSENTIAL_ASSERT ( vertexExists_.size() == NumberOfVertices() );
+
902 ESSENTIAL_ASSERT ( vertices_.size() == NumberOfVertices() );
+
903 ESSENTIAL_ASSERT ( inEdgeIds_.size() == NumberOfVertices() );
+
904 ESSENTIAL_ASSERT ( outEdgeIds_.size() == NumberOfVertices() );
+
905 }
+
+
906
+
+
918 inline void UpdateEdges()
+
919 {
+
920 if ( NumberOfEdges() == edges_.size() )
+
921 {
+
922 // There are no edges marked as deleted.
+
923 return;
+
924 }
+
925
+
926 using std::swap;
+
927
+
928 // delete all entries where the edges do not exist
+
929 for ( Types::edgeId id = 0
+
930 ; id < edges_.size()
+
931 ; ++id)
+
932 {
+
933 if (edgeExists_[id]) continue;
+
934
+
935 while (!edgeExists_.back())
+
936 {
+
937 edgeExists_.pop_back();
+
938 edges_.pop_back();
+
939 }
+
940
+
941 if (id == edges_.size())
+
942 {
+
943 // All edges behind the one at id were marked as deleted as well
+
944 // and have been removed. We have nothing to do anymore.
+
945 break;
+
946 }
+
947
+
948 ESSENTIAL_ASSERT ( edgeExists_.back() );
+
949 ESSENTIAL_ASSERT ( edgeExists_.size() == edges_.size() );
+
950
+
951 swap(edgeExists_[id], edgeExists_.back());
+
952 swap(edges_[id], edges_.back());
+
953 edges_[id].Identifier() = id;
+
954 edgeExists_.pop_back();
+
955 edges_.pop_back();
+
956
+
957 ESSENTIAL_ASSERT( edgeExists_[id] );
+
958 }
+
959
+
960 ESSENTIAL_ASSERT ( edges_.size() == NumberOfEdges() );
+
961 ESSENTIAL_ASSERT ( edgeExists_.size() == NumberOfEdges() );
+
962
+
963 // Rebuild the vectors containing the incident edges since the IDs may have changed.
+
964 // TODO: This could be implemented more efficiently by only updating affected vertices.
+
965 for ( auto & edges : inEdgeIds_ )
+
966 {
+
967 edges.clear();
+
968 }
+
969 for ( auto & edges : outEdgeIds_ )
+
970 {
+
971 edges.clear();
+
972 }
+
973
+
974 std::for_each ( Edges().begin(), Edges().end(),
+
975 [this]( TEdge & edge )
+
976 {
+
977 Types::vertexId source = edge.Source();
+
978 Types::vertexId target = edge.Target();
+
979
+
980 inEdgeIds_[target].push_back(edge.Identifier());
+
981 outEdgeIds_[source].push_back(edge.Identifier());
+
982 }
+
983 );
+
984 }
+
+
986
+
987
+
990#pragma mark GRAPH_PROPERTIES
+
991
+
+
1004 inline Types::count MinDegree ( Types::vertexId & id ) const
+
1005 {
+
1006 if ( NumberOfVertices() == 0 )
+
1007 {
+
1008 id = Const::NONE;
+
1009 return 0;
+
1010 }
+
1011 TConstVerticesView vertices = Vertices();
+
1012
+
1013 auto result = std::min_element ( vertices.begin(), vertices.end(),
+
1014 [&]( TVertex const & left, TVertex const & right )
+
1015 {
+
1016 return DegreeAt( left.Identifier() ) < DegreeAt( right.Identifier() );
+
1017 }
+
1018 );
+
1019
+
1020 id = result->Identifier();
+
1021 return DegreeAt(id);
+
1022 }
+
+
1023
+
+
1031 inline Types::count MinDegree() const
+
1032 {
+
1033 Types::vertexId dummy = 0;
+
1034 return MinDegree(dummy);
+
1035 }
+
+
1036
+
+
1050 inline Types::count MaxDegree ( Types::vertexId & id ) const
+
1051 {
+
1052 if ( NumberOfVertices() == 0 )
+
1053 {
+
1054 id = Const::NONE;
+
1055 return 0;
+
1056 }
+
1057 TConstVerticesView vertices = Vertices();
+
1058
+
1059 auto result = std::max_element ( vertices.begin(), vertices.end(),
+
1060 [&]( TVertex const & left, TVertex const & right )
+
1061 {
+
1062 return DegreeAt( left.Identifier() ) < DegreeAt( right.Identifier() );
+
1063 }
+
1064 );
+
1065 id = result->Identifier();
+
1066 return DegreeAt(id);
+
1067 }
+
+
1068
+
+
1076 inline Types::count MaxDegree() const
+
1077 {
+
1078 Types::vertexId dummy = 0;
+
1079 return MaxDegree(dummy);
+
1080 }
+
+
1082
+
1085#pragma mark VERTEX_LOOPS
+
1086
+
1104 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1105 inline
+ +
1111
+
1128 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1129 inline
+ +
1135
+
1152 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1153 inline
+ +
1159
+
1178 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1179 inline
+ +
1185
+
1204 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1205 inline
+ +
1212
+
1215#pragma mark EDGE_LOOPS
+
1216
+
1233 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1234 inline
+ +
1240
+
1257 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1258 inline
+ +
1264
+
1281 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1282 inline
+ +
1288
+
1306 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1307 inline
+ +
1313
+
1331 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1332 inline
+ +
1339
+
1342#pragma mark NEIGHBORHOOD_LOOPS
+
1343
+
1362 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1363 inline
+ +
1369
+
1388 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1389 inline
+ +
1396
+
1417 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1418 inline
+
+
1419 void for_all_edges_at ( Types::vertexId vertexId
+
1420 , FUNCTION function )
+
1421 {
+
1422 USAGE_ASSERT( VertexExists(vertexId) );
+
1423 internal::DynamicGraphLoopDifferentiation<TGraph, Policy>
+
1424 ::for_all_edges_at ( *this, vertexId, function);
+
1425 }
+
+
1426
+
1447 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1448 inline
+
+
1449 void for_all_edges_at ( Types::vertexId vertexId
+
1450 , FUNCTION function ) const
+
1451 {
+
1452 USAGE_ASSERT( VertexExists(vertexId) );
+
1453 internal::DynamicGraphLoopDifferentiation<TGraph const, Policy>
+
1454 ::for_all_edges_at ( *this, vertexId, function );
+
1455 }
+
+
1456
+
1475 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1476 inline
+ +
1482
+
1501 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1502 inline
+
+
1503 void for_in_edges_at ( TVertex const & vertex
+
1504 , FUNCTION function ) const
+
1505 {
+
1506 internal::DynamicGraphLoopDifferentiation<TGraph const, Policy>
+
1507 ::for_in_edges_at ( *this, vertex.Identifier(), function );
+
1508 }
+
+
1509
+
1530 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1531 inline
+
+
1532 void for_in_edges_at ( Types::vertexId vertexId
+
1533 , FUNCTION function )
+
1534 {
+
1535 USAGE_ASSERT( VertexExists(vertexId) );
+
1536 internal::DynamicGraphLoopDifferentiation<TGraph, Policy>
+
1537 ::for_in_edges_at ( *this, vertexId, function );
+
1538 }
+
+
1539
+
1560 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1561 inline
+
+
1562 void for_in_edges_at ( Types::vertexId vertexId
+
1563 , FUNCTION function ) const
+
1564 {
+
1565 USAGE_ASSERT( VertexExists(vertexId) );
+
1566 internal::DynamicGraphLoopDifferentiation<TGraph const, Policy>
+
1567 ::for_in_edges_at ( *this, vertexId, function );
+
1568 }
+
+
1569
+
1588 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1589 inline
+ +
1596
+
1615 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1616 inline
+ +
1623
+
1644 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1645 inline
+
+
1646 void for_out_edges_at ( Types::vertexId vertexId
+
1647 , FUNCTION function )
+
1648 {
+
1649 USAGE_ASSERT ( VertexExists(vertexId) );
+
1650 internal::DynamicGraphLoopDifferentiation<TGraph, Policy>
+
1651 ::for_out_edges_at ( *this, vertexId, function );
+
1652 }
+
+
1653
+
1674 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1675 inline
+
+
1676 void for_out_edges_at ( Types::vertexId vertexId
+
1677 , FUNCTION function ) const
+
1678 {
+
1679 USAGE_ASSERT( VertexExists(vertexId) );
+
1680 internal::DynamicGraphLoopDifferentiation<TGraph const, Policy>
+
1681 ::for_out_edges_at ( *this, vertexId, function );
+
1682 }
+
+
1684
+
1685#pragma mark ITERATORS
+
1686 private:
+
1695 template<typename ElementType, bool Const>
+
+
1696 class OmittingVectorView
+
1697 {
+
1698 using TElement = ElementType;
+
1702 using TVector = typename std::conditional<Const,
+
1703 std::vector<TElement> const,
+
1704 std::vector<TElement>
+
1705 >::type;
+
1709 using TUnderlyingIterator = typename std::conditional<Const,
+
1710 typename TVector::const_iterator,
+
1711 typename TVector::iterator
+
1712 >::type;
+
1716 using TUnderlyingReverseIterator = typename std::conditional<Const,
+
1717 typename TVector::const_reverse_iterator,
+
1718 typename TVector::reverse_iterator
+
1719 >::type;
+
1720 public:
+
1724 using TIterator = OmittingIterator<
+
1725 TUnderlyingIterator,
+
1726 typename std::vector<bool>::const_iterator>;
+
1730 using TReverseIterator = OmittingIterator<
+
1731 TUnderlyingReverseIterator,
+
1732 typename std::vector<bool>::const_reverse_iterator>;
+
1736 using TReference = typename std::conditional<Const,
+
1737 TElement const &,
+
1738 TElement &
+
1739 >::type;
+
1740
+
+
1752 explicit OmittingVectorView ( TVector * elementVector
+
1753 , std::vector<bool> const * existsVector
+
1754 , Types::count const * counter )
+
1755 : elementVector_(elementVector),
+
1756 existsVector_(existsVector),
+
1757 counter_(counter)
+
1758 {}
+
+
1759
+
1760 TIterator begin() const noexcept
+
1761 {
+
1762 return TIterator ( elementVector_->begin()
+
1763 , elementVector_->end()
+
1764 , existsVector_->begin());
+
1765 }
+
1766
+
1767 TIterator end() const noexcept
+
1768 {
+
1769 return TIterator ( elementVector_->end()
+
1770 , elementVector_->end()
+
1771 , existsVector_->end() );
+
1772 }
+
1773
+
1774 TReverseIterator rbegin() const noexcept
+
1775 {
+
1776 return TReverseIterator ( elementVector_->rbegin()
+
1777 , elementVector_->rend()
+
1778 , existsVector_->rbegin() );
+
1779 }
+
1780
+
1781 TReverseIterator rend() const noexcept
+
1782 {
+
1783 return TReverseIterator ( elementVector_->rend()
+
1784 , elementVector_->rend()
+
1785 , existsVector_->rend() );
+
1786 }
+
1787
+
1788 bool empty() const noexcept { return size() == 0; }
+
1789 Types::count size() const noexcept { return *counter_; }
+
1790
+
1791 TReference operator[] ( Types::index index ) const
+
1792 {
+
1793 USAGE_ASSERT( (*existsVector_)[index] );
+
1794 return (*elementVector_)[index];
+
1795 }
+
1796
+
1797 private:
+
1798 TVector * elementVector_;
+
1799 std::vector<bool> const * existsVector_;
+
1800 Types::count const * counter_;
+
1801 };
+
+
1802
+
1803#pragma mark FRIENDS
+
1804
+
1805#ifdef OPENMP_AVAILABLE
+
1806 friend internal::DynamicGraphLoopDifferentiation<TGraph, ExecutionPolicy::parallel>;
+
1807 friend internal::DynamicGraphLoopDifferentiation<TGraph const, ExecutionPolicy::parallel>;
+
1808#endif // OPENMP_AVAILABLE
+
1809
+
1810#pragma mark MEMBERS
+
1811
+
1812 private:
+
1813 Types::name name_;
+
1815 std::vector<TVertex> vertices_;
+
1816 std::vector<bool> vertexExists_;
+
1817 Types::count numberOfVertices_ = 0;
+
1819 std::vector<TEdge> edges_;
+
1820 std::vector<bool> edgeExists_;
+
1821 Types::count numberOfEdges_ = 0;
+
1823 std::vector< std::vector<Types::edgeId> > inEdgeIds_;
+
1824 std::vector< std::vector<Types::edgeId> > outEdgeIds_;
+
1825};
+
+
1826
+
1827} // namespace egoa
+
1828
+
1829#endif // EGOA__DATA_STRUCTURES__GRAPHS__DYNAMIC_GRAPH_HPP
+
egoa::DynamicGraph::OmittingVectorView
A view on a vector, in which some elements are invalid.
Definition DynamicGraph.hpp:1697
+
egoa::DynamicGraph::OmittingVectorView::TReverseIterator
OmittingIterator< TUnderlyingReverseIterator, typename std::vector< bool >::const_reverse_iterator > TReverseIterator
Definition DynamicGraph.hpp:1732
+
egoa::DynamicGraph::OmittingVectorView::TUnderlyingReverseIterator
typename std::conditional< Const, typename TVector::const_reverse_iterator, typename TVector::reverse_iterator >::type TUnderlyingReverseIterator
Definition DynamicGraph.hpp:1719
+
egoa::DynamicGraph::OmittingVectorView::TReference
typename std::conditional< Const, TElement const &, TElement & >::type TReference
Definition DynamicGraph.hpp:1739
+
egoa::DynamicGraph::OmittingVectorView::TVector
typename std::conditional< Const, std::vector< TElement > const, std::vector< TElement > >::type TVector
Definition DynamicGraph.hpp:1705
+
egoa::DynamicGraph::OmittingVectorView::TIterator
OmittingIterator< TUnderlyingIterator, typename std::vector< bool >::const_iterator > TIterator
Definition DynamicGraph.hpp:1726
+
egoa::DynamicGraph::OmittingVectorView::OmittingVectorView
OmittingVectorView(TVector *elementVector, std::vector< bool > const *existsVector, Types::count const *counter)
Constructs a view to the vector pointed to by elementVector.
Definition DynamicGraph.hpp:1752
+
egoa::DynamicGraph::OmittingVectorView::TUnderlyingIterator
typename std::conditional< Const, typename TVector::const_iterator, typename TVector::iterator >::type TUnderlyingIterator
Definition DynamicGraph.hpp:1712
+
egoa::DynamicGraph
A graph data structure that supports adding and removing vertices and edges.
Definition DynamicGraph.hpp:50
+
egoa::DynamicGraph::edges_
std::vector< TEdge > edges_
Definition DynamicGraph.hpp:1819
+
egoa::DynamicGraph::for_all_edges_at
void for_all_edges_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all edges at a vertex.
Definition DynamicGraph.hpp:1449
+
egoa::DynamicGraph::for_all_vertex_identifiers
void for_all_vertex_identifiers(FUNCTION function) const
The for loop over all vertex identifiers in the graph.
Definition DynamicGraph.hpp:1106
+
egoa::DynamicGraph::for_all_edge_identifiers
void for_all_edge_identifiers(FUNCTION function) const
The for loop over all indentifiers of edges in the graph.
Definition DynamicGraph.hpp:1235
+
egoa::DynamicGraph::MaxDegree
Types::count MaxDegree(Types::vertexId &id) const
The maximum degree of the graph .
Definition DynamicGraph.hpp:1050
+
egoa::DynamicGraph::RemoveEdgeAt
void RemoveEdgeAt(Types::edgeId id)
Removes the edge with identifier id.
Definition DynamicGraph.hpp:722
+
egoa::DynamicGraph::for_in_edges_at
void for_in_edges_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all incoming edges of a vertex.
Definition DynamicGraph.hpp:1532
+
egoa::DynamicGraph::outEdgeIds_
std::vector< std::vector< Types::edgeId > > outEdgeIds_
Definition DynamicGraph.hpp:1824
+
egoa::DynamicGraph::EdgeId
Types::edgeId EdgeId(Types::vertexId source, Types::vertexId target) const
Searches for the identifier of the edge .
Definition DynamicGraph.hpp:564
+
egoa::DynamicGraph::DegreeAt
Types::count DegreeAt(Types::vertexId id) const
The degree of the vertex with identifier id.
Definition DynamicGraph.hpp:389
+ +
egoa::DynamicGraph::EdgeAt
TEdge const & EdgeAt(Types::edgeId id) const
The edge with identifier id.
Definition DynamicGraph.hpp:543
+
egoa::DynamicGraph::Edge
TEdge & Edge(Types::vertexId source, Types::vertexId target)
Searches for an edge .
Definition DynamicGraph.hpp:602
+
egoa::DynamicGraph::RemoveVertexAt
void RemoveVertexAt(Types::vertexId id)
Remove a vertex and all incident edges.
Definition DynamicGraph.hpp:253
+
egoa::DynamicGraph::for_all_edges_at
void for_all_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all edges at a vertex object.
Definition DynamicGraph.hpp:1390
+
egoa::DynamicGraph::VertexExists
bool VertexExists(Types::vertexId id) const
Whether a vertex with identifier id exists in the graph.
Definition DynamicGraph.hpp:141
+
egoa::DynamicGraph::for_all_vertex_tuples
void for_all_vertex_tuples(FUNCTION function)
The for loop over all pairs of vertex identifiers and vertex objects in the graph.
Definition DynamicGraph.hpp:1180
+
egoa::DynamicGraph::AddEdge
Types::edgeId AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)
Adds an edge to the set of edges .
Definition DynamicGraph.hpp:669
+
egoa::DynamicGraph::NeighborsOf
std::vector< Types::vertexId > NeighborsOf(Types::vertexId id) const
Neighbors of a vertex.
Definition DynamicGraph.hpp:305
+
egoa::DynamicGraph::for_all_edges_at
void for_all_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all edges at a vertex object.
Definition DynamicGraph.hpp:1364
+
egoa::DynamicGraph::for_all_edges
void for_all_edges(FUNCTION function)
The for loop over all edges in the graph.
Definition DynamicGraph.hpp:1259
+
egoa::DynamicGraph::MinDegree
Types::count MinDegree() const
The minimum degree of the graph .
Definition DynamicGraph.hpp:1031
+
egoa::DynamicGraph::inEdgeIds_
std::vector< std::vector< Types::edgeId > > inEdgeIds_
Definition DynamicGraph.hpp:1823
+
egoa::DynamicGraph::AddVertex
Types::vertexId AddVertex(TVertexProperties &&properties)
Adds a vertex.
Definition DynamicGraph.hpp:228
+
egoa::DynamicGraph::AddEdge
Types::edgeId AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)
Adds an edge to the set of edges .
Definition DynamicGraph.hpp:689
+
egoa::DynamicGraph::for_in_edges_at
void for_in_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all incoming edges of a vertex.
Definition DynamicGraph.hpp:1503
+
egoa::DynamicGraph::InEdgeIdsAt
std::vector< Types::edgeId > const & InEdgeIdsAt(Types::vertexId id) const
The identifiers of all incoming edges.
Definition DynamicGraph.hpp:404
+
egoa::DynamicGraph::NumberOfEdges
Types::count NumberOfEdges() const
The number of edges in the graph.
Definition DynamicGraph.hpp:93
+
egoa::DynamicGraph::edgeExists_
std::vector< bool > edgeExists_
Definition DynamicGraph.hpp:1820
+
egoa::DynamicGraph::for_out_edges_at
void for_out_edges_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all outgoing edges.
Definition DynamicGraph.hpp:1646
+
egoa::DynamicGraph::EdgeIdsAt
std::vector< Types::edgeId > EdgeIdsAt(Types::vertexId id) const
All edge identifiers of edges incident to a vertex.
Definition DynamicGraph.hpp:435
+
egoa::DynamicGraph::MinDegree
Types::count MinDegree(Types::vertexId &id) const
The minimum degree of the graph .
Definition DynamicGraph.hpp:1004
+
egoa::DynamicGraph::UpdateEdges
void UpdateEdges()
Deletes all edges that were marked as deleted.
Definition DynamicGraph.hpp:918
+
egoa::DynamicGraph::for_all_edges_at
void for_all_edges_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all edges at a vertex.
Definition DynamicGraph.hpp:1419
+
egoa::DynamicGraph::for_all_edge_tuples
void for_all_edge_tuples(FUNCTION function)
The for loop over all pairs of edge identifiers and edge objects in the graph.
Definition DynamicGraph.hpp:1308
+
egoa::DynamicGraph::for_all_edge_tuples
void for_all_edge_tuples(FUNCTION function) const
The for loop over all pairs of edge identifiers and edge objects in the graph.
Definition DynamicGraph.hpp:1333
+
egoa::DynamicGraph::for_all_edges
void for_all_edges(FUNCTION function) const
The for loop over all edges in the graph.
Definition DynamicGraph.hpp:1283
+
egoa::DynamicGraph::VertexAt
TVertex const & VertexAt(Types::vertexId id) const
The vertex with identifier id.
Definition DynamicGraph.hpp:170
+
egoa::DynamicGraph::UpdateVertices
void UpdateVertices()
Update vertices.
Definition DynamicGraph.hpp:842
+
egoa::DynamicGraph::AddVertex
Types::vertexId AddVertex(TVertexProperties const &properties)
Adds a vertex.
Definition DynamicGraph.hpp:216
+
egoa::DynamicGraph::for_all_vertex_tuples
void for_all_vertex_tuples(FUNCTION function) const
The for loop over all pairs of vertex identifiers and vertex objects in the graph.
Definition DynamicGraph.hpp:1206
+
egoa::DynamicGraph::DynamicGraph
DynamicGraph(Types::name name="")
The constructor.
Definition DynamicGraph.hpp:75
+
egoa::DynamicGraph::OutDegreeAt
Types::count OutDegreeAt(Types::vertexId id) const
The outdegree of the vertex with identifier id.
Definition DynamicGraph.hpp:374
+
egoa::DynamicGraph::numberOfEdges_
Types::count numberOfEdges_
Definition DynamicGraph.hpp:1821
+
egoa::DynamicGraph::for_out_edges_at
void for_out_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all outgoing edges of a vertex.
Definition DynamicGraph.hpp:1590
+
egoa::DynamicGraph::numberOfVertices_
Types::count numberOfVertices_
Definition DynamicGraph.hpp:1817
+
egoa::DynamicGraph::InDegreeAt
Types::count InDegreeAt(Types::vertexId id) const
The indegree of the vertex with identifier id.
Definition DynamicGraph.hpp:359
+
egoa::DynamicGraph::Edge
const TEdge & Edge(Types::vertexId source, Types::vertexId target) const
Searches for an edge .
Definition DynamicGraph.hpp:627
+
egoa::DynamicGraph::NumberOfVertices
Types::count NumberOfVertices() const
The number of vertices in the graph.
Definition DynamicGraph.hpp:89
+
egoa::DynamicGraph::for_in_edges_at
void for_in_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all incoming edges of a vertex.
Definition DynamicGraph.hpp:1477
+
egoa::DynamicGraph::for_in_edges_at
void for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all incoming edges of a vertex.
Definition DynamicGraph.hpp:1562
+
egoa::DynamicGraph::Vertices
TVerticesView Vertices()
A view on the vertices.
Definition DynamicGraph.hpp:109
+
egoa::DynamicGraph::Edges
TEdgesView Edges()
A view on the edges.
Definition DynamicGraph.hpp:481
+
egoa::DynamicGraph::for_all_vertices
void for_all_vertices(FUNCTION function) const
The for loop over all vertex objects in the graph.
Definition DynamicGraph.hpp:1154
+
egoa::DynamicGraph::Vertices
TConstVerticesView Vertices() const
A view on the vertices.
Definition DynamicGraph.hpp:126
+
egoa::DynamicGraph::MapVertices
auto MapVertices(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>
Applies function to all vertices and collects the result in a vector.
Definition DynamicGraph.hpp:277
+
egoa::DynamicGraph::for_out_edges_at
void for_out_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all outgoing edges of a vertex.
Definition DynamicGraph.hpp:1617
+
egoa::DynamicGraph::MaxDegree
Types::count MaxDegree() const
The maximum degree of the graph .
Definition DynamicGraph.hpp:1076
+
egoa::DynamicGraph::EdgeExists
bool EdgeExists(Types::edgeId id) const
Whether an edge with identifier id exists.
Definition DynamicGraph.hpp:514
+
egoa::DynamicGraph::NeighborsOf
void NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const
Neighbors of a vertex.
Definition DynamicGraph.hpp:327
+
egoa::DynamicGraph::AddEdge
Types::edgeId AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &properties)
Adds an edge to the set of edges .
Definition DynamicGraph.hpp:649
+
egoa::DynamicGraph::EdgeAt
TEdge & EdgeAt(Types::edgeId id)
The edge with identifier id.
Definition DynamicGraph.hpp:528
+
egoa::DynamicGraph::VertexAt
TVertex & VertexAt(Types::vertexId id)
The vertex with identifier id.
Definition DynamicGraph.hpp:155
+
egoa::DynamicGraph::Edges
TConstEdgesView Edges() const
A view on the edges.
Definition DynamicGraph.hpp:498
+
egoa::DynamicGraph::OutEdgeIdsAt
std::vector< Types::edgeId > const & OutEdgeIdsAt(Types::vertexId id) const
The identifiers of all outgoing edges.
Definition DynamicGraph.hpp:419
+
egoa::DynamicGraph::VertexId
Types::vertexId VertexId(TVertex const &vertex) const
The vertex identifier of a vertex object.
Definition DynamicGraph.hpp:190
+
egoa::DynamicGraph::EdgeIdsAt
void EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const
All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.
Definition DynamicGraph.hpp:454
+
egoa::DynamicGraph::for_out_edges_at
void for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all outgoing edges.
Definition DynamicGraph.hpp:1676
+
egoa::DynamicGraph::vertexExists_
std::vector< bool > vertexExists_
Definition DynamicGraph.hpp:1816
+
egoa::DynamicGraph::AddVertex
Types::vertexId AddVertex(TVertexProperties &properties)
Adds a vertex.
Definition DynamicGraph.hpp:204
+
egoa::DynamicGraph::RemoveAllIncidentEdgesAt
void RemoveAllIncidentEdgesAt(Types::vertexId id)
Removes all incident edges at the vertex with identifier id.
Definition DynamicGraph.hpp:747
+
egoa::DynamicGraph::for_all_vertices
void for_all_vertices(FUNCTION function)
The for loop over all vertex objects in the graph.
Definition DynamicGraph.hpp:1130
+
egoa::DynamicGraph::Name
Types::name Name() const
The name of the graph.
Definition DynamicGraph.hpp:85
+
egoa::DynamicGraph::vertices_
std::vector< TVertex > vertices_
Definition DynamicGraph.hpp:1815
+
egoa::DynamicGraph::MapEdges
auto MapEdges(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>
Applies function to all edges and collects the result in a vector.
Definition DynamicGraph.hpp:799
+
egoa::Edges::Edge
Class for edge.
Definition Edge.hpp:27
+
egoa::Edges::Edge::source_
Types::vertexId source_
Definition Edge.hpp:124
+
egoa::Edges::Edge::target_
Types::vertexId target_
Definition Edge.hpp:125
+
egoa::OmittingIterator
An iterator that omits elements of a range if another range of bool indicates that the element is inv...
Definition OmittingIterator.hpp:24
+
egoa::Vertices::Vertex
Class for a vertex.
Definition Vertex.hpp:29
+ +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_dynamic_graph_iterators_8hpp_source.html b/_dynamic_graph_iterators_8hpp_source.html new file mode 100644 index 00000000..7afa53d3 --- /dev/null +++ b/_dynamic_graph_iterators_8hpp_source.html @@ -0,0 +1,244 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators/DynamicGraphIterators.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DynamicGraphIterators.hpp
+
+
+
1/*
+
2 * DynamicGraphIterators.hpp
+
3 *
+
4 * Created on: Mar 4, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__DYNAMIC_GRAPH_ITERATORS_HPP
+
9#define EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__DYNAMIC_GRAPH_ITERATORS_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif
+
14
+
15#include "GraphIterators.hpp"
+
16
+
17namespace egoa::internal {
+
18
+
30template<typename GraphType, ExecutionPolicy Policy>
+
+
31class DynamicGraphLoopDifferentiation
+
32 : public GraphLoopDifferentiation<GraphType, Policy>
+
33{};
+
+
34
+
35#ifdef OPENMP_AVAILABLE
+
36
+
42template<typename GraphType>
+
43class DynamicGraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel>
+
44 : public GraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel> {
+
45
+
46 using TGraph = GraphType;
+
47 using TVertex = typename TGraph::TVertex;
+
48 using TVertexId = typename TGraph::TVertexId;
+
49 using TEdgeId = typename TGraph::TEdgeId;
+
50
+
51 public:
+
54#pragma mark PARALLEL_VERTEX_LOOPS
+
55
+
73 template<typename FUNCTION>
+
74 inline static
+
75 void for_all_vertex_identifiers ( TGraph & graph
+
76 , FUNCTION function )
+
77 {
+
78 #pragma omp parallel for
+
79 for ( TVertexId vertexId = 0
+
80 ; vertexId < graph.vertices_.size()
+
81 ; ++vertexId )
+
82 {
+
83 if (!graph.VertexExists(vertexId)) continue;
+
84 TVertexId copy = vertexId;
+
85 function( copy );
+
86 }
+
87 }
+
88
+
106 template<typename FUNCTION>
+
107 inline static
+
108 void for_all_vertices ( TGraph & graph
+
109 , FUNCTION function )
+
110 {
+
111 #pragma omp parallel for
+
112 for ( TVertexId vertexId = 0
+
113 ; vertexId < graph.vertices_.size()
+
114 ; ++vertexId )
+
115 {
+
116 if (!graph.VertexExists(vertexId)) continue;
+
117 function( graph.VertexAt(vertexId) );
+
118 }
+
119 }
+
120
+
138 template<typename FUNCTION>
+
139 inline static
+
140 void for_all_vertex_tuples ( TGraph & graph
+
141 , FUNCTION function )
+
142 {
+
143 #pragma omp parallel for
+
144 for ( TVertexId vertexId = 0
+
145 ; vertexId < graph.vertices_.size()
+
146 ; ++vertexId )
+
147 {
+
148 if (!graph.VertexExists(vertexId)) continue;
+
149 TVertexId copy = vertexId;
+
150 function( copy, graph.VertexAt(vertexId) );
+
151 }
+
152 }
+
154
+
157#pragma mark PARALLEL_EDGE_LOOPS
+
158
+
176 template<typename FUNCTION>
+
177 inline static
+
178 void for_all_edge_identifiers ( TGraph & graph
+
179 , FUNCTION function )
+
180 {
+
181 #pragma omp parallel for
+
182 for ( TEdgeId edgeId = 0
+
183 ; edgeId < graph.edges_.size()
+
184 ; ++edgeId )
+
185 {
+
186 if (!graph.EdgeExists(edgeId)) continue;
+
187 TEdgeId copy = edgeId;
+
188 function( copy );
+
189 }
+
190 }
+
191
+
209 template<typename FUNCTION>
+
210 inline static
+
211 void for_all_edges ( TGraph & graph
+
212 , FUNCTION function )
+
213 {
+
214 #pragma omp parallel for
+
215 for ( TEdgeId edgeId = 0
+
216 ; edgeId < graph.edges_.size()
+
217 ; ++edgeId )
+
218 {
+
219 if (!graph.EdgeExists(edgeId)) continue;
+
220 function( graph.EdgeAt(edgeId) );
+
221 }
+
222 }
+
223
+
241 template<typename FUNCTION>
+
242 inline static
+
243 void for_all_edge_tuples ( TGraph & graph
+
244 , FUNCTION function )
+
245 {
+
246 #pragma omp parallel for
+
247 for ( TEdgeId edgeId = 0
+
248 ; edgeId < graph.edges_.size()
+
249 ; ++edgeId )
+
250 {
+
251 if (!graph.EdgeExists(edgeId)) continue;
+
252 TEdgeId copy = edgeId;
+
253 function( copy, graph.EdgeAt(edgeId) );
+
254 }
+
255 }
+
257};
+
258
+
259#else // OPENMP_AVAILABLE
+
260
+
266template<typename GraphType>
+
+
267class DynamicGraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel>
+
268 : public DynamicGraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential> {
+
269};
+
+
270#endif // OPENMP_AVAILABLE
+
271
+
272
+
273} // namespace egoa::internal
+
274
+
275#endif // EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__DYNAMIC_GRAPH_ITERATORS_HPP
+ +
egoa::internal::GraphLoopDifferentiation
The base class for for loops for graphs.
Definition GraphIterators.hpp:30
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_edges_2_electrical_properties_8hpp_source.html b/_edges_2_electrical_properties_8hpp_source.html new file mode 100644 index 00000000..36e1b01d --- /dev/null +++ b/_edges_2_electrical_properties_8hpp_source.html @@ -0,0 +1,554 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Edges/ElectricalProperties.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ElectricalProperties.hpp
+
+
+
1/*
+
2 * ElectricalProperties.hpp
+
3 *
+
4 * Created on: Sep 16, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__EDGES__ELECTRICAL_PROPERTIES_HPP
+
9#define EGOA__DATA_STRUCTURES__EDGES__ELECTRICAL_PROPERTIES_HPP
+
10
+
11#include <iostream>
+
12#include <iomanip>
+
13
+
14#include "Auxiliary/Constants.hpp"
+
15#include "DataStructures/Bound.hpp"
+
16#include "DataStructures/Graphs/Edges/Type.hpp"
+
17
+
18namespace egoa::Edges {
+
19
+
20template<Edges::CarrierDifferentiationType CarrierType>
+
21class CarrierDifferentiation;
+
22
+
+
27class ElectricalProperties {
+
28 // Template type aliasing
+
29 using TBound = Bound<>;
+
30
+
31 public:
+
34#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
35
+
36 ElectricalProperties()
+
37 : name_("Branch 0")
+
38 , status_(true)
+
39 , type_(Edges::ElectricalEdgeType::standard)
+
40 , thetaBound_( TBound(0.0, 0.0) )
+
41 , resistance_(0.0)
+
42 , reactance_(0.0)
+
43 , conductance_(0.0)
+
44 , susceptance_(0.0)
+
45 , charge_(0.0)
+
46 , thermalLimitA_(0.0)
+
47 , thermalLimitB_(0.0)
+
48 , thermalLimitC_(0.0)
+
49 , tapRatio_(1.0)
+
50 , angleShift_(0.0)
+
51 , tapRatioCosThetaShift_(0.0)
+
52 , tapRatioSinThetaShift_(0.0)
+
53 //
+
54 , capitalCost_(0.0)
+
55 , length_(0.0)
+
56 , numberOfParallelLines_(0)
+
57 , nominalApparentPower_(1.0)
+
58 , nominalVoltage_(0.0)
+
59 , nominalApparentPowerBound_( TBound(0.0, 0.0) )
+
60 , nominalApparentPowerExtendable_(false)
+
61 , terrainFactor_(0.0)
+
62 {}
+
63
+
64 ElectricalProperties ( Types::name name )
+
65 : ElectricalProperties()
+
66 {
+
67 Name() = name;
+
68 }
+
70
+
+
77 friend void swap ( ElectricalProperties & lhs, ElectricalProperties & rhs )
+
78 { // Necessary for the copy and swap idiom
+
79 using std::swap; // enable ADL
+
80 swap( lhs.name_, rhs.name_ );
+
81 swap( lhs.status_, rhs.status_);
+
82 swap( lhs.type_, rhs.type_);
+
83 swap( lhs.thetaBound_, rhs.thetaBound_);
+
84 swap( lhs.resistance_, rhs.resistance_);
+
85 swap( lhs.reactance_, rhs.reactance_);
+
86 swap( lhs.conductance_, rhs.conductance_);
+
87 swap( lhs.susceptance_, rhs.susceptance_);
+
88 swap( lhs.charge_, rhs.charge_);
+
89 swap( lhs.thermalLimitA_, rhs.thermalLimitA_);
+
90 swap( lhs.thermalLimitB_, rhs.thermalLimitB_);
+
91 swap( lhs.thermalLimitC_, rhs.thermalLimitC_);
+
92 swap( lhs.tapRatio_, rhs.tapRatio_);
+
93 swap( lhs.angleShift_, rhs.angleShift_);
+
94 swap( lhs.tapRatioCosThetaShift_, rhs.tapRatioCosThetaShift_);
+
95 swap( lhs.tapRatioSinThetaShift_, rhs.tapRatioSinThetaShift_);
+
96
+
97 swap( lhs.capitalCost_, rhs.capitalCost_);
+
98 swap( lhs.length_, rhs.length_);
+
99 swap( lhs.numberOfParallelLines_, rhs.numberOfParallelLines_);
+
100 swap( lhs.nominalApparentPower_, rhs.nominalApparentPower_);
+
101 swap( lhs.nominalVoltage_, rhs.nominalVoltage_);
+
102 swap( lhs.nominalApparentPowerBound_, rhs.nominalApparentPowerBound_);
+
103 swap( lhs.nominalApparentPowerExtendable_, rhs.nominalApparentPowerExtendable_);
+
104 swap( lhs.terrainFactor_, rhs.terrainFactor_);
+
105 }
+
+
106
+
109#pragma mark COMPARATORS
+
+
118 friend bool operator== ( ElectricalProperties const & lhs
+
119 , ElectricalProperties const & rhs)
+
120 {
+
121 return ( lhs.Name() == rhs.Name() )
+
122 && ( lhs.Status() == rhs.Status() )
+
123 && ( lhs.Type() == rhs.Type() )
+
124 && ( lhs.Resistance() == rhs.Resistance() )
+
125 && ( lhs.Reactance() == rhs.Reactance() )
+
126 && ( lhs.conductance_ == rhs.conductance_ )
+
127 && ( lhs.susceptance_ == rhs.susceptance_ )
+
128 && ( lhs.Weight() == rhs.Weight() )
+
129 && ( lhs.Charge() == rhs.Charge() )
+
130 && ( lhs.ThermalLimit() == rhs.ThermalLimit() )
+
131 && ( lhs.ThermalLimitB() == rhs.ThermalLimitB() )
+
132 && ( lhs.ThermalLimitC() == rhs.ThermalLimitC() )
+
133 && ( lhs.TapRatio() == rhs.TapRatio() )
+
134 && ( lhs.AngleShift() == rhs.AngleShift() )
+
135 && ( lhs.TapRatioCosThetaShift() == rhs.TapRatioCosThetaShift() )
+
136 && ( lhs.TapRatioSinThetaShift() == rhs.TapRatioSinThetaShift() )
+
137 && ( lhs.ThetaBound() == rhs.ThetaBound() )
+
138 && ( lhs.CapitalCost() == rhs.CapitalCost() )
+
139 && ( lhs.Length() == rhs.Length() )
+
140 && ( lhs.NumberOfParallelLines() == rhs.NumberOfParallelLines() )
+
141 && ( lhs.NominalApparentPower() == rhs.NominalApparentPower() )
+
142 && ( lhs.NominalVoltage() == rhs.NominalVoltage() )
+
143 && ( lhs.NominalApparentPowerBound() == rhs.NominalApparentPowerBound() )
+
144 && ( lhs.NominalApparentPowerExtendable() == rhs.NominalApparentPowerExtendable() )
+
145 && ( lhs.TerrainFactor() == rhs.TerrainFactor() );
+
146 }
+
+
147
+
+
156 friend bool operator!=( ElectricalProperties const & lhs
+
157 , ElectricalProperties const & rhs)
+
158 {
+
159 return !(lhs == rhs);
+
160 }
+
+
162
+
165#pragma mark GETTER_AND_SETTER
+
166 inline Types::string Name() const { return name_; }
+
167 inline Types::string & Name() { return name_; }
+
168
+
169 inline bool Status() const { return status_; }
+
170 inline bool & Status() { return status_; }
+
171
+
172 inline Edges::ElectricalEdgeType Type() const { return type_; }
+
173 inline Edges::ElectricalEdgeType & Type() { return type_; }
+
174
+
175 inline Types::real Resistance() const { return resistance_; }
+
176 inline Types::real & Resistance() { return resistance_; }
+
177
+
178 inline Types::real Reactance() const { return reactance_; }
+
179 inline Types::real & Reactance() { return reactance_; }
+
180
+
181 template<Edges::CarrierDifferentiationType CarrierType>
+
182 inline Types::real Conductance() const { return CarrierDifferentiation<CarrierType>::Conductance(*this); }
+
183 inline void Conductance(Types::real conductance) { conductance_ = conductance; }
+
184
+
185 template<Edges::CarrierDifferentiationType CarrierType>
+
186 inline Types::real Susceptance() const { return CarrierDifferentiation<CarrierType>::Susceptance(*this); }
+
187 inline void Susceptance(Types::real susceptance) { susceptance_ = susceptance; }
+
188
+
189 inline Types::real Weight() const { return thermalLimitA_; }
+
190 inline Types::real & Weight() { return thermalLimitA_; }
+
191
+
192 inline Types::real Charge() const { return charge_; }
+
193 inline Types::real & Charge() { return charge_; }
+
194
+
195 inline Types::real ThermalLimit() const { return thermalLimitA_; }
+
196 inline Types::real & ThermalLimit() { return thermalLimitA_; }
+
197
+
198 inline Types::real ThermalLimitB() const { return thermalLimitB_; }
+
199 inline Types::real & ThermalLimitB() { return thermalLimitB_; }
+
200
+
201 inline Types::real ThermalLimitC() const { return thermalLimitC_; }
+
202 inline Types::real & ThermalLimitC() { return thermalLimitC_; }
+
203
+
204 inline Types::real TapRatio() const { return tapRatio_; }
+
205 inline Types::real & TapRatio() { return tapRatio_; }
+
206
+
207 inline Types::real AngleShift() const { return angleShift_; }
+
208 inline Types::real & AngleShift() { return angleShift_; }
+
209
+
210 inline Types::real TapRatioCosThetaShift() const { return tapRatioCosThetaShift_; }
+
211 inline Types::real & TapRatioCosThetaShift() { return tapRatioCosThetaShift_; }
+
212
+
213 inline Types::real TapRatioSinThetaShift() const { return tapRatioSinThetaShift_; }
+
214 inline Types::real & TapRatioSinThetaShift() { return tapRatioSinThetaShift_; }
+
215
+
216 // used to be Bound type
+
217 inline TBound ThetaBound() const { return thetaBound_; }
+
218 inline TBound & ThetaBound() { return thetaBound_; }
+
220
+
221 // PyPsa
+
222 inline Types::real CapitalCost() const { return capitalCost_; }
+
223 inline Types::real & CapitalCost() { return capitalCost_; }
+
224
+
225 inline Types::real Length() const { return length_; }
+
226 inline Types::real & Length() { return length_; }
+
227
+
228 inline Types::count NumberOfParallelLines() const { return numberOfParallelLines_; }
+
229 inline Types::count & NumberOfParallelLines() { return numberOfParallelLines_; }
+
230
+
231 inline Types::real NominalApparentPower() const { return nominalApparentPower_; }
+
232 inline Types::real & NominalApparentPower() { return nominalApparentPower_; }
+
233
+
234 inline Types::real NominalVoltage() const { return nominalVoltage_; }
+
235 inline Types::real & NominalVoltage() { return nominalVoltage_; }
+
236
+
237 inline TBound NominalApparentPowerBound() const { return nominalApparentPowerBound_; }
+
238 inline TBound & NominalApparentPowerBound() { return nominalApparentPowerBound_; }
+
239
+
240 inline bool NominalApparentPowerExtendable() const { return nominalApparentPowerExtendable_; }
+
241 inline bool & NominalApparentPowerExtendable() { return nominalApparentPowerExtendable_; }
+
242
+
243 inline Types::real TerrainFactor() const { return terrainFactor_; }
+
244 inline Types::real & TerrainFactor() { return terrainFactor_; }
+
245
+
246
+
249#pragma mark OUTPUT_METHODS
+
250
+
+
257 static void HeaderLong ( std::ostream & outputStream )
+
258 {
+
259 outputStream
+
260 << std::setw(15) << "Name"
+
261 << std::setw(6) << "Source"
+
262 << std::setw(6) << "Target"
+
263 << std::setw(10) << "Resistance"
+
264 << std::setw(10) << "Reactance"
+
265 << std::setw(10) << "Susceptance"
+
266 << std::setw(10) << "ThermalLineLimitA"
+
267 << std::setw(10) << "ThermalLineLimitB"
+
268 << std::setw(10) << "ThermalLineLimitC"
+
269 << std::setw(10) << "Ratio"
+
270 << std::setw(10) << "Angle"
+
271 << std::setw(6) << "Status"
+
272 << std::setw(10) << "AngleMinimum"
+
273 << std::setw(10) << "AngleMaximum"
+
274 << std::endl;
+
275 }
+
+
276
+
+
283 static inline void Header ( std::ostream & outputStream)
+
284 {
+
285 outputStream
+
286 << std::setw(15) << "name"
+
287 << std::setw(6) << "fbus"
+
288 << std::setw(6) << "tbus"
+
289 << std::setw(10) << "r"
+
290 << std::setw(10) << "x"
+
291 << std::setw(10) << "b"
+
292 << std::setw(10) << "rateA"
+
293 << std::setw(10) << "rateB"
+
294 << std::setw(10) << "rateC"
+
295 << std::setw(10) << "ratio"
+
296 << std::setw(10) << "angle"
+
297 << std::setw(6) << "status"
+
298 << std::setw(10) << "angmin"
+
299 << std::setw(10) << "angmax"
+
300 << std::endl;
+
301 }
+
+
302
+
+
312 inline void Line ( std::ostream & outputStream
+
313 , Types::name sourceName
+
314 , Types::name targetName
+
315 , Types::real baseMva = 1 ) const
+
316 {
+
317 outputStream
+
318 << std::setprecision(2)
+
319 << std::fixed
+
320 << std::setw(15) << Name()
+
321 << std::setw(6) << sourceName
+
322 << std::setw(6) << targetName
+
323 << std::setw(10) << Resistance()
+
324 << std::setw(10) << Reactance()
+
325 << std::setw(10) << Charge()
+
326 << std::setw(10) << ThermalLimit() * baseMva * NominalApparentPower()
+
327 << std::setw(10) << ThermalLimitB() * baseMva * NominalApparentPower()
+
328 << std::setw(10) << ThermalLimitC() * baseMva * NominalApparentPower()
+
329 << std::setw(10) << TapRatio()
+
330 << std::setw(10) << AngleShift() / Const::PI * 180
+
331 << std::setw(6) << Status()
+
332 << std::setw(10) << ThetaBound().Minimum() / Const::PI * 180
+
333 << std::setw(10) << ThetaBound().Maximum() / Const::PI * 180
+
334 << std::endl;
+
335 }
+
+
336
+
+
345 friend std::ostream & operator<< ( std::ostream & outputStream
+
346 , ElectricalProperties const & rhs )
+
347 {
+
348 outputStream << std::setprecision(2)
+
349 << std::fixed
+
350 << std::endl
+
351 << "Branch " << rhs.Name() << std::endl
+
352 << "-------------------" << std::endl
+
353 << std::setw(30) << "\tthermal line limit: "<< std::setw(10) << rhs.ThermalLimit() << std::setw(10) << " MW, "
+
354 << std::setw(10) << rhs.ThermalLimitB() << std::setw(10) << " MW, "
+
355 << std::setw(10) << rhs.ThermalLimitC() << std::setw(10) << " MW, " << std::endl
+
356 << std::setw(30) << "\timpedance Z: " << std::setw(10) << rhs.Resistance() << std::setw(10) << " p.u. (R), "
+
357 << std::setw(10) << rhs.Reactance() << std::setw(10) << " p.u. (X), " << std::endl
+
358 << std::setw(30) << "\tcharge: " << std::setw(10) << rhs.Charge() << std::setw(10) << ", " << std::endl
+
359 << std::setw(30) << "\ttap ratio: " << std::setw(10) << rhs.TapRatio() << std::setw(10) << " (tau)," << std::endl
+
360 << std::setw(30) << "\tangle shift: " << std::setw(10) << rhs.AngleShift() << std::setw(10) << " theta shift/final angle," << std::endl;
+
361 return outputStream;
+
362 }
+
+
364
+
365
+
366 private:
+
367 Types::string name_;
+
369 bool status_;
+
371 Edges::ElectricalEdgeType type_;
+
372
+
373 // used to be type Bound
+
374 TBound thetaBound_;
+
381 Types::real resistance_;
+
382 Types::real reactance_;
+
384 Types::real conductance_;
+
385 Types::real susceptance_;
+
386 Types::real charge_;
+
394 Types::real thermalLimitA_;
+
395 Types::real thermalLimitB_;
+
396 Types::real thermalLimitC_;
+
398
+
401 Types::real tapRatio_;
+
405 Types::real angleShift_;
+
407 Types::real tapRatioCosThetaShift_;
+
408 Types::real tapRatioSinThetaShift_;
+
410
+
411 // PyPsa
+
412 Types::real capitalCost_;
+
413 Types::real length_;
+
414 Types::count numberOfParallelLines_;
+
415 Types::real nominalApparentPower_;
+
416 Types::real nominalVoltage_;
+
417 TBound nominalApparentPowerBound_;
+
418 bool nominalApparentPowerExtendable_;
+
419 Types::real terrainFactor_;
+
421 friend CarrierDifferentiation<Edges::CarrierDifferentiationType::AC>;
+
422 friend CarrierDifferentiation<Edges::CarrierDifferentiationType::DC>;
+
423 friend CarrierDifferentiation<Edges::CarrierDifferentiationType::unknown>;
+
424
+
425};
+
+
426
+
427template<>
+
+
428class CarrierDifferentiation<Edges::CarrierDifferentiationType::AC> {
+
429 typedef ElectricalProperties TEdge;
+
430 public:
+
+
440 static inline Types::real Conductance ( TEdge const & edge ) {
+
441 Types::real squareImpedanceMagnitude = ( pow( edge.Resistance(), 2 ) + pow( edge.Reactance(), 2 ) );
+
442 if ( squareImpedanceMagnitude != 0 )
+
443 return ( edge.Resistance() / squareImpedanceMagnitude );
+
444 else {
+
445 std::cerr << "AcConductance: Electrical edge has values r = x = 0";
+
446 exit(-1);
+
447 }
+
448 }
+
+
449
+
+
465 static inline Types::real Susceptance ( TEdge const & edge )
+
466 {
+
467 Types::real squareImpedanceMagnitude = ( pow( edge.Resistance(), 2 ) + pow( edge.Reactance(), 2 ) );
+
468 if ( squareImpedanceMagnitude != 0 ) {
+
469 return ( -edge.Reactance() / squareImpedanceMagnitude );
+
470 } else {
+
471 std::cerr << "AcSusceptance: Electrical edge has values r = x = 0";
+
472 exit(-1);
+
473 }
+
474 }
+
+
475};
+
+
476
+
483template<>
+
+
484class CarrierDifferentiation<Edges::CarrierDifferentiationType::DC> {
+
485 typedef ElectricalProperties TEdge;
+
486 public:
+
+
497 static inline Types::real Conductance ( TEdge const & edge )
+
498 {
+
499 return 0.0;
+
500 }
+
+
501
+
+
518 static inline Types::real Susceptance ( TEdge const & edge ) {
+
519 if ( edge.Reactance() != 0 )
+
520 return ( -1 / edge.Reactance() );
+
521 else {
+
522 std::cerr << "DcSusceptance: Electrical edge has values r = x = 0";
+
523 exit(-1);
+
524 }
+
525 }
+
+
526};
+
+
527
+
533template<>
+
+
534class CarrierDifferentiation<Edges::CarrierDifferentiationType::unknown> {
+
535 typedef ElectricalProperties TEdge;
+
536 public:
+
537 static inline Types::real Conductance ( TEdge const & edge ) {
+
538 return edge.conductance_;
+
539 }
+
540
+
541 static inline Types::real Susceptance ( TEdge const & edge ) {
+
542 return edge.susceptance_;
+
543 }
+
544};
+
+
545
+
546} // namespace egoa::Edge
+
547
+
548#endif // EGOA__DATA_STRUCTURES__EDGES__ELECTRICAL_PROPERTIES_HPP
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+
egoa::Bound::Minimum
TBound Minimum() const
Getter of the minimum of the bound.
Definition Bound.hpp:61
+
egoa::Bound::Maximum
TBound Maximum() const
Getter of the maximum of the bound.
Definition Bound.hpp:85
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Susceptance
static Types::real Susceptance(TEdge const &edge)
Susceptance for the AC network.
Definition ElectricalProperties.hpp:465
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Conductance
static Types::real Conductance(TEdge const &edge)
Conductance for the AC network.
Definition ElectricalProperties.hpp:440
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Susceptance
static Types::real Susceptance(TEdge const &edge)
Susceptance for the DC approximation of an AC network.
Definition ElectricalProperties.hpp:518
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Conductance
static Types::real Conductance(TEdge const &edge)
Conductance for the DC approximation of an AC network.
Definition ElectricalProperties.hpp:497
+ +
egoa::Edges::ElectricalProperties
Class having all edge electrical properties (branch properties).
Definition ElectricalProperties.hpp:27
+ + + + + + +
egoa::Edges::ElectricalProperties::operator==
friend bool operator==(ElectricalProperties const &lhs, ElectricalProperties const &rhs)
Comparator.
Definition ElectricalProperties.hpp:118
+ + + +
egoa::Edges::ElectricalProperties::operator<<
friend std::ostream & operator<<(std::ostream &outputStream, ElectricalProperties const &rhs)
Writes the electrical property to an output stream.
Definition ElectricalProperties.hpp:345
+ + +
egoa::Edges::ElectricalProperties::HeaderLong
static void HeaderLong(std::ostream &outputStream)
Header out stream.
Definition ElectricalProperties.hpp:257
+ + + +
egoa::Edges::ElectricalProperties::Header
static void Header(std::ostream &outputStream)
Header out stream.
Definition ElectricalProperties.hpp:283
+ + + + + + + +
egoa::Edges::ElectricalProperties::operator!=
friend bool operator!=(ElectricalProperties const &lhs, ElectricalProperties const &rhs)
Comparator.
Definition ElectricalProperties.hpp:156
+ +
egoa::Edges::ElectricalProperties::Line
void Line(std::ostream &outputStream, Types::name sourceName, Types::name targetName, Types::real baseMva=1) const
Line out stream.
Definition ElectricalProperties.hpp:312
+ +
egoa::Edges::ElectricalProperties::swap
friend void swap(ElectricalProperties &lhs, ElectricalProperties &rhs)
Swapping the members of two ElectricalProperties.
Definition ElectricalProperties.hpp:77
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_edges_2_type_8hpp_source.html b/_edges_2_type_8hpp_source.html new file mode 100644 index 00000000..af2f8447 --- /dev/null +++ b/_edges_2_type_8hpp_source.html @@ -0,0 +1,245 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Edges/Type.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Type.hpp
+
+
+
1/*
+
2 * Type.hpp
+
3 *
+
4 * Created on: Oct 13, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURE__EDGES__TYPE_HPP
+
9#define EGOA__DATA_STRUCTURE__EDGES__TYPE_HPP
+
10
+
11#ifdef OGDF_AVAILABLE
+
12 #include <ogdf/basic/graphics.h>
+
13#endif
+
14
+
15#include "IO/Appearance/Color.hpp"
+
16#include "IO/Appearance/Stroke.hpp"
+
17
+
18namespace egoa::Edges {
+
19
+
22#pragma mark EDGE_TYPES
+
26 enum class ElectricalEdgeType {
+
27 standard = 0
+
28 , switched = 1
+
29 , controller = 2
+
30 , transformer = 3
+
31 , facts = 4
+
32 , overloaded = 5
+
33 , unknown = 99
+
34 };
+
35
+
41 enum class CarrierDifferentiationType {
+
42 AC = 0
+
43 , DC = 1
+
44 , unknown = 99
+
45 };
+
47
+
50#pragma mark OPERATORS
+
59 inline std::ostream & operator<< ( std::ostream & outputStream
+
60 , CarrierDifferentiationType const & rhs )
+
61 {
+
62 if ( rhs == CarrierDifferentiationType::AC ){ outputStream << "AC"; }
+
63 else if ( rhs == CarrierDifferentiationType::DC ){ outputStream << "DC"; }
+
64 else { outputStream << "unknown"; }
+
65 return outputStream;
+
66 }
+
67
+
76 inline std::ostream & operator<< ( std::ostream & outputStream
+
77 , ElectricalEdgeType const & rhs)
+
78 {
+
79 if ( rhs == ElectricalEdgeType::standard ) { outputStream << "standard"; }
+
80 else if ( rhs == ElectricalEdgeType::switched ) { outputStream << "switched"; }
+
81 else if ( rhs == ElectricalEdgeType::controller ) { outputStream << "controller"; }
+
82 else if ( rhs == ElectricalEdgeType::transformer ) { outputStream << "transformer";}
+
83 else if ( rhs == ElectricalEdgeType::facts ) { outputStream << "facts"; }
+
84 else if ( rhs == ElectricalEdgeType::overloaded ) { outputStream << "overloaded"; }
+
85 else { outputStream << "unknown"; }
+
86 return outputStream;
+
87 }
+
89
+
92#pragma mark CONVERSION_METHODS
+
93
+
94#ifdef OGDF_AVAILABLE
+
101 inline void ElectricalEdge2Stroke ( ElectricalEdgeType const & type
+
102 , ogdf::StrokeType & stroke )
+
103 {
+
104 switch (type) {
+
105 case ElectricalEdgeType::standard: stroke = ogdf::StrokeType::Solid; break;
+
106 case ElectricalEdgeType::switched: stroke = ogdf::StrokeType::Dash; break;
+
107 case ElectricalEdgeType::controller: stroke = ogdf::StrokeType::Dot; break;
+
108 case ElectricalEdgeType::transformer: stroke = ogdf::StrokeType::Dot; break;
+
109 case ElectricalEdgeType::facts: stroke = ogdf::StrokeType::Dashdot; break;
+
110 case ElectricalEdgeType::overloaded: stroke = ogdf::StrokeType::Solid; break;
+
111 default: stroke = ogdf::StrokeType::None;
+
112 }
+
113 }
+
114
+
121 inline void ElectricalEdge2Color ( ElectricalEdgeType const & type
+
122 , ogdf::Color & color )
+
123 {
+
124 switch (type) {
+
125 case ElectricalEdgeType::standard: color = ogdf::Color::Name::Black; break;
+
126 case ElectricalEdgeType::switched: color = ogdf::Color::Name::Gray; break;
+
127 case ElectricalEdgeType::controller: color = ogdf::Color::Name::Steelblue; break;
+
128 case ElectricalEdgeType::transformer: color = ogdf::Color::Name::Mediumblue;break;
+
129 case ElectricalEdgeType::facts: color = ogdf::Color::Name::Royalblue; break;
+
130 case ElectricalEdgeType::overloaded: color = ogdf::Color::Name::Darkred; break;
+
131 default: color = ogdf::Color::Name::Yellow;
+
132 }
+
133 }
+
134
+
141 inline void Stroke2ElectricalEdge ( ogdf::StrokeType const & stroke
+
142 , ElectricalEdgeType & type )
+
143 {
+
144 switch (stroke) {
+
145 case ogdf::StrokeType::Solid: type = ElectricalEdgeType::standard; break;
+
146 case ogdf::StrokeType::Dash: type = ElectricalEdgeType::switched; break;
+
147 // case ogdf::StrokeType::Dot: type = ElectricalEdgeType::controller; break;
+
148 // case ogdf::StrokeType::Dot: type = ElectricalEdgeType::transformer; break;
+
149 case ogdf::StrokeType::Dot: type = ElectricalEdgeType::facts; break;
+
150 case ogdf::StrokeType::Dashdot: type = ElectricalEdgeType::overloaded; break;
+
151 default: type = ElectricalEdgeType::unknown;
+
152 }
+
153 }
+
154
+
161 inline void Color2ElectricalEdge ( ogdf::Color const & color
+
162 , ElectricalEdgeType & type )
+
163 {
+
164 if ( color == ogdf::Color::Name::Black ) { type = ElectricalEdgeType::standard; }
+
165 else if ( color == ogdf::Color::Name::Gray ) { type = ElectricalEdgeType::switched; }
+
166 else if ( color == ogdf::Color::Name::Steelblue ) { type = ElectricalEdgeType::controller; }
+
167 else if ( color == ogdf::Color::Name::Mediumblue) { type = ElectricalEdgeType::transformer; }
+
168 else if ( color == ogdf::Color::Name::Royalblue ) { type = ElectricalEdgeType::facts; }
+
169 else if ( color == ogdf::Color::Name::Darkred ) { type = ElectricalEdgeType::overloaded; }
+
170 else { type = ElectricalEdgeType::unknown; }
+
171 }
+
172#endif // OGDF_AVAILABLE
+
173
+
180 inline void ElectricalEdge2Color ( ElectricalEdgeType const & type
+
181 , Color & color )
+
182 {
+
183 switch (type) {
+
184 case ElectricalEdgeType::standard: color = Color::Name::KITblack; break;
+
185 case ElectricalEdgeType::switched: color = Color::Name::KITblack30; break;
+
186 case ElectricalEdgeType::controller: color = Color::Name::KITseablue50; break;
+
187 case ElectricalEdgeType::transformer: color = Color::Name::KITcyanblue50;break;
+
188 case ElectricalEdgeType::facts: color = Color::Name::KITgreen70; break;
+
189 case ElectricalEdgeType::overloaded: color = Color::Name::KITred70; break;
+
190 default: color = Color::Name::KITyellow;
+
191 }
+
192 }
+
193
+
200 inline void ElectricalEdge2Stroke ( ElectricalEdgeType const & type
+
201 , Stroke::Name & stroke )
+
202 {
+
203 switch (type) {
+
204 case ElectricalEdgeType::standard: stroke = Stroke::Name::solid; break;
+
205 case ElectricalEdgeType::switched: stroke = Stroke::Name::dashed; break;
+
206 case ElectricalEdgeType::controller: stroke = Stroke::Name::dotted; break;
+
207 case ElectricalEdgeType::transformer: stroke = Stroke::Name::dotted; break;
+
208 case ElectricalEdgeType::facts: stroke = Stroke::Name::dasheddotted; break;
+
209 case ElectricalEdgeType::overloaded: stroke = Stroke::Name::bold; break;
+
210 default: stroke = Stroke::Name::none;
+
211 }
+
212 }
+
214
+
215} // namespace egoa::Edges
+
216
+
217#endif // EGOA__DATA_STRUCTURE__EDGES__TYPE_HPP
+ + + + + + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_exceptions_8hpp_source.html b/_exceptions_8hpp_source.html new file mode 100644 index 00000000..fb72dd55 --- /dev/null +++ b/_exceptions_8hpp_source.html @@ -0,0 +1,177 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Exceptions/Exceptions.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Exceptions.hpp
+
+
+
1/*
+
2 * PgtExceptions.hpp
+
3 *
+
4 * Created on: Nov 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__EXCEPTIONS__PGT_EXCEPTIONS_HPP
+
9#define EGOA__EXCEPTIONS__PGT_EXCEPTIONS_HPP
+
10
+
11#include <iostream>
+
12#include <exception>
+
13#include <stdexcept>
+
14#include <sstream>
+
15#include <string>
+
16
+
17#include "Auxiliary/Types.hpp"
+
18
+
19namespace egoa {
+
20
+
21// https://stackoverflow.com/questions/348833/how-to-know-the-exact-line-of-code-where-where-an-exception-has-been-caused
+
22template<typename T>
+
23void my_exception(T arg1, T arg2, const char *file, const char *func, size_t line) {
+
24#ifdef PGT_EXCEPTION_HANDLING
+
25 if ( arg1 < arg2 )
+
26 throw runtime_error( (std::string)file + ":" + (std::string)func + ":" + std::to_string(line) +
+
27 ": index out of bound error with index:" + to_string(arg1) +
+
28 " > number of elements ( here " + to_string(arg2) + ")." );
+
29#endif
+
30}
+
31
+
32#define throw_out_of_bound(arg1,arg2) throw my_exception(arg1, arg2, __FILE__, __func__, __LINE__);
+
33
+
34// template<typename T = double>
+
+
35class BoundMismatch : public std::runtime_error {
+
36 typedef double T;
+
37 public:
+
+
39 BoundMismatch(std::string msg, T minimum, T maximum)
+
40 : std::runtime_error(msg), minimum_(minimum), maximum_(maximum) {}
+
+
41
+
42 BoundMismatch(T minimum, T maximum)
+
43 : std::runtime_error("Minimum > maximum"), minimum_(minimum), maximum_(maximum) {
+
44
+
45 }
+
46
+
47 inline T Minimum() const { return minimum_; }
+
48 inline T& Minimum() { return minimum_; }
+
49
+
50 inline T Maximum() const { return maximum_; }
+
51 inline T& Maximum() { return maximum_; }
+
52
+
53 template<typename T2 = double>
+
54 static T2 Check(const T2& minimum, const T2& maximum)
+
55 {
+
56 if ( minimum > maximum ) {
+
57 throw BoundMismatch( minimum, maximum );
+
58 }
+
59 return true;
+
60 }
+
61
+
62 virtual Types::string What() const throw() {
+
63 std::ostringstream message;
+
64
+
65 message << runtime_error::what()
+
66 << ": " << Minimum()
+
67 << " < " << Maximum();
+
68
+
69 return message.str();
+
70 }
+
71
+
72 private:
+
73 double minimum_;
+
74 double maximum_;
+
75};
+
+
76
+
77// ostringstream BoundMismatch::message_;
+
78
+
79} // namespace egoa
+
80
+
81#endif // EGOA__EXCEPTIONS__PGT_EXCEPTIONS_HPP
+ +
egoa::BoundMismatch::BoundMismatch
BoundMismatch(std::string msg, T minimum, T maximum)
constructor only which passes message to base class
Definition Exceptions.hpp:39
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_execution_policy_8hpp_source.html b/_execution_policy_8hpp_source.html new file mode 100644 index 00000000..9069221e --- /dev/null +++ b/_execution_policy_8hpp_source.html @@ -0,0 +1,117 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/ExecutionPolicy.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ExecutionPolicy.hpp
+
+
+
1/*
+
2 * ExecutionPolicy.hpp
+
3 *
+
4 * Created on: Mar 1, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7#ifndef EGOA__AUXILIARY__EXECUTION_POLICY_HPP
+
8#define EGOA__AUXILIARY__EXECUTION_POLICY_HPP
+
9
+
10namespace egoa {
+
11
+
+
15enum class ExecutionPolicy {
+
19 sequential,
+
23 parallel,
+
27 breakable
+
28};
+
+
29
+
30}
+
31
+
32#endif // EGOA__AUXILIARY__EXECUTION_POLICY_HPP
+
egoa
Definition Color.cpp:15
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_formulas.log b/_formulas.log new file mode 100644 index 00000000..6a0243a1 --- /dev/null +++ b/_formulas.log @@ -0,0 +1,196 @@ +This is pdfTeX, Version 3.141592653-2.6-1.40.22 (TeX Live 2022/dev/Debian) (preloaded format=latex 2024.1.12) 12 JAN 2024 14:52 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +**_formulas +(./_formulas.tex +LaTeX2e <2021-11-15> patch level 1 +L3 programming layer <2022-01-21> (/usr/share/texlive/texmf-dist/tex/latex/base +/article.cls +Document Class: article 2021/10/04 v1.4n Standard LaTeX document class +(/usr/share/texlive/texmf-dist/tex/latex/base/size10.clo +File: size10.clo 2021/10/04 v1.4n Standard LaTeX file (size option) +) +\c@part=\count185 +\c@section=\count186 +\c@subsection=\count187 +\c@subsubsection=\count188 +\c@paragraph=\count189 +\c@subparagraph=\count190 +\c@figure=\count191 +\c@table=\count192 +\abovecaptionskip=\skip47 +\belowcaptionskip=\skip48 +\bibindent=\dimen138 +) (/usr/share/texlive/texmf-dist/tex/latex/base/ifthen.sty +Package: ifthen 2020/11/24 v1.1c Standard LaTeX ifthen package (DPC) +) (/usr/share/texlive/texmf-dist/tex/latex/graphics/epsfig.sty +Package: epsfig 2017/06/25 v1.7b (e)psfig emulation (SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphicx.sty +Package: graphicx 2021/09/16 v1.2d Enhanced LaTeX Graphics (DPC,SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/keyval.sty +Package: keyval 2014/10/28 v1.15 key=value parser (DPC) +\KV@toks@=\toks16 +) (/usr/share/texlive/texmf-dist/tex/latex/graphics/graphics.sty +Package: graphics 2021/03/04 v1.4d Standard LaTeX Graphics (DPC,SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/trig.sty +Package: trig 2021/08/11 v1.11 sin cos tan (DPC) +) (/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/graphics.cfg +File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration +) +Package graphics Info: Driver file: dvips.def on input line 107. +(/usr/share/texlive/texmf-dist/tex/latex/graphics-def/dvips.def +File: dvips.def 2017/06/20 v3.1d Graphics/color driver for dvips +)) +\Gin@req@height=\dimen139 +\Gin@req@width=\dimen140 +) +\epsfxsize=\dimen141 +\epsfysize=\dimen142 +) (/usr/share/texlive/texmf-dist/tex/latex/base/inputenc.sty +Package: inputenc 2021/02/14 v1.3d Input encoding file +\inpenc@prehook=\toks17 +\inpenc@posthook=\toks18 +) (/usr/share/texlive/texmf-dist/tex/latex/xcolor/xcolor.sty +Package: xcolor 2021/10/31 v2.13 LaTeX color extensions (UK) +(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/color.cfg +File: color.cfg 2016/01/02 v1.6 sample color configuration +) +Package xcolor Info: Driver file: dvips.def on input line 227. +Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1352. +Package xcolor Info: Model `RGB' extended on input line 1368. +Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1370. +Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1371. +Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1372. +Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1373. +Package xcolor Info: Model `Gray' substituted by `gray' on input line 1374. +Package xcolor Info: Model `wave' substituted by `hsb' on input line 1375. +) +(/home/runner/work/egoa/egoa/documentation/includes/EGOA_DocumentationLatexPrea +mble.sty (/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amsfonts.sty +Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support +\@emptytoks=\toks19 +\symAMSa=\mathgroup4 +\symAMSb=\mathgroup5 +LaTeX Font Info: Redeclaring math symbol \hbar on input line 98. +LaTeX Font Info: Overwriting math alphabet `\mathfrak' in version `bold' +(Font) U/euf/m/n --> U/euf/b/n on input line 106. +) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsmath.sty +Package: amsmath 2021/10/15 v2.17l AMS math features +\@mathmargin=\skip49 +For additional information on amsmath, use the `?' option. +(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amstext.sty +Package: amstext 2021/08/26 v2.01 AMS text +(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsgen.sty +File: amsgen.sty 1999/11/30 v2.0 generic functions +\@emptytoks=\toks20 +\ex@=\dimen143 +)) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsbsy.sty +Package: amsbsy 1999/11/29 v1.2d Bold Symbols +\pmbraise@=\dimen144 +) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsopn.sty +Package: amsopn 2021/08/26 v2.02 operator names +) +\inf@bad=\count193 +LaTeX Info: Redefining \frac on input line 234. +\uproot@=\count194 +\leftroot@=\count195 +LaTeX Info: Redefining \overline on input line 399. +\classnum@=\count196 +\DOTSCASE@=\count197 +LaTeX Info: Redefining \ldots on input line 496. +LaTeX Info: Redefining \dots on input line 499. +LaTeX Info: Redefining \cdots on input line 620. +\Mathstrutbox@=\box50 +\strutbox@=\box51 +\big@size=\dimen145 +LaTeX Font Info: Redeclaring font encoding OML on input line 743. +LaTeX Font Info: Redeclaring font encoding OMS on input line 744. +\macc@depth=\count198 +\c@MaxMatrixCols=\count199 +\dotsspace@=\muskip16 +\c@parentequation=\count266 +\dspbrk@lvl=\count267 +\tag@help=\toks21 +\row@=\count268 +\column@=\count269 +\maxfields@=\count270 +\andhelp@=\toks22 +\eqnshift@=\dimen146 +\alignsep@=\dimen147 +\tagshift@=\dimen148 +\tagwidth@=\dimen149 +\totwidth@=\dimen150 +\lineht@=\dimen151 +\@envbody=\toks23 +\multlinegap=\skip50 +\multlinetaggap=\skip51 +\mathdisplay@stack=\toks24 +LaTeX Info: Redefining \[ on input line 2938. +LaTeX Info: Redefining \] on input line 2939. +) (/usr/share/texlive/texmf-dist/tex/latex/amscls/amsthm.sty +Package: amsthm 2020/05/29 v2.20.6 +\thm@style=\toks25 +\thm@bodyfont=\toks26 +\thm@headfont=\toks27 +\thm@notefont=\toks28 +\thm@headpunct=\toks29 +\thm@preskip=\skip52 +\thm@postskip=\skip53 +\thm@headsep=\skip54 +\dth@everypar=\toks30 +) (/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amssymb.sty +Package: amssymb 2013/01/14 v3.01 AMS font symbols +) (/usr/share/texlive/texmf-dist/tex/latex/mathtools/mathtools.sty +Package: mathtools 2021/02/02 v1.28 mathematical typesetting tools +(/usr/share/texlive/texmf-dist/tex/latex/tools/calc.sty +Package: calc 2017/05/25 v4.3 Infix arithmetic (KKT,FJ) +\calc@Acount=\count271 +\calc@Bcount=\count272 +\calc@Adimen=\dimen152 +\calc@Bdimen=\dimen153 +\calc@Askip=\skip55 +\calc@Bskip=\skip56 +LaTeX Info: Redefining \setlength on input line 80. +LaTeX Info: Redefining \addtolength on input line 81. +\calc@Ccount=\count273 +\calc@Cskip=\skip57 +) (/usr/share/texlive/texmf-dist/tex/latex/mathtools/mhsetup.sty +Package: mhsetup 2021/03/18 v1.4 programming setup (MH) +) +\g_MT_multlinerow_int=\count274 +\l_MT_multwidth_dim=\dimen154 +\origjot=\skip58 +\l_MT_shortvdotswithinadjustabove_dim=\dimen155 +\l_MT_shortvdotswithinadjustbelow_dim=\dimen156 +\l_MT_above_intertext_sep=\dimen157 +\l_MT_below_intertext_sep=\dimen158 +\l_MT_above_shortintertext_sep=\dimen159 +\l_MT_below_shortintertext_sep=\dimen160 +\xmathstrut@box=\box52 +\xmathstrut@dim=\dimen161 +) + +! LaTeX Error: File `complexity.sty' not found. + +Type X to quit or to proceed, +or enter new name. (Default extension: sty) + +Enter file name: +! Emergency stop. + + +l.22 \usepackage + {thmtools}^^M +*** (cannot \read from terminal in nonstop modes) + + +Here is how much of TeX's memory you used: + 3174 strings out of 480248 + 46508 string characters out of 5896177 + 333174 words of memory out of 5000000 + 21130 multiletter control sequences out of 15000+600000 + 469259 words of font info for 28 fonts, out of 8000000 for 9000 + 14 hyphenation exceptions out of 8191 + 70i,0n,76p,224b,36s stack positions out of 5000i,500n,10000p,200000b,80000s +No pages of output. diff --git a/_formulas.tex b/_formulas.tex new file mode 100644 index 00000000..b1032444 --- /dev/null +++ b/_formulas.tex @@ -0,0 +1,457 @@ +\documentclass{article} +\usepackage{ifthen} +\usepackage{epsfig} +\usepackage[utf8]{inputenc} +\usepackage{xcolor} +% Packages requested by user +\usepackage{/home/runner/work/egoa/egoa/documentation/includes/EGOA_DocumentationLatexPreamble} + +\usepackage{newunicodechar} + \makeatletter + \def\doxynewunicodechar#1#2{% + \@tempswafalse + \edef\nuc@tempa{\detokenize{#1}}% + \if\relax\nuc@tempa\relax + \nuc@emptyargerr + \else + \edef\@tempb{\expandafter\@car\nuc@tempa\@nil}% + \nuc@check + \if@tempswa + \@namedef{u8:\nuc@tempa}{#2}% + \fi + \fi + } + \makeatother + \doxynewunicodechar{⁻}{${}^{-}$}% Superscript minus + \doxynewunicodechar{²}{${}^{2}$}% Superscript two + \doxynewunicodechar{³}{${}^{3}$}% Superscript three + +\pagestyle{empty} +\begin{document} +$\dtp$ +\pagebreak + +$c_{\sbc}\colon\edges\to\posreals$ +\pagebreak + +\[ + c_{\sbc} := \frac{1}{m_B}\sum_{\source\in\vertices}\sum_{\sink\in\vertices\setminus\{\source\}} \frac{\sigma_{\dtp}(\source,\sink,\edge)}{\sigma_{\dtp}(\source,\sink)}, + \] +\pagebreak + +$\sigma_{\dtp}(\source,\sink,\edge)$ +\pagebreak + +$\dtp{s}$ +\pagebreak + +$\source$ +\pagebreak + +$\sink$ +\pagebreak + +$\edge$ +\pagebreak + +$\sigma_{\dtp}(\source,\sink)$ +\pagebreak + +$\dtp{\text{s}}$ +\pagebreak + +$m_B = |\vertices|\cdot(|\vertices|-1)$ +\pagebreak + +$\SBC$ +\pagebreak + +$\sbc$ +\pagebreak + +$m_B = |V|\cdot (|V|-1)$ +\pagebreak + +$\graph = (\vertices,\edges)$ +\pagebreak + +$\labels(\vertex)$ +\pagebreak + +$\vertex$ +\pagebreak + +$\labelu$ +\pagebreak + +$\labelu_{\mathrm{new}}$ +\pagebreak + +$\queue$ +\pagebreak + +$\labelu_{p}$ +\pagebreak + +$\labelu_p$ +\pagebreak + +$\vertex\in\vertices$ +\pagebreak + +$\Theta(1)$ +\pagebreak + +$\Theta(\log n)$ +\pagebreak + +$\Theta(n)$ +\pagebreak + +$n = |\vertices|$ +\pagebreak + +$m = |\edges|$ +\pagebreak + +$O(|\vertices|)$ +\pagebreak + +$O(1)$ +\pagebreak + +$(\vertexa, + \vertexb)$ +\pagebreak + +$\vertexa$ +\pagebreak + +$(\vertexa,\vertexb)$ +\pagebreak + +$\vertexb$ +\pagebreak + +$(\vertexa, \vertexb)$ +\pagebreak + +$\edges$ +\pagebreak + +$m-1$ +\pagebreak + +$\graph$ +\pagebreak + +$ r = x = b = 0 $ +\pagebreak + +$ tap = |V(source)|/|V(target)|) $ +\pagebreak + +$r / (r^2 + x^2)$ +\pagebreak + +$x / (r^2 + x^2)$ +\pagebreak + +$x /(r^2 + + x^2)$ +\pagebreak + +$1 / x$ +\pagebreak + +$\shuntsusceptance(\vertex)$ +\pagebreak + +$\shuntsusceptance\colon\vertices\to\reals$ +\pagebreak + +$\shuntconductance(\vertex)$ +\pagebreak + +$\shuntconductance\colon\vertices\to\reals$ +\pagebreak + +$\voltagenominal$ +\pagebreak + +$\vmagnitude$ +\pagebreak + +$\vangle(\vertex)$ +\pagebreak + +$\vangle\colon\vertices\to\reals$ +\pagebreak + +$\voltagemin$ +\pagebreak + +$\voltagemax$ +\pagebreak + +$\ac$ +\pagebreak + +$\dc$ +\pagebreak + +$\vmagnitude(\vertex)$ +\pagebreak + +$\voltage := [\voltagemin,\voltagemax]$ +\pagebreak + +$\realpowernominal$ +\pagebreak + +$\realpowernominalmin$ +\pagebreak + +$\realpowernominalmax$ +\pagebreak + +\[ + \realpowernominal := [\realpowernominalmin,\realpowernominalmax]. + \] +\pagebreak + +$\vertex\in\generators$ +\pagebreak + +$\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ +\pagebreak + +$\realpowergeneration$ +\pagebreak + +$[\realpowergenerationmin, \realpowergenerationmax]$ +\pagebreak + +$[\realpowergenerationmin, + \realpowergenerationmax]$ +\pagebreak + +$\reactivepowergeneration$ +\pagebreak + +$[\reactivepowergenerationmin, \reactivepowergenerationmax]$ +\pagebreak + +$[\reactivepowergenerationmin,\reactivepowergenerationmax]$ +\pagebreak + +$\realpowernominal\coloneqq[\realpowernominalmin, + \realpowernominalmax]$ +\pagebreak + +$[\realpowergenerationmin, + \realpowergenerationmax]$ +\pagebreak + +$[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ +\pagebreak + +$\realpowerdemand$ +\pagebreak + +$[\realpowerdemandmin, \realpowerdemandmax]$ +\pagebreak + +$\reactivepowerdemand$ +\pagebreak + +$[\reactivepowerdemandmin, \reactivepowerdemandmax]$ +\pagebreak + +$[\reactivepowerdemandmin, + \reactivepowerdemandmax]$ +\pagebreak + +$\graph = (\vertices, \edges)$ +\pagebreak + +$\vertices$ +\pagebreak + +$\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$ +\pagebreak + +$\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$ +\pagebreak + +\[ + \bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}, + \] +\pagebreak + +$\susceptance(\vertexa,\vertexb)\in\reals$ +\pagebreak + +$(\vertexa,\vertexb)\in\edges$ +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}}$ +\pagebreak + +$\fpath{}{\vertexa}{\vertexb}$ +\pagebreak + +\[ + \deltavangle(\vertexa,\vertexb) = \bnorm{\fpath{}{\vertexa}{\vertexb}} \cdot \fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}, + \] +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}$ +\pagebreak + +$\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }:= \min_{ (\vertexa,\vertexb)\in\pathu}\fcapacity{}{\vertexa}{\vertexb}$ +\pagebreak + +$\capacity\colon\edges\to\reals$ +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}} = 0.0$ +\pagebreak + +$(0,\infty)$ +\pagebreak + +$\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }$ +\pagebreak + +$\fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}$ +\pagebreak + +$\vertexa\in\vertices$ +\pagebreak + +$\deltavangle(\vertexa,\vertexb)$ +\pagebreak + +$\realpowergeneration(\vertex)$ +\pagebreak + +$\network$ +\pagebreak + +\[ + -\maxdemand\leq\netflow(\vertexa)\leq-\mindemand\qquad\forall\vertexa\in\consumers + \] +\pagebreak + +\[ + \maxexcess\leq\netflow(\vertexa)\leq \minexcess\qquad\forall\vertexa\in\generators + \] +\pagebreak + +\[ + -\infty\leq\netflow(\vertexa)\leq 0\qquad\forall\vertexa\in\consumers + \] +\pagebreak + +\[ + 0\leq\netflow(\vertexa)\leq\infty\qquad\forall\vertexa\in\generators + \] +\pagebreak + +\[ + -\demand(\vertexa)\leq\netflow(\vertexa)\leq -\demand(\vertexa)\qquad\forall\vertexa\in\consumers, + \] +\pagebreak + +\[ + \excess(\vertexa)\leq\netflow(\vertexa)\leq\excess(\vertexa)\qquad\forall\vertexa\in\generators, + \] +\pagebreak + +$\netflow:=\sum_{ \{ \vertexa,\vertexb \} \in \undirectededges } \flow ( \vertexa,\vertexb ) $ +\pagebreak + +$\generators$ +\pagebreak + +$\consumers$ +\pagebreak + +$g\in\generators$ +\pagebreak + +$\emptyset$ +\pagebreak + +$\{\vertex\}\cap\generators = \emptyset$ +\pagebreak + +$\realpowergenerationmin$ +\pagebreak + +$\realpowergenerationmax$ +\pagebreak + +$[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ +\pagebreak + +$\reactivepowergenerationmin$ +\pagebreak + +$\reactivepowergenerationmax$ +\pagebreak + +$ \frac{R}{|Z|} $ +\pagebreak + +$ |Z| = R^2 + X^2 $ +\pagebreak + +$ \frac{X}{|Z|} $ +\pagebreak + +$ \frac{angle^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$ \pi = 180^\circ $ +\pagebreak + +$ ratio\cdot\cos\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $ +\pagebreak + +$ ratio\cdot\sin\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $ +\pagebreak + +$ \frac{angmin^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$ \frac{angmax^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$ +\pagebreak + +$\graph = (\vertices, \edges_{\mathrm{cand}})$ +\pagebreak + +$ \network $ +\pagebreak + +$\network $ +\pagebreak + +$\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$ +\pagebreak + +$\graph $ +\pagebreak + +\end{document} diff --git a/_formulas_dark.log b/_formulas_dark.log new file mode 100644 index 00000000..272487f8 --- /dev/null +++ b/_formulas_dark.log @@ -0,0 +1,196 @@ +This is pdfTeX, Version 3.141592653-2.6-1.40.22 (TeX Live 2022/dev/Debian) (preloaded format=latex 2024.1.12) 12 JAN 2024 14:52 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +**_formulas_dark +(./_formulas_dark.tex +LaTeX2e <2021-11-15> patch level 1 +L3 programming layer <2022-01-21> (/usr/share/texlive/texmf-dist/tex/latex/base +/article.cls +Document Class: article 2021/10/04 v1.4n Standard LaTeX document class +(/usr/share/texlive/texmf-dist/tex/latex/base/size10.clo +File: size10.clo 2021/10/04 v1.4n Standard LaTeX file (size option) +) +\c@part=\count185 +\c@section=\count186 +\c@subsection=\count187 +\c@subsubsection=\count188 +\c@paragraph=\count189 +\c@subparagraph=\count190 +\c@figure=\count191 +\c@table=\count192 +\abovecaptionskip=\skip47 +\belowcaptionskip=\skip48 +\bibindent=\dimen138 +) (/usr/share/texlive/texmf-dist/tex/latex/base/ifthen.sty +Package: ifthen 2020/11/24 v1.1c Standard LaTeX ifthen package (DPC) +) (/usr/share/texlive/texmf-dist/tex/latex/graphics/epsfig.sty +Package: epsfig 2017/06/25 v1.7b (e)psfig emulation (SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphicx.sty +Package: graphicx 2021/09/16 v1.2d Enhanced LaTeX Graphics (DPC,SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/keyval.sty +Package: keyval 2014/10/28 v1.15 key=value parser (DPC) +\KV@toks@=\toks16 +) (/usr/share/texlive/texmf-dist/tex/latex/graphics/graphics.sty +Package: graphics 2021/03/04 v1.4d Standard LaTeX Graphics (DPC,SPQR) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/trig.sty +Package: trig 2021/08/11 v1.11 sin cos tan (DPC) +) (/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/graphics.cfg +File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration +) +Package graphics Info: Driver file: dvips.def on input line 107. +(/usr/share/texlive/texmf-dist/tex/latex/graphics-def/dvips.def +File: dvips.def 2017/06/20 v3.1d Graphics/color driver for dvips +)) +\Gin@req@height=\dimen139 +\Gin@req@width=\dimen140 +) +\epsfxsize=\dimen141 +\epsfysize=\dimen142 +) (/usr/share/texlive/texmf-dist/tex/latex/base/inputenc.sty +Package: inputenc 2021/02/14 v1.3d Input encoding file +\inpenc@prehook=\toks17 +\inpenc@posthook=\toks18 +) (/usr/share/texlive/texmf-dist/tex/latex/xcolor/xcolor.sty +Package: xcolor 2021/10/31 v2.13 LaTeX color extensions (UK) +(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/color.cfg +File: color.cfg 2016/01/02 v1.6 sample color configuration +) +Package xcolor Info: Driver file: dvips.def on input line 227. +Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1352. +Package xcolor Info: Model `RGB' extended on input line 1368. +Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1370. +Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1371. +Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1372. +Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1373. +Package xcolor Info: Model `Gray' substituted by `gray' on input line 1374. +Package xcolor Info: Model `wave' substituted by `hsb' on input line 1375. +) +(/home/runner/work/egoa/egoa/documentation/includes/EGOA_DocumentationLatexPrea +mble.sty (/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amsfonts.sty +Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support +\@emptytoks=\toks19 +\symAMSa=\mathgroup4 +\symAMSb=\mathgroup5 +LaTeX Font Info: Redeclaring math symbol \hbar on input line 98. +LaTeX Font Info: Overwriting math alphabet `\mathfrak' in version `bold' +(Font) U/euf/m/n --> U/euf/b/n on input line 106. +) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsmath.sty +Package: amsmath 2021/10/15 v2.17l AMS math features +\@mathmargin=\skip49 +For additional information on amsmath, use the `?' option. +(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amstext.sty +Package: amstext 2021/08/26 v2.01 AMS text +(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsgen.sty +File: amsgen.sty 1999/11/30 v2.0 generic functions +\@emptytoks=\toks20 +\ex@=\dimen143 +)) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsbsy.sty +Package: amsbsy 1999/11/29 v1.2d Bold Symbols +\pmbraise@=\dimen144 +) (/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsopn.sty +Package: amsopn 2021/08/26 v2.02 operator names +) +\inf@bad=\count193 +LaTeX Info: Redefining \frac on input line 234. +\uproot@=\count194 +\leftroot@=\count195 +LaTeX Info: Redefining \overline on input line 399. +\classnum@=\count196 +\DOTSCASE@=\count197 +LaTeX Info: Redefining \ldots on input line 496. +LaTeX Info: Redefining \dots on input line 499. +LaTeX Info: Redefining \cdots on input line 620. +\Mathstrutbox@=\box50 +\strutbox@=\box51 +\big@size=\dimen145 +LaTeX Font Info: Redeclaring font encoding OML on input line 743. +LaTeX Font Info: Redeclaring font encoding OMS on input line 744. +\macc@depth=\count198 +\c@MaxMatrixCols=\count199 +\dotsspace@=\muskip16 +\c@parentequation=\count266 +\dspbrk@lvl=\count267 +\tag@help=\toks21 +\row@=\count268 +\column@=\count269 +\maxfields@=\count270 +\andhelp@=\toks22 +\eqnshift@=\dimen146 +\alignsep@=\dimen147 +\tagshift@=\dimen148 +\tagwidth@=\dimen149 +\totwidth@=\dimen150 +\lineht@=\dimen151 +\@envbody=\toks23 +\multlinegap=\skip50 +\multlinetaggap=\skip51 +\mathdisplay@stack=\toks24 +LaTeX Info: Redefining \[ on input line 2938. +LaTeX Info: Redefining \] on input line 2939. +) (/usr/share/texlive/texmf-dist/tex/latex/amscls/amsthm.sty +Package: amsthm 2020/05/29 v2.20.6 +\thm@style=\toks25 +\thm@bodyfont=\toks26 +\thm@headfont=\toks27 +\thm@notefont=\toks28 +\thm@headpunct=\toks29 +\thm@preskip=\skip52 +\thm@postskip=\skip53 +\thm@headsep=\skip54 +\dth@everypar=\toks30 +) (/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amssymb.sty +Package: amssymb 2013/01/14 v3.01 AMS font symbols +) (/usr/share/texlive/texmf-dist/tex/latex/mathtools/mathtools.sty +Package: mathtools 2021/02/02 v1.28 mathematical typesetting tools +(/usr/share/texlive/texmf-dist/tex/latex/tools/calc.sty +Package: calc 2017/05/25 v4.3 Infix arithmetic (KKT,FJ) +\calc@Acount=\count271 +\calc@Bcount=\count272 +\calc@Adimen=\dimen152 +\calc@Bdimen=\dimen153 +\calc@Askip=\skip55 +\calc@Bskip=\skip56 +LaTeX Info: Redefining \setlength on input line 80. +LaTeX Info: Redefining \addtolength on input line 81. +\calc@Ccount=\count273 +\calc@Cskip=\skip57 +) (/usr/share/texlive/texmf-dist/tex/latex/mathtools/mhsetup.sty +Package: mhsetup 2021/03/18 v1.4 programming setup (MH) +) +\g_MT_multlinerow_int=\count274 +\l_MT_multwidth_dim=\dimen154 +\origjot=\skip58 +\l_MT_shortvdotswithinadjustabove_dim=\dimen155 +\l_MT_shortvdotswithinadjustbelow_dim=\dimen156 +\l_MT_above_intertext_sep=\dimen157 +\l_MT_below_intertext_sep=\dimen158 +\l_MT_above_shortintertext_sep=\dimen159 +\l_MT_below_shortintertext_sep=\dimen160 +\xmathstrut@box=\box52 +\xmathstrut@dim=\dimen161 +) + +! LaTeX Error: File `complexity.sty' not found. + +Type X to quit or to proceed, +or enter new name. (Default extension: sty) + +Enter file name: +! Emergency stop. + + +l.22 \usepackage + {thmtools}^^M +*** (cannot \read from terminal in nonstop modes) + + +Here is how much of TeX's memory you used: + 3173 strings out of 480248 + 46523 string characters out of 5896177 + 333215 words of memory out of 5000000 + 21130 multiletter control sequences out of 15000+600000 + 469259 words of font info for 28 fonts, out of 8000000 for 9000 + 14 hyphenation exceptions out of 8191 + 70i,0n,76p,229b,36s stack positions out of 5000i,500n,10000p,200000b,80000s +No pages of output. diff --git a/_formulas_dark.tex b/_formulas_dark.tex new file mode 100644 index 00000000..28c19964 --- /dev/null +++ b/_formulas_dark.tex @@ -0,0 +1,459 @@ +\documentclass{article} +\usepackage{ifthen} +\usepackage{epsfig} +\usepackage[utf8]{inputenc} +\usepackage{xcolor} +\color{white} +\pagecolor{black} +% Packages requested by user +\usepackage{/home/runner/work/egoa/egoa/documentation/includes/EGOA_DocumentationLatexPreamble} + +\usepackage{newunicodechar} + \makeatletter + \def\doxynewunicodechar#1#2{% + \@tempswafalse + \edef\nuc@tempa{\detokenize{#1}}% + \if\relax\nuc@tempa\relax + \nuc@emptyargerr + \else + \edef\@tempb{\expandafter\@car\nuc@tempa\@nil}% + \nuc@check + \if@tempswa + \@namedef{u8:\nuc@tempa}{#2}% + \fi + \fi + } + \makeatother + \doxynewunicodechar{⁻}{${}^{-}$}% Superscript minus + \doxynewunicodechar{²}{${}^{2}$}% Superscript two + \doxynewunicodechar{³}{${}^{3}$}% Superscript three + +\pagestyle{empty} +\begin{document} +$\dtp$ +\pagebreak + +$c_{\sbc}\colon\edges\to\posreals$ +\pagebreak + +\[ + c_{\sbc} := \frac{1}{m_B}\sum_{\source\in\vertices}\sum_{\sink\in\vertices\setminus\{\source\}} \frac{\sigma_{\dtp}(\source,\sink,\edge)}{\sigma_{\dtp}(\source,\sink)}, + \] +\pagebreak + +$\sigma_{\dtp}(\source,\sink,\edge)$ +\pagebreak + +$\dtp{s}$ +\pagebreak + +$\source$ +\pagebreak + +$\sink$ +\pagebreak + +$\edge$ +\pagebreak + +$\sigma_{\dtp}(\source,\sink)$ +\pagebreak + +$\dtp{\text{s}}$ +\pagebreak + +$m_B = |\vertices|\cdot(|\vertices|-1)$ +\pagebreak + +$\SBC$ +\pagebreak + +$\sbc$ +\pagebreak + +$m_B = |V|\cdot (|V|-1)$ +\pagebreak + +$\graph = (\vertices,\edges)$ +\pagebreak + +$\labels(\vertex)$ +\pagebreak + +$\vertex$ +\pagebreak + +$\labelu$ +\pagebreak + +$\labelu_{\mathrm{new}}$ +\pagebreak + +$\queue$ +\pagebreak + +$\labelu_{p}$ +\pagebreak + +$\labelu_p$ +\pagebreak + +$\vertex\in\vertices$ +\pagebreak + +$\Theta(1)$ +\pagebreak + +$\Theta(\log n)$ +\pagebreak + +$\Theta(n)$ +\pagebreak + +$n = |\vertices|$ +\pagebreak + +$m = |\edges|$ +\pagebreak + +$O(|\vertices|)$ +\pagebreak + +$O(1)$ +\pagebreak + +$(\vertexa, + \vertexb)$ +\pagebreak + +$\vertexa$ +\pagebreak + +$(\vertexa,\vertexb)$ +\pagebreak + +$\vertexb$ +\pagebreak + +$(\vertexa, \vertexb)$ +\pagebreak + +$\edges$ +\pagebreak + +$m-1$ +\pagebreak + +$\graph$ +\pagebreak + +$ r = x = b = 0 $ +\pagebreak + +$ tap = |V(source)|/|V(target)|) $ +\pagebreak + +$r / (r^2 + x^2)$ +\pagebreak + +$x / (r^2 + x^2)$ +\pagebreak + +$x /(r^2 + + x^2)$ +\pagebreak + +$1 / x$ +\pagebreak + +$\shuntsusceptance(\vertex)$ +\pagebreak + +$\shuntsusceptance\colon\vertices\to\reals$ +\pagebreak + +$\shuntconductance(\vertex)$ +\pagebreak + +$\shuntconductance\colon\vertices\to\reals$ +\pagebreak + +$\voltagenominal$ +\pagebreak + +$\vmagnitude$ +\pagebreak + +$\vangle(\vertex)$ +\pagebreak + +$\vangle\colon\vertices\to\reals$ +\pagebreak + +$\voltagemin$ +\pagebreak + +$\voltagemax$ +\pagebreak + +$\ac$ +\pagebreak + +$\dc$ +\pagebreak + +$\vmagnitude(\vertex)$ +\pagebreak + +$\voltage := [\voltagemin,\voltagemax]$ +\pagebreak + +$\realpowernominal$ +\pagebreak + +$\realpowernominalmin$ +\pagebreak + +$\realpowernominalmax$ +\pagebreak + +\[ + \realpowernominal := [\realpowernominalmin,\realpowernominalmax]. + \] +\pagebreak + +$\vertex\in\generators$ +\pagebreak + +$\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ +\pagebreak + +$\realpowergeneration$ +\pagebreak + +$[\realpowergenerationmin, \realpowergenerationmax]$ +\pagebreak + +$[\realpowergenerationmin, + \realpowergenerationmax]$ +\pagebreak + +$\reactivepowergeneration$ +\pagebreak + +$[\reactivepowergenerationmin, \reactivepowergenerationmax]$ +\pagebreak + +$[\reactivepowergenerationmin,\reactivepowergenerationmax]$ +\pagebreak + +$\realpowernominal\coloneqq[\realpowernominalmin, + \realpowernominalmax]$ +\pagebreak + +$[\realpowergenerationmin, + \realpowergenerationmax]$ +\pagebreak + +$[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ +\pagebreak + +$\realpowerdemand$ +\pagebreak + +$[\realpowerdemandmin, \realpowerdemandmax]$ +\pagebreak + +$\reactivepowerdemand$ +\pagebreak + +$[\reactivepowerdemandmin, \reactivepowerdemandmax]$ +\pagebreak + +$[\reactivepowerdemandmin, + \reactivepowerdemandmax]$ +\pagebreak + +$\graph = (\vertices, \edges)$ +\pagebreak + +$\vertices$ +\pagebreak + +$\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$ +\pagebreak + +$\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$ +\pagebreak + +\[ + \bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}, + \] +\pagebreak + +$\susceptance(\vertexa,\vertexb)\in\reals$ +\pagebreak + +$(\vertexa,\vertexb)\in\edges$ +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}}$ +\pagebreak + +$\fpath{}{\vertexa}{\vertexb}$ +\pagebreak + +\[ + \deltavangle(\vertexa,\vertexb) = \bnorm{\fpath{}{\vertexa}{\vertexb}} \cdot \fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}, + \] +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}$ +\pagebreak + +$\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }:= \min_{ (\vertexa,\vertexb)\in\pathu}\fcapacity{}{\vertexa}{\vertexb}$ +\pagebreak + +$\capacity\colon\edges\to\reals$ +\pagebreak + +$\bnorm{\fpath{}{\vertexa}{\vertexb}} = 0.0$ +\pagebreak + +$(0,\infty)$ +\pagebreak + +$\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }$ +\pagebreak + +$\fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}$ +\pagebreak + +$\vertexa\in\vertices$ +\pagebreak + +$\deltavangle(\vertexa,\vertexb)$ +\pagebreak + +$\realpowergeneration(\vertex)$ +\pagebreak + +$\network$ +\pagebreak + +\[ + -\maxdemand\leq\netflow(\vertexa)\leq-\mindemand\qquad\forall\vertexa\in\consumers + \] +\pagebreak + +\[ + \maxexcess\leq\netflow(\vertexa)\leq \minexcess\qquad\forall\vertexa\in\generators + \] +\pagebreak + +\[ + -\infty\leq\netflow(\vertexa)\leq 0\qquad\forall\vertexa\in\consumers + \] +\pagebreak + +\[ + 0\leq\netflow(\vertexa)\leq\infty\qquad\forall\vertexa\in\generators + \] +\pagebreak + +\[ + -\demand(\vertexa)\leq\netflow(\vertexa)\leq -\demand(\vertexa)\qquad\forall\vertexa\in\consumers, + \] +\pagebreak + +\[ + \excess(\vertexa)\leq\netflow(\vertexa)\leq\excess(\vertexa)\qquad\forall\vertexa\in\generators, + \] +\pagebreak + +$\netflow:=\sum_{ \{ \vertexa,\vertexb \} \in \undirectededges } \flow ( \vertexa,\vertexb ) $ +\pagebreak + +$\generators$ +\pagebreak + +$\consumers$ +\pagebreak + +$g\in\generators$ +\pagebreak + +$\emptyset$ +\pagebreak + +$\{\vertex\}\cap\generators = \emptyset$ +\pagebreak + +$\realpowergenerationmin$ +\pagebreak + +$\realpowergenerationmax$ +\pagebreak + +$[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ +\pagebreak + +$\reactivepowergenerationmin$ +\pagebreak + +$\reactivepowergenerationmax$ +\pagebreak + +$ \frac{R}{|Z|} $ +\pagebreak + +$ |Z| = R^2 + X^2 $ +\pagebreak + +$ \frac{X}{|Z|} $ +\pagebreak + +$ \frac{angle^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$ \pi = 180^\circ $ +\pagebreak + +$ ratio\cdot\cos\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $ +\pagebreak + +$ ratio\cdot\sin\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $ +\pagebreak + +$ \frac{angmin^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$ \frac{angmax^\circ\cdot\pi}{180^\circ} $ +\pagebreak + +$\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$ +\pagebreak + +$\graph = (\vertices, \edges_{\mathrm{cand}})$ +\pagebreak + +$ \network $ +\pagebreak + +$\network $ +\pagebreak + +$\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$ +\pagebreak + +$\graph $ +\pagebreak + +\end{document} diff --git a/_generation_strategy_8hpp_source.html b/_generation_strategy_8hpp_source.html new file mode 100644 index 00000000..875b5382 --- /dev/null +++ b/_generation_strategy_8hpp_source.html @@ -0,0 +1,179 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Networks/GenerationStrategy.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GenerationStrategy.hpp
+
+
+
1/*
+
2 * GenerationStrategy.hpp
+
3 *
+
4 * Created on: Jan 13, 2020
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATASTRUCTURES__NETWORKS__GENERATION_STRATEGY_HPP
+
9#define EGOA__DATASTRUCTURES__NETWORKS__GENERATION_STRATEGY_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12#include "Exceptions/Assertions.hpp"
+
13
+
14namespace egoa::internal {
+
15
+
25template<typename NetworkType, Vertices::GenerationStrategyDifferentiationType GenerationType>
+
26class GenerationStrategyDifferentiation;
+
27
+
39template<typename NetworkType>
+
+
40class GenerationStrategyDifferentiation<NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot> {
+
41
+
42 using TNetwork = NetworkType;
+
43 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
44
+
45 public:
+
46
+
49#pragma mark TOTAL_VERTEX_REAL_POWER_GENERATION_PER_SNAPSHOT_STRATEGY
+
62 inline static
+
+
63 Types::real TotalRealPowerGenerationAt ( TNetwork const & network
+
64 , Types::vertexId vertexId
+
65 , Types::index timestampPosition = 0 )
+
66 {
+
67 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
68
+
69 Types::real pg ( 0.0 );
+
70 if ( network.HasGeneratorAt ( vertexId ) )
+
71 {
+
72 network.template for_all_generators_at <ExecutionPolicy::sequential> ( vertexId,
+
73 [ &network, &pg, &timestampPosition ]( TGeneratorProperties const & generator )
+
74 {
+
75 if ( generator.IsActive() )
+
76 {
+
77 pg += network.GeneratorRealPowerSnapshotAt ( generator, timestampPosition );
+
78 }
+
79 }
+
80 );
+
81 }
+
82 return pg;
+
83 }
+
+
85
+
88#pragma mark TOTAL_VERTEX_REACTIVE_POWER_GENERATION_PER_SNAPSHOT_STRATEGY
+
89
+
108 inline static
+
+
109 Types::real TotalReactivePowerGenerationAt ( TNetwork const & network
+
110 , Types::vertexId vertexId
+
111 , Types::index timestampPosition = 0 )
+
112 {
+
113 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
114
+
115 Types::real qg( 0.0 );
+
116 if ( network.HasGeneratorAt( vertexId ) )
+
117 {
+
118 network.template for_all_generators_at <ExecutionPolicy::sequential> ( vertexId,
+
119 [&network, &qg, &timestampPosition ]( TGeneratorProperties const & generator )
+
120 {
+
121 if ( generator.IsActive() )
+
122 {
+
123 qg += network.GeneratorReactivePowerSnapshotAt ( generator
+
124 , timestampPosition );
+
125 }
+
126 }
+
127 );
+
128 }
+
129 return qg;
+
130 }
+
+
132};
+
+
133
+
134} // namespace egoa::internal
+
135
+
136#endif // EGOA__DATASTRUCTURES__NETWORKS__GENERATION_STRATEGY_HPP
+
egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalRealPowerGenerationAt
static Types::real TotalRealPowerGenerationAt(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)
Total real power generation at a vertex with vertex identifier vertexId.
Definition GenerationStrategy.hpp:63
+
egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalReactivePowerGenerationAt
static Types::real TotalReactivePowerGenerationAt(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)
The total reactive power generation of all generator snapshots for one timestamp at vertex with ide...
Definition GenerationStrategy.hpp:109
+
egoa::internal::GenerationStrategyDifferentiation
This base class to differentiate between different generation strategy.
Definition GenerationStrategy.hpp:26
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_generator_based_betweenness_centrality_8hpp_source.html b/_generator_based_betweenness_centrality_8hpp_source.html new file mode 100644 index 00000000..9178b733 --- /dev/null +++ b/_generator_based_betweenness_centrality_8hpp_source.html @@ -0,0 +1,206 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/Centralities/GeneratorBasedBetweennessCentrality.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GeneratorBasedBetweennessCentrality.hpp
+
+
+
1/*
+
2 * GeneratorBasedBetweennessCentrality.hpp
+
3 *
+
4 * Created on: Feb 26, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__CENTRALITY__GENERATOR_BASED__BETWEENNESS_CENTRALITY_HPP
+
9#define EGOA__ALGORITHMS__CENTRALITY__GENERATOR_BASED__BETWEENNESS_CENTRALITY_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif // OPENMP_AVAILABLE
+
14
+
15#include "Algorithms/PathFinding/DominatingThetaPath.hpp"
+
16#include "Algorithms/Centralities/BetweennessCentrality.hpp"
+
17#include "IO/Statistics/DtpRuntimeCollection.hpp"
+
18
+
19namespace egoa {
+
20
+
59template< typename NetworkType = PowerGrid< StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>
+
60 , Edges::ElectricalProperties >
+
61 , Vertices::GeneratorProperties<>
+
62 , Vertices::LoadProperties<Vertices::IeeeBusType> >
+
63 , typename PathFindingAlgorithm = DominatingThetaPath<typename NetworkType::TGraph>
+
64 , typename MeasurementCollection = IO::DtpRuntimeCollection
+
65 , CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges >
+
66class GeneratorBasedBetweennessCentrality final : public BetweennessCentrality < typename NetworkType::TGraph
+
67 , PathFindingAlgorithm
+
68 , MeasurementCollection
+
69 , CentralityCounterType >
+
70{
+
71 public:
+
72#pragma mark TYPE_ALIASING
+
73 // Graph specific types
+
74 using TNetwork = NetworkType;
+
75 using TBetweennessCentrality = BetweennessCentrality < typename TNetwork::TGraph
+
76 , PathFindingAlgorithm
+
77 , MeasurementCollection
+
78 , CentralityCounterType >;
+
79 using TGeneratorId = Types::generatorId;
+
80 private:
+
81 using typename TBetweennessCentrality::TNumberOfPaths;
+
82 using typename TBetweennessCentrality::TRelativeNumberOfPaths;
+
83 public:
+
86#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
87 GeneratorBasedBetweennessCentrality ( TNetwork const & network )
+
88 : TBetweennessCentrality( network.Graph() )
+
89 , network_( network )
+
90 {}
+
91
+
95 ~GeneratorBasedBetweennessCentrality () {}
+
96
+
98
+
101#pragma mark EXECUTE_ALGORITHM
+
102
+
113 inline void Run ()
+
114 {
+
115 TNumberOfPaths numberOfPaths;
+
116 TRelativeNumberOfPaths relativeNumberOfPaths;
+
117
+
118 this->Clear ( numberOfPaths, relativeNumberOfPaths );
+
119
+
120 network_.template for_all_vertex_identifiers_with_generator<ExecutionPolicy::parallel> ( [
+
121 this
+
122 , & numberOfPaths
+
123 , & relativeNumberOfPaths ] ( TGeneratorId vertexId )
+
124 {
+
125#ifdef OPENMP_AVAILABLE
+
126 this->Algorithm()[omp_get_thread_num()].Clear();
+
127 this->Algorithm()[omp_get_thread_num()].Source( vertexId );
+
128 this->Algorithm()[omp_get_thread_num()].Run();
+
129 this->Algorithm()[omp_get_thread_num()].NumberOfLabels();
+
130 this->TotalNumberOfPaths( numberOfPaths, relativeNumberOfPaths );
+
131
+
132#ifdef EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY // COLLECT RUNTIME INFORMATION
+
133 #pragma omp critical
+
134 { // More information concerning standard container
+
135 // concurrency under "Thread safety":
+
136 // https://en.cppreference.com/w/cpp/container
+
137 this->Algorithm()[omp_get_thread_num()].Statistic().NumberOfGenerators = network_.NumberOfGenerators();
+
138 this->Algorithm()[omp_get_thread_num()].Statistic().NumberOfLoads = network_.NumberOfLoads();
+
139 this->Collection() += this->Algorithm()[omp_get_thread_num()].Statistic();
+
140 }
+
141#endif // EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
142
+
143// ################################################################################
+
144// ################################################################################
+
145// ################################################################################
+
146
+
147#else // OPENMP IS NOT AVAILABLE
+
148
+
149 this->Algorithm().Clear();
+
150 this->Algorithm().Source ( vertexId );
+
151 this->Algorithm().Run();
+
152 this->TotalNumberOfPaths ( numberOfPaths, relativeNumberOfPaths );
+
153
+
154#ifdef EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
155 this->Collection() += this->Algorithm().Statistic();
+
156#endif // EGOA_ENABLE_STATISTIC_BETWEENNESS_CENTRALITY
+
157#endif // OPENMP_AVAILABLE
+
158 });
+
159 this->JoinThreadBasedResults ( numberOfPaths
+
160 , relativeNumberOfPaths
+
161 , 1 / static_cast<Types::real>( network_.NumberOfGenerators() * network_.NumberOfLoads() ) );
+
162 }
+
164
+
165#pragma mark MEMBERS
+
166 private:
+
167 TNetwork const & network_;
+
168};
+
169
+
170} // egoa
+
171
+
172#endif // EGOA__ALGORITHMS__CENTRALITY__GENERATOR_BASED__BETWEENNESS_CENTRALITY_HPP
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_generator_properties_8hpp_source.html b/_generator_properties_8hpp_source.html new file mode 100644 index 00000000..cb21ef72 --- /dev/null +++ b/_generator_properties_8hpp_source.html @@ -0,0 +1,1213 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices/GeneratorProperties.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GeneratorProperties.hpp
+
+
+
1/*
+
2 * GeneratorProperties.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__VERTICES__GENERATOR_PROPERTIES_HPP
+
9#define EGOA__DATA_STRUCTURES__VERTICES__GENERATOR_PROPERTIES_HPP
+
10
+
11#include <iostream>
+
12#include <iomanip>
+
13
+
14#include "Type.hpp"
+
15#include "Auxiliary/Auxiliary.hpp"
+
16#include "Auxiliary/Constants.hpp"
+
17#include "DataStructures/Bound.hpp"
+
18
+
19namespace egoa::Vertices {
+
20
+
27template<class VertexType = Vertices::IeeeBusType>
+
+
28class GeneratorProperties {
+
29 public:
+
32 using TBound = Bound<Types::real>;
+
34
+
37 using TVertexType = VertexType;
+
38 using TControlType = Vertices::ControlType;
+
39 using TGeneratorType = Vertices::GeneratorType;
+
40 using TBusStatus = Vertices::BusStatus;
+
41 using TPowerSign = Vertices::PowerSign;
+
43
+
44 public:
+
47#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
48
+
49 GeneratorProperties ()
+
50 : name_("")
+
51 , type_(TVertexType::generator)
+
52 , xCoordinate_(0.0)
+
53 , yCoordinate_(0.0)
+
54 // voltage
+
55 , voltageMagnitudeSnapshot_(1.0)
+
56 // nominal power
+
57 , nominalPower_(1.0)
+
58 , pNomExtendable_(false)
+
59 , nominalRealPowerBound_( TBound(0.0, Const::REAL_INFTY ) )
+
60 , sign_(TPowerSign::positive)
+
61 // real power
+
62 , realPower_(0.0)
+
63 , realPowerBound_( TBound(0.0, Const::REAL_INFTY) )
+
64 , pc1_(0.0)
+
65 , pc2_(0.0)
+
66 // reactive power
+
67 , reactivePower_(0.0)
+
68 , reactivePowerBound_( TBound(0.0, Const::REAL_INFTY) )
+
69 , qc1Bound_( TBound(0.0, 0.0) )
+
70 , qc2Bound_( TBound(0.0, 0.0) )
+
71 // status
+
72 , status_(TBusStatus::active)
+
73 , committable_(false)
+
74 // types
+
75 , control_( TControlType::PQ )
+
76 , generatorType_(TGeneratorType::unknown)
+
77 , efficiency_(1.0)
+
78 // cost specific information
+
79 , marginalCost_(0.0)
+
80 , capitalCost_(0.0)
+
81 , startUpCost_(0.0)
+
82 , shutDownCost_(0.0)
+
83 // ramp information
+
84 , minUpTime_(0.0)
+
85 , minDownTime_(0.0)
+
86 , rampAgc_(0.0)
+
87 , ramp10_(0.0)
+
88 , ramp30_(0.0)
+
89 , rampQ_(0.0)
+
90 , apf_(0.0)
+
91 , rampLimitUp_(Const::REAL_INFTY)
+
92 , rampLimitDown_(Const::REAL_INFTY)
+
93 , rampLimitStartUp_(1.0)
+
94 , rampLimitShutDown_(1.0)
+
95 {}
+
96
+
+
100 inline void Reset ()
+
101 {
+
102 // BasicVertex specifics
+
103 Name () = "";
+
104 Type () = TVertexType::unknown;
+
105 X () = 0.0;
+
106 Y () = 0.0;
+
107 // voltage
+
108 VoltageMagnitude() = 1.0;
+
109 // nominal power
+
110 NominalPower() = 1.0;
+
111 IsExtendable() = false;
+
112 NominalRealPowerBound() = TBound(0.0, Const::REAL_INFTY );
+
113 PowerSign() = TPowerSign::positive;
+
114 // real power
+
115 RealPower() = 0.0;
+
116 RealPowerBound() = TBound(0.0, Const::REAL_INFTY); //1.o?
+
117 Pc1() = 0.0;
+
118 Pc2() = 0.0;
+
119 // reactive power
+
120 ReactivePower() = 0.0;
+
121 ReactivePowerBound() = TBound(0.0, Const::REAL_INFTY);
+
122 Qc1Bound() = TBound(0.0, 0.0);
+
123 Qc2Bound() = TBound(0.0, 0.0);
+
124 // status
+
125 Status() = TBusStatus::active;
+
126 Committable() = false;
+
127 // types
+
128 Control() = TControlType::PQ;
+
129 GeneratorType() = TGeneratorType::unknown;
+
130 Efficiency() = 1.0;
+
131 // cost specific information
+
132 MarginalCost() = 0.0;
+
133 CapitalCost() = 0.0;
+
134 StartUpCost() = 0.0;
+
135 ShutDownCost() = 0.0;
+
136 // ramp information
+
137 MinimumUpTime() = 0.0;
+
138 MinimumDownTime() = 0.0;
+
139 RampAgc() = 0.0;
+
140 Ramp10() = 0.0;
+
141 Ramp30() = 0.0;
+
142 RampQ() = 0.0;
+
143 Apf() = 0.0;
+
144 RampLimitUp() = Const::REAL_INFTY;
+
145 RampLimitDown() = Const::REAL_INFTY;
+
146 RampLimitStartUp() = 1.0;
+
147 RampLimitShutDown() = 1.0;
+
148 }
+
+
150
+
153#pragma mark COMPARATORS
+
154
+
+
163 inline bool operator!=( GeneratorProperties const & rhs ) const
+
164 {
+
165 return !(this == rhs);
+
166 }
+
+
167
+
+
176 inline bool operator==( GeneratorProperties const & rhs ) const
+
177 {
+
178 // Basic Vertex
+
179 if ( Name() != rhs.Name() ) return false;
+
180 if ( X() != rhs.X() ) return false;
+
181 if ( Y() != rhs.Y() ) return false;
+
182 if ( Type() != rhs.Type() ) return false;
+
183
+
184 // Voltage specific information
+
185 if ( !Auxiliary::EQ ( VoltageMagnitude(), rhs.VoltageMagnitude() ) ) return false;
+
186
+
187 // Nominal power specific information
+
188 if ( NominalPower() != rhs.NominalPower() ) return false;
+
189 if ( IsExtendable() != rhs.IsExtendable() ) return false;
+
190 if ( NominalRealPowerBound().Minimum() != rhs.NominalRealPowerBound().Minimum() ) return false;
+
191 if ( NominalRealPowerBound().Maximum() != rhs.NominalRealPowerBound().Maximum() ) return false;
+
192 if ( PowerSign() != rhs.PowerSign() ) return false;
+
193
+
194 // Real power specific information
+
195 if ( !Auxiliary::EQ ( RealPower(), rhs.RealPower() ) ) return false;
+
196 if ( !Auxiliary::EQ ( RealPowerBound().Maximum(), rhs.RealPowerBound().Maximum()) ) return false;
+
197 if ( !Auxiliary::EQ ( RealPowerBound().Minimum(), rhs.RealPowerBound().Minimum()) ) return false;
+
198 if ( !Auxiliary::EQ ( Pc1(), rhs.Pc1() ) ) return false;
+
199 if ( !Auxiliary::EQ ( Pc2(), rhs.Pc2() ) ) return false;
+
200
+
201 // Reactive power specific information
+
202 if ( !Auxiliary::EQ( ReactivePower(), rhs.ReactivePower() ) ) return false;
+
203 if ( !Auxiliary::EQ( ReactivePowerBound().Minimum(),rhs.ReactivePowerBound().Minimum() ) ) return false;
+
204 if ( !Auxiliary::EQ( ReactivePowerBound().Maximum(),rhs.ReactivePowerBound().Maximum() ) ) return false;
+
205 if ( !Auxiliary::EQ( Qc1Bound().Minimum(), rhs.Qc1Bound().Minimum() ) ) return false;
+
206 if ( !Auxiliary::EQ( Qc1Bound().Maximum(), rhs.Qc1Bound().Maximum() ) ) return false;
+
207 if ( !Auxiliary::EQ( Qc2Bound().Minimum(), rhs.Qc2Bound().Minimum() ) ) return false;
+
208 if ( !Auxiliary::EQ( Qc2Bound().Maximum(), rhs.Qc2Bound().Maximum() ) ) return false;
+
209
+
210 // Status specific information
+
211 if ( Status() != rhs.Status() ) return false;
+
212 if ( Committable() != rhs.Committable() ) return false;
+
213
+
214 // Type specific information
+
215 if ( Control() != rhs.Control() ) return false;
+
216 if ( GeneratorType() != rhs.GeneratorType() ) return false;
+
217 if ( !Auxiliary::EQ ( Efficiency(), rhs.Efficiency() ) ) return false;
+
218
+
219 // Cost specific information
+
220 if ( !Auxiliary::EQ( MarginalCost(), rhs.MarginalCost() ) ) return false;
+
221 if ( !Auxiliary::EQ( CapitalCost(), rhs.CapitalCost() ) ) return false;
+
222 if ( !Auxiliary::EQ( StartUpCost(), rhs.StartUpCost() ) ) return false;
+
223 if ( !Auxiliary::EQ( ShutDownCost(), rhs.ShutDownCost() ) ) return false;
+
224
+
225 // Ramp specific information
+
226 if ( !Auxiliary::EQ( MinimumUpTime(), rhs.MinimumUpTime() ) ) return false;
+
227 if ( !Auxiliary::EQ( MinimumDownTime(), rhs.MinimumDownTime() ) ) return false;
+
228 if ( !Auxiliary::EQ( RampAgc(), rhs.RampAgc() ) ) return false;
+
229 if ( !Auxiliary::EQ( Ramp10(), rhs.Ramp10() ) ) return false;
+
230 if ( !Auxiliary::EQ( Ramp30(), rhs.Ramp30() ) ) return false;
+
231 if ( !Auxiliary::EQ( RampQ(), rhs.RampQ() ) ) return false;
+
232 if ( !Auxiliary::EQ( Apf(), rhs.Apf() ) ) return false;
+
233 if ( !Auxiliary::EQ( RampLimitUp(), rhs.RampLimitUp() ) ) return false;
+
234 if ( !Auxiliary::EQ( RampLimitDown(), rhs.RampLimitDown() ) ) return false;
+
235 if ( !Auxiliary::EQ( RampLimitStartUp(), rhs.RampLimitStartUp() ) ) return false;
+
236 if ( !Auxiliary::EQ( RampLimitShutDown(), rhs.RampLimitShutDown() ) ) return false;
+
237
+
238 return true;
+
239 }
+
+
241
+
+
248 friend void swap ( GeneratorProperties & lhs
+
249 , GeneratorProperties & rhs )
+
250 { // Necessary for the copy and swap idiom
+
251 using std::swap; // enable ADL
+
252 // Basic vertex
+
253 swap( lhs.name_, rhs.name_ );
+
254 swap( lhs.type_, rhs.type_ );
+
255 swap( lhs.xCoordinate_, rhs.xCoordinate_);
+
256 swap( lhs.yCoordinate_, rhs.yCoordinate_);
+
257
+
258 // Voltage specific information
+
259 swap( lhs.voltageMagnitudeSnapshot_,rhs.voltageMagnitudeSnapshot_);
+
260
+
261 // Nominal power specific information
+
262 swap( lhs.nominalPower_, rhs.nominalPower_);
+
263 swap( lhs.pNomExtendable_, rhs.pNomExtendable_);
+
264 swap( lhs.nominalRealPowerBound_, rhs.nominalRealPowerBound_);
+
265 swap( lhs.sign_, rhs.sign_);
+
266
+
267 // Real power specific information
+
268 swap( lhs.realPower_, rhs.realPower_);
+
269 swap( lhs.realPowerBound_, rhs.realPowerBound_);
+
270 swap( lhs.pc1_, rhs.pc1_);
+
271 swap( lhs.pc2_, rhs.pc2_);
+
272
+
273 // Reactive power specific information
+
274 swap( lhs.reactivePower_, rhs.reactivePower_);
+
275 swap( lhs.reactivePowerBound_, rhs.reactivePowerBound_);
+
276 swap( lhs.qc1Bound_, rhs.qc1Bound_);
+
277 swap( lhs.qc2Bound_, rhs.qc2Bound_);
+
278
+
279 // Status specific information
+
280 swap( lhs.status_, rhs.status_);
+
281 swap( lhs.committable_, rhs.committable_);
+
282
+
283 // Type specific information
+
284 swap( lhs.control_, rhs.control_);
+
285 swap( lhs.type_, rhs.type_);
+
286 swap( lhs.efficiency_, rhs.efficiency_);
+
287
+
288 // Cost specific information
+
289 swap( lhs.marginalCost_, rhs.marginalCost_);
+
290 swap( lhs.capitalCost_, rhs.capitalCost_);
+
291 swap( lhs.startUpCost_, rhs.startUpCost_);
+
292 swap( lhs.shutDownCost_, rhs.shutDownCost_);
+
293
+
294 // Ramp specific information
+
295 swap( lhs.minUpTime_, rhs.minUpTime_);
+
296 swap( lhs.minDownTime_, rhs.minDownTime_);
+
297 swap( lhs.rampAgc_, rhs.rampAgc_);
+
298 swap( lhs.ramp10_, rhs.ramp10_);
+
299 swap( lhs.ramp30_, rhs.ramp30_);
+
300 swap( lhs.rampQ_, rhs.rampQ_);
+
301 swap( lhs.apf_, rhs.apf_);
+
302 swap( lhs.rampLimitUp_, rhs.rampLimitUp_);
+
303 swap( lhs.rampLimitDown_, rhs.rampLimitDown_);
+
304 swap( lhs.rampLimitStartUp_, rhs.rampLimitStartUp_);
+
305 swap( lhs.rampLimitShutDown_, rhs.rampLimitShutDown_);
+
306 }
+
+
307
+
310#pragma mark BASIC_PROPERTIES
+
311
+
312 inline Types::name Name() const { return name_; }
+
313 inline Types::name & Name() { return name_; }
+
314
+
315 inline TVertexType Type() const { return type_; }
+
316 inline TVertexType & Type() { return type_; }
+
317
+
318 inline Types::real X() const { return xCoordinate_; }
+
319 inline Types::real & X() { return xCoordinate_; }
+
320
+
321 inline Types::real Y() const { return yCoordinate_; }
+
322 inline Types::real & Y() { return yCoordinate_; }
+
324
+
327#pragma mark VOLTAGE
+
328
+
+
336 inline Types::real VoltageMagnitude () const
+
337 {
+
338 return voltageMagnitudeSnapshot_;
+
339 }
+
+
340
+
+
348 inline Types::real & VoltageMagnitude ()
+
349 {
+
350 return voltageMagnitudeSnapshot_;
+
351 }
+
+
353
+
356#pragma mark NOMINAL_POWER
+
357
+
+
391 inline bool IsExtendable() const
+
392 {
+
393 return pNomExtendable_;
+
394 }
+
+
395
+
+
433 inline bool & IsExtendable ()
+
434 {
+
435 return pNomExtendable_;
+
436 }
+
+
437
+
+
460 inline Types::real NominalPower () const
+
461 {
+
462 return nominalPower_;
+
463 }
+
+
464
+
+
485 inline Types::real & NominalPower ()
+
486 {
+
487 return nominalPower_;
+
488 }
+
+
489
+
+
517 inline TBound NominalRealPowerBound () const
+
518 {
+
519 return nominalRealPowerBound_;
+
520 }
+
+
521
+
+
547 inline TBound & NominalRealPowerBound ()
+
548 {
+
549 return nominalRealPowerBound_;
+
550 }
+
+
551
+
+
560 inline TPowerSign PowerSign () const
+
561 {
+
562 return sign_;
+
563 }
+
+
564
+
+
573 inline TPowerSign & PowerSign ()
+
574 {
+
575 return sign_;
+
576 }
+
+
578
+
581#pragma mark REAL_POWER_INFORMATION
+
582
+
+
588 inline Types::real RealPower () const
+
589 {
+
590 return realPower_;
+
591 }
+
+
592
+
+
599 inline Types::real & RealPower ()
+
600 {
+
601 return realPower_;
+
602 }
+
+
603
+
+
611 inline TBound RealPowerBound () const
+
612 {
+
613 return realPowerBound_;
+
614 }
+
+
615
+
+
623 inline TBound & RealPowerBound ()
+
624 {
+
625 return realPowerBound_;
+
626 }
+
+
627
+
+
635 inline Types::real Pc1 () const
+
636 {
+
637 return pc1_;
+
638 }
+
+
639
+
+
647 inline Types::real & Pc1 ()
+
648 {
+
649 return pc1_;
+
650 }
+
+
651
+
+
659 inline Types::real Pc2 () const
+
660 {
+
661 return pc2_;
+
662 }
+
+
663
+
+
671 inline Types::real & Pc2 ()
+
672 {
+
673 return pc2_;
+
674 }
+
+
676
+
679#pragma mark REACTIVE_POWER_INFORMATION
+
680
+
+
687 inline Types::real ReactivePower () const
+
688 {
+
689 return reactivePower_;
+
690 }
+
+
691
+
+
698 inline Types::real & ReactivePower ()
+
699 {
+
700 return reactivePower_;
+
701 }
+
+
702
+
+
710 inline TBound ReactivePowerBound () const
+
711 {
+
712 return reactivePowerBound_;
+
713 }
+
+
714
+
+
722 inline TBound & ReactivePowerBound ()
+
723 {
+
724 return reactivePowerBound_;
+
725 }
+
+
726
+
+
734 inline TBound Qc1Bound () const
+
735 {
+
736 return qc1Bound_;
+
737 }
+
+
738
+
+
746 inline TBound & Qc1Bound ()
+
747 {
+
748 return qc1Bound_;
+
749 }
+
+
750
+
+
758 inline TBound Qc2Bound () const
+
759 {
+
760 return qc2Bound_;
+
761 }
+
+
762
+
+
770 inline TBound & Qc2Bound ()
+
771 {
+
772 return qc2Bound_;
+
773 }
+
+
775
+
778#pragma mark STATUS_INFORMATION
+
779
+
+
787 inline bool IsActive () const
+
788 {
+
789 if ( TBusStatus::active == Status() )
+
790 return true;
+
791 else
+
792 return false;
+
793 }
+
+
794
+
+
805 inline TBusStatus Status () const
+
806 {
+
807 return status_;
+
808 }
+
+
809
+
+
820 inline TBusStatus & Status ()
+
821 {
+
822 return status_;
+
823 }
+
+
824
+
+
833 inline bool Committable () const
+
834 {
+
835 return committable_;
+
836 }
+
+
837
+
+
846 inline bool & Committable ()
+
847 {
+
848 return committable_;
+
849 }
+
+
851
+
854#pragma mark TYPE_INFORMATION
+
855
+
+
867 inline Vertices::ControlType Control () const
+
868 {
+
869 return control_;
+
870 }
+
+
871
+
+
883 inline Vertices::ControlType & Control ()
+
884 {
+
885 return control_;
+
886 }
+
+
887
+
+
897 inline Vertices::GeneratorType GeneratorType () const
+
898 {
+
899 return generatorType_;
+
900 }
+
+
901
+
+
911 inline Vertices::GeneratorType & GeneratorType ()
+
912 {
+
913 return generatorType_;
+
914 }
+
+
915
+
+
923 inline Types::real Efficiency () const
+
924 {
+
925 return efficiency_;
+
926 }
+
+
927
+
+
936 inline Types::real & Efficiency ()
+
937 {
+
938 return efficiency_;
+
939 }
+
+
941
+
944#pragma mark COST_SPECIFIC_INFOMRATION
+
945
+
+
952 inline Types::real MarginalCost () const
+
953 {
+
954 return marginalCost_;
+
955 }
+
+
956
+
+
963 inline Types::real & MarginalCost ()
+
964 {
+
965 return marginalCost_;
+
966 }
+
+
967
+
+
975 inline Types::real CapitalCost () const
+
976 {
+
977 return capitalCost_;
+
978 }
+
+
979
+
+
987 inline Types::real & CapitalCost ()
+
988 {
+
989 return capitalCost_;
+
990 }
+
+
991
+
+
999 inline Types::real StartUpCost () const
+
1000 {
+
1001 return startUpCost_;
+
1002 }
+
+
1003
+
+
1012 inline Types::real & StartUpCost ()
+
1013 {
+
1014 return startUpCost_;
+
1015 }
+
+
1016
+
+
1024 inline Types::real ShutDownCost () const
+
1025 {
+
1026 return shutDownCost_;
+
1027 }
+
+
1028
+
+
1037 inline Types::real & ShutDownCost ()
+
1038 {
+
1039 return shutDownCost_;
+
1040 }
+
+
1042
+
1056#pragma mark RAMP_SPECIFIC_INFORMATION
+
1057
+
+
1069 inline Types::real MinimumUpTime () const
+
1070 {
+
1071 return minUpTime_;
+
1072 }
+
+
1073
+
+
1086 inline Types::real & MinimumUpTime ()
+
1087 {
+
1088 return minUpTime_;
+
1089 }
+
+
1090
+
+
1102 inline Types::real MinimumDownTime () const
+
1103 {
+
1104 return minDownTime_;
+
1105 }
+
+
1106
+
+
1119 inline Types::real & MinimumDownTime ()
+
1120 {
+
1121 return minDownTime_;
+
1122 }
+
+
1123
+
+
1133 inline Types::real RampAgc () const
+
1134 {
+
1135 return rampAgc_;
+
1136 }
+
+
1137
+
+
1148 inline Types::real & RampAgc ()
+
1149 {
+
1150 return rampAgc_;
+
1151 }
+
+
1152
+
+
1160 inline Types::real Ramp10 () const
+
1161 {
+
1162 return ramp10_;
+
1163 }
+
+
1164
+
+
1173 inline Types::real & Ramp10 ()
+
1174 {
+
1175 return ramp10_;
+
1176 }
+
+
1177
+
+
1185 inline Types::real Ramp30 () const
+
1186 {
+
1187 return ramp30_;
+
1188 }
+
+
1189
+
+
1198 inline Types::real & Ramp30 ()
+
1199 {
+
1200 return ramp30_;
+
1201 }
+
+
1202
+
+
1211 inline Types::real RampQ () const
+
1212 {
+
1213 return rampQ_;
+
1214 }
+
+
1215
+
+
1224 inline Types::real & RampQ ()
+
1225 {
+
1226 return rampQ_;
+
1227 }
+
+
1228
+
+
1234 inline Types::real Apf () const
+
1235 {
+
1236 return apf_;
+
1237 }
+
+
1238
+
+
1245 inline Types::real & Apf ()
+
1246 {
+
1247 return apf_;
+
1248 }
+
+
1249
+
+
1259 inline Types::real RampLimitUp () const
+
1260 {
+
1261 return rampLimitUp_;
+
1262 }
+
+
1263
+
+
1273 inline Types::real & RampLimitUp ()
+
1274 {
+
1275 return rampLimitUp_;
+
1276 }
+
+
1277
+
+
1287 inline Types::real RampLimitDown () const
+
1288 {
+
1289 return rampLimitDown_;
+
1290 }
+
+
1291
+
+
1301 inline Types::real & RampLimitDown ()
+
1302 {
+
1303 return rampLimitDown_;
+
1304 }
+
+
1305
+
+
1315 inline Types::real RampLimitStartUp () const
+
1316 {
+
1317 return rampLimitStartUp_;
+
1318 }
+
+
1319
+
+
1330 inline Types::real & RampLimitStartUp ()
+
1331 {
+
1332 return rampLimitStartUp_;
+
1333 }
+
+
1334
+
+
1344 inline Types::real RampLimitShutDown () const
+
1345 {
+
1346 return rampLimitShutDown_;
+
1347 }
+
+
1348
+
+
1359 inline Types::real & RampLimitShutDown ()
+
1360 {
+
1361 return rampLimitShutDown_;
+
1362 }
+
+
1364
+
1367#pragma mark OUTPUT_METHODS
+
+
1376 friend std::ostream & operator<< ( std::ostream & outputStream
+
1377 , GeneratorProperties const & rhs )
+
1378 {
+
1379 outputStream << std::setprecision(2)
+
1380 << std::fixed
+
1381 << std::endl
+
1382 << "Generator at Bus " << rhs.Name() << std::endl
+
1383 << "-------------------" << std::endl
+
1384 << std::setw(30) << "bus: " << std::setw(10) << rhs.Name()
+
1385 << std::setw(20) << "generation: " << std::setw(10) << rhs.RealPower() << std::setw(25) << " p.u. (real, MW), "
+
1386 << std::setw(10) << rhs.ReactivePower() << std::setw(25) << " p.u. (reactive, MVar), " << std::endl
+
1387 << std::setw(20) << "real power bound: " << std::setw(10) << rhs.RealPowerBound().Minimum() << std::setw(25) << " p.u. (pmin, MW), "
+
1388 << std::setw(10) << rhs.RealPowerBound().Maximum() << std::setw(25) << " p.u. (pmax, MW), " << std::endl
+
1389 << std::setw(20) << "reactive power bound: "<< std::setw(10) << rhs.ReactivePowerBound().Minimum()<< std::setw(25) << " p.u. (qmin, MVar), "
+
1390 << std::setw(10) << rhs.ReactivePowerBound().Maximum()<< std::setw(25) << " p.u. (qmax, MVar), " << std::endl
+
1391 << std::setw(20) << "voltage magnitude: " << std::setw(10) << rhs.VoltageMagnitude() << std::setw(25) << " (Vm, V), " << std::endl
+
1392 << std::setw(20) << "status: " << std::setw(10) << rhs.IsActive() << std::setw(25) << "" << std::endl;
+
1393 return outputStream;
+
1394 }
+
+
1395
+
+
1402 static inline void Header ( std::ostream & outputStream)
+
1403 {
+
1404 outputStream << std::setw(20) << "bus"
+
1405 << std::setw(10) << "Pg"
+
1406 << std::setw(10) << "Qg"
+
1407 << std::setw(10) << "Qmax"
+
1408 << std::setw(10) << "Qmin"
+
1409 << std::setw(10) << "Vg"
+
1410 << std::setw(10) << "mBase"
+
1411 << std::setw(10) << "status"
+
1412 << std::setw(10) << "Pmax"
+
1413 << std::setw(10) << "Pmin"
+
1414 << std::setw(6) << "Pc1"
+
1415 << std::setw(6) << "Pc2"
+
1416 << std::setw(8) << "Qc1min"
+
1417 << std::setw(8) << "Qc1max"
+
1418 << std::setw(8) << "Qc2min"
+
1419 << std::setw(8) << "Qc2max"
+
1420 << std::setw(9) << "ramp_agc"
+
1421 << std::setw(8) << "ramp_10"
+
1422 << std::setw(8) << "ramp_30"
+
1423 << std::setw(8) << "ramp_q"
+
1424 << std::setw(6) << "apf"
+
1425 << std::endl;
+
1426 }
+
+
1427
+
1428 static inline void HeaderBusGeneratorName ( std::ostream & outputStream)
+
1429 {
+
1430 outputStream << std::setw(20) << "bus"
+
1431 << std::setw(20) << "name"
+
1432 << std::setw(10) << "Pg"
+
1433 << std::setw(10) << "Qg"
+
1434 << std::setw(10) << "Qmax"
+
1435 << std::setw(10) << "Qmin"
+
1436 << std::setw(10) << "Vg"
+
1437 << std::setw(10) << "mBase"
+
1438 << std::setw(10) << "status"
+
1439 << std::setw(10) << "Pmax"
+
1440 << std::setw(10) << "Pmin"
+
1441 << std::setw(6) << "Pc1"
+
1442 << std::setw(6) << "Pc2"
+
1443 << std::setw(8) << "Qc1min"
+
1444 << std::setw(8) << "Qc1max"
+
1445 << std::setw(8) << "Qc2min"
+
1446 << std::setw(8) << "Qc2max"
+
1447 << std::setw(9) << "ramp_agc"
+
1448 << std::setw(8) << "ramp_10"
+
1449 << std::setw(8) << "ramp_30"
+
1450 << std::setw(8) << "ramp_q"
+
1451 << std::setw(6) << "apf"
+
1452 << std::endl;
+
1453 }
+
1454
+
+
1462 inline void Line ( std::ostream & outputStream
+
1463 , Types::real baseMva = 1 ) const
+
1464 {
+
1465 outputStream << std::setprecision(2)
+
1466 << std::fixed
+
1467 << std::setw(20) << Name()
+
1468 << std::setw(10) << RealPower() * baseMva
+
1469 << std::setw(10) << ReactivePower() * baseMva
+
1470 << std::setw(10) << ReactivePowerBound().Maximum() * baseMva
+
1471 << std::setw(10) << ReactivePowerBound().Minimum() * baseMva
+
1472 << std::setw(10) << VoltageMagnitude()
+
1473 << std::setw(10) << NominalPower()
+
1474 << std::setw(10) << IsActive()
+
1475 << std::setw(10) << RealPowerBound().Maximum() * baseMva
+
1476 << std::setw(10) << RealPowerBound().Minimum() * baseMva
+
1477 << std::setw(6) << Pc1()
+
1478 << std::setw(6) << Pc2()
+
1479 << std::setw(8) << Qc1Bound().Minimum()
+
1480 << std::setw(8) << Qc1Bound().Maximum()
+
1481 << std::setw(8) << Qc2Bound().Minimum()
+
1482 << std::setw(8) << Qc2Bound().Maximum()
+
1483 << std::setw(9) << RampAgc()
+
1484 << std::setw(8) << Ramp10()
+
1485 << std::setw(8) << Ramp30()
+
1486 << std::setw(8) << RampQ()
+
1487 << std::setw(6) << Apf()
+
1488 << std::endl;
+
1489 }
+
+
1490
+
+
1499 inline void Line ( std::ostream & outputStream
+
1500 , Types::vertexId identifier
+
1501 , Types::real baseMva = 1 ) const
+
1502 {
+
1503 outputStream << std::setprecision(2)
+
1504 << std::fixed
+
1505 << std::setw(6) << identifier
+
1506 << std::setw(10) << RealPower() * baseMva
+
1507 << std::setw(10) << ReactivePower() * baseMva
+
1508 << std::setw(10) << ReactivePowerBound().Maximum() * baseMva
+
1509 << std::setw(10) << ReactivePowerBound().Minimum() * baseMva
+
1510 << std::setw(10) << VoltageMagnitude()
+
1511 << std::setw(10) << NominalPower()
+
1512 << std::setw(10) << IsActive()
+
1513 << std::setw(10) << RealPowerBound().Maximum() * baseMva
+
1514 << std::setw(10) << RealPowerBound().Minimum() * baseMva
+
1515 << std::setw(6) << Pc1()
+
1516 << std::setw(6) << Pc2()
+
1517 << std::setw(8) << Qc1Bound().Minimum()
+
1518 << std::setw(8) << Qc1Bound().Maximum()
+
1519 << std::setw(8) << Qc2Bound().Minimum()
+
1520 << std::setw(8) << Qc2Bound().Maximum()
+
1521 << std::setw(9) << RampAgc()
+
1522 << std::setw(8) << Ramp10()
+
1523 << std::setw(8) << Ramp30()
+
1524 << std::setw(8) << RampQ()
+
1525 << std::setw(6) << Apf()
+
1526 << std::endl;
+
1527 }
+
+
1528
+
+
1537 inline void Line ( std::ostream & outputStream
+
1538 , Types::name busName
+
1539 , Types::real baseMva = 1 ) const
+
1540 {
+
1541 outputStream << std::setprecision(2)
+
1542 << std::fixed
+
1543 << std::setw(20) << busName
+
1544 << std::setw(20) << Name()
+
1545 << std::setw(10) << RealPower() * baseMva
+
1546 << std::setw(10) << ReactivePower() * baseMva
+
1547 << std::setw(10) << ReactivePowerBound().Maximum() * baseMva
+
1548 << std::setw(10) << ReactivePowerBound().Minimum() * baseMva
+
1549 << std::setw(10) << VoltageMagnitude()
+
1550 << std::setw(10) << NominalPower()
+
1551 << std::setw(10) << IsActive()
+
1552 << std::setw(10) << RealPowerBound().Maximum() * baseMva
+
1553 << std::setw(10) << RealPowerBound().Minimum() * baseMva
+
1554 << std::setw(6) << Pc1()
+
1555 << std::setw(6) << Pc2()
+
1556 << std::setw(8) << Qc1Bound().Minimum()
+
1557 << std::setw(8) << Qc1Bound().Maximum()
+
1558 << std::setw(8) << Qc2Bound().Minimum()
+
1559 << std::setw(8) << Qc2Bound().Maximum()
+
1560 << std::setw(9) << RampAgc()
+
1561 << std::setw(8) << Ramp10()
+
1562 << std::setw(8) << Ramp30()
+
1563 << std::setw(8) << RampQ()
+
1564 << std::setw(6) << Apf()
+
1565 << std::endl;
+
1566 }
+
+
1568
+
1569 private:
+
1570#pragma mark MEMBERS
+
1573 Types::name name_;
+
1574 TVertexType type_;
+
1575 Types::real xCoordinate_;
+
1576 Types::real yCoordinate_;
+
1578
+
1581 Types::real voltageMagnitudeSnapshot_;
+
1585
+
1588 Types::real nominalPower_;
+
1591 bool pNomExtendable_;
+
1600 TBound nominalRealPowerBound_;
+
1605 TPowerSign sign_;
+
1607
+
1610 Types::real realPower_;
+
1613 TBound realPowerBound_;
+
1616 Types::real pc1_;
+
1619 Types::real pc2_;
+
1623
+
1626 Types::real reactivePower_;
+
1629 TBound reactivePowerBound_;
+
1632 TBound qc1Bound_;
+
1633 TBound qc2Bound_;
+
1635
+
1638 TBusStatus status_;
+
1639 bool committable_;
+
1643
+
1646 TControlType control_;
+
1649 TGeneratorType generatorType_;
+
1650 Types::real efficiency_;
+
1654
+
1657 Types::real marginalCost_;
+
1658 Types::real capitalCost_;
+
1660 Types::real startUpCost_;
+
1661 Types::real shutDownCost_;
+
1663
+
1676 Types::real minUpTime_;
+
1677 Types::real minDownTime_;
+
1679 Types::real rampAgc_;
+
1680 Types::real ramp10_;
+
1681 Types::real ramp30_;
+
1682 Types::real rampQ_;
+
1683 Types::real apf_;
+
1685 Types::real rampLimitUp_;
+
1686 Types::real rampLimitDown_;
+
1687 Types::real rampLimitStartUp_;
+
1688 Types::real rampLimitShutDown_;
+
1690
+
1691
+
1692 // Types::real MU_P_BOUND /**< in u/MW, Kuhn-Tucker multiplier on lower/upper P_g limit (MU_PMIN / MU_PMAX) */
+
1693 // Types::real MU_QMAX /**< in u/MVAr, Kuhn-Tucker multiplier on lower/upper Q_g limit (MU_QMIN / MU_QMAX) */
+
1694};
+
+
1695
+
1696} // namespace egoa
+
1697
+
1698#endif // EGOA__DATA_STRUCTURES__VERTICES__GENERATOR_PROPERTIES_HPP
+ +
egoa::Bound::Minimum
TBound Minimum() const
Getter of the minimum of the bound.
Definition Bound.hpp:61
+
egoa::Bound::Maximum
TBound Maximum() const
Getter of the maximum of the bound.
Definition Bound.hpp:85
+
egoa::Vertices::GeneratorProperties
Class having all generator properties.
Definition GeneratorProperties.hpp:28
+
egoa::Vertices::GeneratorProperties::Qc1Bound
TBound Qc1Bound() const
Getter for the reactive power output bound at PC1.
Definition GeneratorProperties.hpp:734
+ + + +
egoa::Vertices::GeneratorProperties::RealPowerBound
TBound RealPowerBound() const
Getter for the real power bound .
Definition GeneratorProperties.hpp:611
+
egoa::Vertices::GeneratorProperties::NominalPower
Types::real NominalPower() const
Getter for the nominal power base.
Definition GeneratorProperties.hpp:460
+ +
egoa::Vertices::GeneratorProperties::Ramp30
Types::real Ramp30() const
Getter for the ramp rate for a 30 minute reserve.
Definition GeneratorProperties.hpp:1185
+
egoa::Vertices::GeneratorProperties::VoltageMagnitude
Types::real VoltageMagnitude() const
Getter for the voltage magnitude setpoint in per unit (p.u.) of the nominal voltage.
Definition GeneratorProperties.hpp:336
+
egoa::Vertices::GeneratorProperties::MinimumDownTime
Types::real MinimumDownTime() const
Getter for the minimum time to be inactive.
Definition GeneratorProperties.hpp:1102
+
egoa::Vertices::GeneratorProperties::NominalRealPowerBound
TBound & NominalRealPowerBound()
Getter and setter for the nominal real power bound with while the generator is extendable.
Definition GeneratorProperties.hpp:547
+
egoa::Vertices::GeneratorProperties::Committable
bool & Committable()
Getter and setter for the unit commitment.
Definition GeneratorProperties.hpp:846
+
egoa::Vertices::GeneratorProperties::ShutDownCost
Types::real ShutDownCost() const
Getter for the shutdown costs for the generator.
Definition GeneratorProperties.hpp:1024
+
egoa::Vertices::GeneratorProperties::GeneratorType
Vertices::GeneratorType & GeneratorType()
Getter and setter for the generator type.
Definition GeneratorProperties.hpp:911
+ +
egoa::Vertices::GeneratorProperties::MarginalCost
Types::real MarginalCost() const
Getter for the marginal cost.
Definition GeneratorProperties.hpp:952
+
egoa::Vertices::GeneratorProperties::ReactivePower
Types::real & ReactivePower()
Getter and setter for the reactive power .
Definition GeneratorProperties.hpp:698
+
egoa::Vertices::GeneratorProperties::RampAgc
Types::real & RampAgc()
Getter and setter for the ramp rate for load following AGC.
Definition GeneratorProperties.hpp:1148
+ +
egoa::Vertices::GeneratorProperties::Apf
Types::real & Apf()
Getter and setter for the area participation factor (APF).
Definition GeneratorProperties.hpp:1245
+
egoa::Vertices::GeneratorProperties::Ramp10
Types::real Ramp10() const
Getter for the ramp rate for a 10 minute reserve.
Definition GeneratorProperties.hpp:1160
+
egoa::Vertices::GeneratorProperties::ReactivePowerBound
TBound & ReactivePowerBound()
Getter and setter for the reactive power bound .
Definition GeneratorProperties.hpp:722
+ + + + +
egoa::Vertices::GeneratorProperties::RealPower
Types::real & RealPower()
Getter and setter for the real power set point .
Definition GeneratorProperties.hpp:599
+ + +
egoa::Vertices::GeneratorProperties::Header
static void Header(std::ostream &outputStream)
Write the header to the output stream.
Definition GeneratorProperties.hpp:1402
+
egoa::Vertices::GeneratorProperties::PowerSign
TPowerSign & PowerSign()
Getter for the power sign.
Definition GeneratorProperties.hpp:573
+
egoa::Vertices::GeneratorProperties::Apf
Types::real Apf() const
Getter for the area participation factor (APF).
Definition GeneratorProperties.hpp:1234
+
egoa::Vertices::GeneratorProperties::Pc1
Types::real & Pc1()
Getter and setter for the lower real power output of PQ capability curve (MW) at PC1.
Definition GeneratorProperties.hpp:647
+
egoa::Vertices::GeneratorProperties::Reset
void Reset()
Reset to default values.
Definition GeneratorProperties.hpp:100
+
egoa::Vertices::GeneratorProperties::Committable
bool Committable() const
Getter for the unit commitment.
Definition GeneratorProperties.hpp:833
+
egoa::Vertices::GeneratorProperties::RampAgc
Types::real RampAgc() const
Getter for the ramp rate for load following AGC.
Definition GeneratorProperties.hpp:1133
+
egoa::Vertices::GeneratorProperties::Line
void Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const
Writes the values including the identifier of the generator property.
Definition GeneratorProperties.hpp:1499
+
egoa::Vertices::GeneratorProperties::MinimumUpTime
Types::real & MinimumUpTime()
Getter and setter for the minimum availability (active) time.
Definition GeneratorProperties.hpp:1086
+
egoa::Vertices::GeneratorProperties::RampLimitShutDown
Types::real RampLimitShutDown() const
Getter for the maximum decrease in power at shut-down.
Definition GeneratorProperties.hpp:1344
+ +
egoa::Vertices::GeneratorProperties::StartUpCost
Types::real StartUpCost() const
Getter for the startup costs for the generator.
Definition GeneratorProperties.hpp:999
+
egoa::Vertices::GeneratorProperties::IsExtendable
bool IsExtendable() const
Determines if the generator is extendable (used for production expansion).
Definition GeneratorProperties.hpp:391
+ +
egoa::Vertices::GeneratorProperties::operator!=
bool operator!=(GeneratorProperties const &rhs) const
Inequality comparator of two generator properties.
Definition GeneratorProperties.hpp:163
+
egoa::Vertices::GeneratorProperties::CapitalCost
Types::real CapitalCost() const
Getter for the capital cost.
Definition GeneratorProperties.hpp:975
+
egoa::Vertices::GeneratorProperties::RampLimitUp
Types::real RampLimitUp() const
Getter for the maximum increase in power.
Definition GeneratorProperties.hpp:1259
+
egoa::Vertices::GeneratorProperties::RampQ
Types::real RampQ() const
Getter for the ramp rate for the reactive power (2 sec timescale).
Definition GeneratorProperties.hpp:1211
+
egoa::Vertices::GeneratorProperties::VoltageMagnitude
Types::real & VoltageMagnitude()
Getter and setter for the voltage magnitude setpoint in per unit (p.u.) of the nominal voltage.
Definition GeneratorProperties.hpp:348
+
egoa::Vertices::GeneratorProperties::Qc1Bound
TBound & Qc1Bound()
Getter and setter for the reactive power output bound at PC1.
Definition GeneratorProperties.hpp:746
+ +
egoa::Vertices::GeneratorProperties::NominalRealPowerBound
TBound NominalRealPowerBound() const
Getter for the nominal real power bound with while the generator is extendable.
Definition GeneratorProperties.hpp:517
+ +
egoa::Vertices::GeneratorProperties::ShutDownCost
Types::real & ShutDownCost()
Getter and setter for the shutdown costs for the generator.
Definition GeneratorProperties.hpp:1037
+
egoa::Vertices::GeneratorProperties::Pc1
Types::real Pc1() const
Getter for the lower real power output of PQ capability curve (MW) at PC1.
Definition GeneratorProperties.hpp:635
+ + +
egoa::Vertices::GeneratorProperties::IsExtendable
bool & IsExtendable()
Setter and determines if the generator is extendable (used for production expansion).
Definition GeneratorProperties.hpp:433
+ +
egoa::Vertices::GeneratorProperties::RampLimitDown
Types::real & RampLimitDown()
Getter and setter for the maximum decrease in power.
Definition GeneratorProperties.hpp:1301
+
egoa::Vertices::GeneratorProperties::NominalPower
Types::real & NominalPower()
Getter and setter for the nominal power base.
Definition GeneratorProperties.hpp:485
+
egoa::Vertices::GeneratorProperties::GeneratorType
Vertices::GeneratorType GeneratorType() const
Getter for the generator type.
Definition GeneratorProperties.hpp:897
+ +
egoa::Vertices::GeneratorProperties::operator==
bool operator==(GeneratorProperties const &rhs) const
Comparison of two generator properties.
Definition GeneratorProperties.hpp:176
+
egoa::Vertices::GeneratorProperties::operator<<
friend std::ostream & operator<<(std::ostream &outputStream, GeneratorProperties const &rhs)
Writes the generator property to an output stream.
Definition GeneratorProperties.hpp:1376
+
egoa::Vertices::GeneratorProperties::RampLimitShutDown
Types::real & RampLimitShutDown()
Getter and setter for the maximum decrease in power at shut-down.
Definition GeneratorProperties.hpp:1359
+ +
egoa::Vertices::GeneratorProperties::PowerSign
TPowerSign PowerSign() const
Getter for the power sign.
Definition GeneratorProperties.hpp:560
+ +
egoa::Vertices::GeneratorProperties::RampQ
Types::real & RampQ()
Getter and setter for the ramp rate for the reactive power (2 sec timescale).
Definition GeneratorProperties.hpp:1224
+
egoa::Vertices::GeneratorProperties::Efficiency
Types::real Efficiency() const
Getter for the efficiency of the generator.
Definition GeneratorProperties.hpp:923
+
egoa::Vertices::GeneratorProperties::MinimumUpTime
Types::real MinimumUpTime() const
Getter for the minimum availability (active) time.
Definition GeneratorProperties.hpp:1069
+
egoa::Vertices::GeneratorProperties::Status
TBusStatus Status() const
Status of the electrical vertex.
Definition GeneratorProperties.hpp:805
+
egoa::Vertices::GeneratorProperties::Line
void Line(std::ostream &outputStream, Types::name busName, Types::real baseMva=1) const
Writes the values including the name of the generator property.
Definition GeneratorProperties.hpp:1537
+
egoa::Vertices::GeneratorProperties::RampLimitDown
Types::real RampLimitDown() const
Getter for the maximum decrease in power.
Definition GeneratorProperties.hpp:1287
+
egoa::Vertices::GeneratorProperties::ReactivePowerBound
TBound ReactivePowerBound() const
Getter for the reactive power bound .
Definition GeneratorProperties.hpp:710
+
egoa::Vertices::GeneratorProperties::Control
Vertices::ControlType & Control()
Getter and setter for the control strategy.
Definition GeneratorProperties.hpp:883
+ + +
egoa::Vertices::GeneratorProperties::swap
friend void swap(GeneratorProperties &lhs, GeneratorProperties &rhs)
Swapping the members of two generator properties.
Definition GeneratorProperties.hpp:248
+
egoa::Vertices::GeneratorProperties::IsActive
bool IsActive() const
Determines if the electrical vertex is active.
Definition GeneratorProperties.hpp:787
+ + +
egoa::Vertices::GeneratorProperties::Ramp30
Types::real & Ramp30()
Getter and setter for the ramp rate for a 30 minute reserve.
Definition GeneratorProperties.hpp:1198
+ + +
egoa::Vertices::GeneratorProperties::RealPowerBound
TBound & RealPowerBound()
Getter and setter for the real power bound .
Definition GeneratorProperties.hpp:623
+
egoa::Vertices::GeneratorProperties::CapitalCost
Types::real & CapitalCost()
Getter and setter for the capital cost.
Definition GeneratorProperties.hpp:987
+
egoa::Vertices::GeneratorProperties::StartUpCost
Types::real & StartUpCost()
Getter and setter for the startup costs for the generator.
Definition GeneratorProperties.hpp:1012
+
egoa::Vertices::GeneratorProperties::Line
void Line(std::ostream &outputStream, Types::real baseMva=1) const
Write the values of the generator property.
Definition GeneratorProperties.hpp:1462
+ + +
egoa::Vertices::GeneratorProperties::MinimumDownTime
Types::real & MinimumDownTime()
Getter and setter for the minimum time to be inactive.
Definition GeneratorProperties.hpp:1119
+
egoa::Vertices::GeneratorProperties::RampLimitUp
Types::real & RampLimitUp()
Getter and setter for the maximum increase in power.
Definition GeneratorProperties.hpp:1273
+ +
egoa::Vertices::GeneratorProperties::RealPower
Types::real RealPower() const
Getter for the real power .
Definition GeneratorProperties.hpp:588
+
egoa::Vertices::GeneratorProperties::Qc2Bound
TBound & Qc2Bound()
Getter and setter for the reactive power output bound at PC2.
Definition GeneratorProperties.hpp:770
+
egoa::Vertices::GeneratorProperties::Pc2
Types::real Pc2() const
Getter for the upper real power output of PQ capability curve (MW) at PC2.
Definition GeneratorProperties.hpp:659
+
egoa::Vertices::GeneratorProperties::MarginalCost
Types::real & MarginalCost()
Getter and setter for the marginal cost.
Definition GeneratorProperties.hpp:963
+
egoa::Vertices::GeneratorProperties::Efficiency
Types::real & Efficiency()
Getter and setter for the efficiency of the generator.
Definition GeneratorProperties.hpp:936
+
egoa::Vertices::GeneratorProperties::RampLimitStartUp
Types::real & RampLimitStartUp()
Getter and setter for the maximum increase in power at start-up.
Definition GeneratorProperties.hpp:1330
+ + +
egoa::Vertices::GeneratorProperties::Qc2Bound
TBound Qc2Bound() const
Getter for the reactive power output bound at PC2.
Definition GeneratorProperties.hpp:758
+
egoa::Vertices::GeneratorProperties::RampLimitStartUp
Types::real RampLimitStartUp() const
Getter for the maximum increase in power at startup.
Definition GeneratorProperties.hpp:1315
+
egoa::Vertices::GeneratorProperties::Status
TBusStatus & Status()
Status of the electrical vertex.
Definition GeneratorProperties.hpp:820
+
egoa::Vertices::GeneratorProperties::Control
Vertices::ControlType Control() const
Getter for the control strategy.
Definition GeneratorProperties.hpp:867
+
egoa::Vertices::GeneratorProperties::Ramp10
Types::real & Ramp10()
Getter and setter for the ramp rate for a 10 minute reserve.
Definition GeneratorProperties.hpp:1173
+ +
egoa::Vertices::GeneratorProperties::ReactivePower
Types::real ReactivePower() const
Getter for the reactive power .
Definition GeneratorProperties.hpp:687
+
egoa::Vertices::GeneratorProperties::Pc2
Types::real & Pc2()
Getter and setter for the upper real power output of PQ capability curve (MW) at PC2.
Definition GeneratorProperties.hpp:671
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_geojson_writer_8hpp_source.html b/_geojson_writer_8hpp_source.html new file mode 100644 index 00000000..0f330713 --- /dev/null +++ b/_geojson_writer_8hpp_source.html @@ -0,0 +1,688 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Writer/GeojsonWriter.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GeojsonWriter.hpp
+
+
+
1/*
+
2 * GeojsonWriter.hpp
+
3 *
+
4 * Created on: Nov 02, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__GEOJSON_WRITER_HPP
+
9#define EGOA__IO__GEOJSON_WRITER_HPP
+
10
+
11#include "DataStructures/Networks/PowerGrid.hpp"
+
12
+
13#include "DataStructures/Graphs/StaticGraph.hpp"
+
14
+
15#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
16#include "DataStructures/Graphs/Vertices/GeneratorProperties.hpp"
+
17#include "DataStructures/Graphs/Vertices/LoadProperties.hpp"
+
18
+
19#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
20
+
21#include <fstream>
+
22
+
23namespace egoa::IO {
+
24
+
25template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>
+
26 , Edges::ElectricalProperties > >
+
+
27class GeoJsonWriter final {
+
28
+
29#pragma mark TEMPLATE_TYPE_ALIASING
+
30 // Template type aliasing
+
31 using TGraph = GraphType;
+
32 using TNetwork = PowerGrid<GraphType>;
+
33 // Vertices
+
34 using TVertex = typename TGraph::TVertex;
+
35 using TVertexProperties = typename TGraph::TVertexProperties;
+
36 using TVertexType = typename TVertexProperties::TVertexType;
+
37 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
38 using TLoadProperties = typename TNetwork::TLoadProperties;
+
39 // Edges
+
40 using TEdge = typename TGraph::TEdge;
+
41 using TEdgeProperties = typename TGraph::TEdgeProperties;
+
42
+
43 // Bounds
+
44 using TBound = Bound<>;
+
45
+
46 public:
+
47
+
50#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
51
+
+
59 explicit GeoJsonWriter ( Types::count indent = 4
+
60 , bool readable = true )
+
61 : indent_(indent)
+
62 , readable_(readable)
+
63 {}
+
+
64
+
65 ~GeoJsonWriter(){}
+
67
+
69#pragma mark GRAPH WRITER
+
70
+
+
79 inline bool WriteGraph ( std::ostream & os
+
80 , TGraph const & graph )
+
81 {
+
82 WriteHeader ( os );
+
83 WriteFeatureCollection ( os );
+
84 WriteFeaturesBegin ( os );
+
85 WriteVertices ( os, graph, false);
+
86 WriteLines ( os, graph, true );
+
87 WriteFeaturesEnd ( os, true );
+
88 WriteFooter ( os );
+
89 return true; // How do you declare success
+
90 }
+
+
92
+
93private:
+
96#pragma mark AUXILIARY
+
97
+
+
104 inline void Indent ( std::ostream & os
+
105 , Types::count depth = 1 )
+
106 {
+
107 if ( Readable() )
+
108 {
+
109 Types::string indent( static_cast<std::string::size_type>( depth * indent_ ), ' ' );
+
110 os << indent;
+
111 }
+
112 }
+
+
113
+
+
119 inline void NewLine ( std::ostream & os)
+
120 {
+
121 if ( Readable() )
+
122 {
+
123 os << std::endl;
+
124 }
+
125 }
+
+
126
+
+
134 inline bool Readable ()
+
135 {
+
136 return readable_;
+
137 }
+
+
139
+
142#pragma mark WRITER METHODS
+
143
+
+
149 inline void WriteHeader ( std::ostream & os )
+
150 {
+
151 os << "{";
+
152 NewLine(os);
+
153 }
+
+
154
+
+
161 inline void WriteFooter ( std::ostream & os
+
162 , Types::count indent = 0 )
+
163 {
+
164 Indent( os, indent );
+
165 os << "}";
+
166 NewLine(os);
+
167 }
+
+
168
+
+
175 inline void WriteFeatureBegin ( std::ostream & os
+
176 , Types::count indent = 1 )
+
177 {
+
178 Indent( os, indent );
+
179 os << "{";
+
180 NewLine(os);
+
181
+
182 Indent( os, indent + 1 );
+
183 os << "\"type\": \"Feature\",";
+
184 NewLine(os);
+
185 }
+
+
186
+
+
194 inline void WriteFeatureEnd ( std::ostream & os
+
195 , bool last = false
+
196 , Types::count indent = 1 )
+
197 {
+
198 char comma = last?' ':',';
+
199 Indent( os, indent );
+
200 os << "}"
+
201 << comma;
+
202 NewLine(os);
+
203 }
+
+
204
+
+
211 inline void WritePropertiesBegin ( std::ostream & os
+
212 , Types::count indent = 2 )
+
213 {
+
214 Indent( os, indent );
+
215 os << "\"properties\":"
+
216 << "{";
+
217 NewLine(os);
+
218 }
+
+
219
+
+
227 inline void WriteVertexProperties ( std::ostream & os
+
228 , TVertexProperties const & vertexProperty
+
229 , Types::count indent = 2 )
+
230 {
+
231 bool last = false;
+
232 /* Basic Property Members */
+
233 PropertyTemplate<Types::name> ( os, "name", vertexProperty.Name(), last, indent );
+
234 PropertyTemplate<TVertexType> ( os, "type", vertexProperty.Type(), last, indent );
+
235 PropertyTemplate<Types::real> ( os, "xCoordinate", vertexProperty.X(), last, indent );
+
236 PropertyTemplate<Types::real> ( os, "yCoordinate", vertexProperty.Y(), last, indent );
+
237
+
238 /* Admittance Related Members */
+
239 PropertyTemplate<Types::real> ( os, "shuntConductance", vertexProperty.ShuntConductance(), last, indent );
+
240 PropertyTemplate<Types::real> ( os, "shuntSusceptance", vertexProperty.ShuntSusceptance(), last, indent );
+
241
+
242 /* Voltage Related Members */
+
243 PropertyTemplate<Types::real> ( os, "voltageMagnitude", vertexProperty.VoltageMagnitude(), last, indent );
+
244 PropertyTemplate<Types::real> ( os, "voltageAngle", vertexProperty.VoltageAngle(), last, indent );
+
245 PropertyTemplate<Types::real> ( os, "nominalVoltage", vertexProperty.NominalVoltage(), last, indent );
+
246 PropertyTemplate<Types::real> ( os, "maximumVoltage", vertexProperty.MaximumVoltage(), last, indent );
+
247 PropertyTemplate<Types::real> ( os, "minimumVoltage", vertexProperty.MinimumVoltage(), last, indent );
+
248
+
249 /* Location Specific Members */
+
250 PropertyTemplate<Types::name> ( os, "country", vertexProperty.Country(), last, indent );
+
251 PropertyTemplate<Types::index> ( os, "area", vertexProperty.Area(), last, indent );
+
252 PropertyTemplate<Types::index> ( os, "zone", vertexProperty.Zone(), last, indent );
+
253 PropertyTemplate<Vertices::ControlType> ( os, "control", vertexProperty.Control(), last, indent );
+
254 PropertyTemplate<Vertices::EnergyCarrier> ( os, "carrier", vertexProperty.Carrier(), last, indent );
+
255
+
256 /* Status Members */
+
257 last = true;
+
258 PropertyTemplate<Vertices::BusStatus> ( os, "status", vertexProperty.Status(), last, indent );
+
259 }
+
+
260
+
+
268 inline void WriteEdgeProperties ( std::ostream & os
+
269 , TEdgeProperties const & edgeProperty
+
270 , Types::count indent = 2 )
+
271 {
+
272 bool last = false;
+
273 /* Basic Property Members */
+
274 PropertyTemplate<Types::name> ( os, "name", edgeProperty.Name(), last, indent );
+
275 PropertyTemplate<bool> ( os, "status", edgeProperty.Status(), last, indent );
+
276 PropertyTemplate<Edges::ElectricalEdgeType> ( os, "type", edgeProperty.Type(), last, indent );
+
277 PropertyTemplate<Types::real> ( os, "minimumThetaBound", edgeProperty.ThetaBound().Minimum() / Const::PI * 180, last, indent );
+
278 PropertyTemplate<Types::real> ( os, "maximumThetaBound", edgeProperty.ThetaBound().Maximum() / Const::PI * 180, last, indent );
+
279
+
280 /* Branch impedance */
+
281 PropertyTemplate<Types::real> ( os, "resistance", edgeProperty.Resistance(), last, indent );
+
282 PropertyTemplate<Types::real> ( os, "reactance", edgeProperty.Reactance(), last, indent );
+
283
+
284 /* Voltage Related Members */
+
285 PropertyTemplate<Types::real> ( os, "conductance", edgeProperty.template Conductance<Edges::CarrierDifferentiationType::DC>(), last, indent );
+
286 PropertyTemplate<Types::real> ( os, "susceptance", edgeProperty.template Susceptance<Edges::CarrierDifferentiationType::DC>(), last, indent );
+
287 PropertyTemplate<Types::real> ( os, "charge", edgeProperty.Charge(), last, indent );
+
288
+
289 /* Line MVA ratings */
+
290 PropertyTemplate<Types::real> ( os, "thermalLimitA", edgeProperty.ThermalLimit(), last, indent );
+
291 PropertyTemplate<Types::real> ( os, "thermalLimitB", edgeProperty.ThermalLimitB(), last, indent );
+
292 PropertyTemplate<Types::real> ( os, "thermalLimitC", edgeProperty.ThermalLimitC(), last, indent );
+
293
+
294 /* Location Specific Members */
+
295 PropertyTemplate<Types::real> ( os, "tapRatio", edgeProperty.TapRatio(), last, indent );
+
296 PropertyTemplate<Types::real> ( os, "angleShift", edgeProperty.AngleShift(), last, indent );
+
297
+
298 /* Location Specific Members */
+
299 PropertyTemplate<Types::real> ( os, "capitalCost", edgeProperty.CapitalCost(), last, indent );
+
300 PropertyTemplate<Types::real> ( os, "length", edgeProperty.Length(), last, indent );
+
301 PropertyTemplate<Types::count> ( os, "numberOfParallelLines", edgeProperty.NumberOfParallelLines(), last, indent );
+
302 PropertyTemplate<Types::real> ( os, "nominalApparentPower", edgeProperty.NominalApparentPower(), last, indent );
+
303 PropertyTemplate<Types::real> ( os, "nominalVoltage", edgeProperty.NominalVoltage(), last, indent );
+
304 PropertyTemplate<Types::real> ( os, "minimumNominalApparentPowerBound", edgeProperty.NominalApparentPowerBound().Minimum(), last, indent );
+
305 PropertyTemplate<Types::real> ( os, "maximumNominalApparentPowerBound", edgeProperty.NominalApparentPowerBound().Maximum(), last, indent );
+
306 PropertyTemplate<bool> ( os, "nominalApparentPowerExtendable", edgeProperty.NominalApparentPowerExtendable(), last, indent );
+
307 last = true;
+
308 PropertyTemplate<Types::real> ( os, "terrainFactor", edgeProperty.TerrainFactor(), last, indent );
+
309 }
+
+
310
+
325 template<typename T>
+
+
326 inline void PropertyTemplate ( std::ostream & os
+
327 , std::string lhs
+
328 , T const & rhs
+
329 , bool last = false
+
330 , Types::count indent = 2)
+
331 {
+
332 std::string comma = last?" ":",";
+
333 Indent( os, indent );
+
334 os << "\""
+
335 << lhs
+
336 << "\": "
+
337 << "\""
+
338 << rhs
+
339 << "\""
+
340 << comma;
+
341 NewLine(os);
+
342 }
+
+
343
+
+
351 inline void WritePropertiesEnd ( std::ostream & os
+
352 , bool last = false
+
353 , Types::count indent = 2 )
+
354 {
+
355 std::string comma = last?" ":",";
+
356
+
357 Indent( os, indent );
+
358 os << "}"
+
359 << comma;
+
360 NewLine(os);
+
361 }
+
+
362
+
+
368 inline void WriteFeatureCollection ( std::ostream & os )
+
369 {
+
370 os << "\"type\": \"FeatureCollection\",";
+
371 NewLine(os);
+
372 }
+
+
373
+
+
379 inline void WriteFeaturesBegin ( std::ostream & os )
+
380 {
+
381 os << "\"features\": [";
+
382 NewLine(os);
+
383 }
+
+
384
+
+
392 inline void WriteFeaturesEnd ( std::ostream & os
+
393 , bool last = false
+
394 , Types::count indent = 0 )
+
395 {
+
396 char comma = last?' ':',';
+
397 Indent( os, indent );
+
398 os << "]"
+
399 << comma;
+
400 NewLine(os);
+
401 }
+
+
402
+
+
409 inline void WriteGeometry ( std::ostream & os
+
410 , Types::count indent = 2 )
+
411 {
+
412 Indent( os, indent );
+
413 os << "\"geometry\": ";
+
414 }
+
+
416
+
419#pragma mark POINT WRITER
+
420
+
+
429 inline void WriteVertices ( std::ostream & os
+
430 , TGraph const & graph
+
431 , bool last = false
+
432 , Types::count indent = 1 )
+
433 {
+
434 graph.for_all_vertices( [this, &os, &last, &indent]( TVertex const & vertex ){
+
435 WriteFeatureBegin ( os, indent );
+
436 WritePropertiesBegin ( os, indent + 1 );
+
437 WriteVertexProperties ( os, vertex.Properties(), indent + 2 );
+
438 WritePropertiesEnd ( os, false, indent + 1 );
+
439 WritePoint ( os, vertex, indent + 1 );
+
440 WriteFeatureEnd ( os, last, indent );
+
441 });
+
442 }
+
+
443
+
+
452 inline void WriteGenerators ( std::ostream & os
+
453 , TNetwork const & network
+
454 , bool last = false
+
455 , Types::count indent = 1 )
+
456 {
+
457 // network.for_all_generators( [this, &os, &last, &indent]( TGeneratorProperties const & generatorProperty ){
+
458 // WriteFeatureBegin ( os, indent );
+
459 // WritePropertiesBegin ( os, indent + 1 );
+
460 // WriteVertexProperties ( os, vertex.Properties(), indent + 2 );
+
461 // WritePropertiesEnd ( os, false, indent + 1 );
+
462 // WritePoint ( os, vertex, indent + 1 );
+
463 // WriteFeatureEnd ( os, last, indent );
+
464 // });
+
465 }
+
+
466
+
+
474 inline void WritePoint ( std::ostream & os
+
475 , Types::real xCoordinate
+
476 , Types::real yCoordinate
+
477 , Types::count indent = 2 )
+
478 {
+
479 WriteGeometry ( os, indent );
+
480 os << "{";
+
481 NewLine(os);
+
482
+
483 Indent( os, indent + 1 );
+
484 os << "\"type\": \"Point\",";
+
485 NewLine(os);
+
486
+
487 Indent( os, indent + 1 );
+
488 os << "\"coordinates\": ";
+
489 WritePointCoordinate ( os, xCoordinate, yCoordinate, 0 );
+
490 NewLine(os);
+
491 Indent( os, indent );
+
492 os << "}";
+
493 NewLine(os);
+
494 }
+
+
495
+
+
503 inline void WritePoint ( std::ostream & os
+
504 , TGraph const & graph
+
505 , Types::vertexId vertexId
+
506 , Types::count indent = 2 )
+
507 {
+
508 WritePoint ( os
+
509 , graph.VertexAt(vertexId).X()
+
510 , graph.VertexAt(vertexId).Y()
+
511 , indent );
+
512 }
+
+
513
+
+
520 inline void WritePoint ( std::ostream & os
+
521 , TVertex const & vertex
+
522 , Types::count indent = 2 )
+
523 {
+
524 WritePoint ( os
+
525 , vertex.Properties().X()
+
526 , vertex.Properties().Y()
+
527 , indent );
+
528 }
+
+
529
+
+
537 inline void WritePointCoordinate ( std::ostream & os
+
538 , Types::real xCoordinate
+
539 , Types::real yCoordinate
+
540 , Types::count indent = 2 )
+
541 {
+
542 Indent ( os, indent );
+
543 os << "["
+
544 << xCoordinate
+
545 << ","
+
546 << yCoordinate
+
547 << "]"
+
548 ;
+
549 }
+
+
550
+
+
558 inline void WritePointCoordinate ( std::ostream & os
+
559 , TGraph const & graph
+
560 , Types::vertexId vertexId )
+
561 {
+
562 WritePointCoordinate ( os
+
563 , graph.VertexAt(vertexId).X()
+
564 , graph.VertexAt(vertexId).Y() );
+
565 }
+
+
566
+
+
573 inline void WritePointCoordinate ( std::ostream & os
+
574 , TVertex const & vertex )
+
575 {
+
576 WritePointCoordinate ( os
+
577 , vertex.X()
+
578 , vertex.Y() );
+
579 }
+
+
581
+
584#pragma mark LINE WRITER
+
585
+
+
594 inline void WriteLines ( std::ostream & os
+
595 , TGraph const & graph
+
596 , bool last = false
+
597 , Types::count indent = 2 )
+
598 {
+
599 Types::count edgeCounter = 0;
+
600 graph.for_all_edges ( [this, &os, &graph, &last, &indent, &edgeCounter] (TEdge const & edge) {
+
601 WriteFeatureBegin ( os );
+
602 WritePropertiesBegin ( os );
+
603 WriteEdgeProperties ( os, edge.Properties(), indent + 2 );
+
604 WritePropertiesEnd ( os );
+
605 Types::vertexId source = edge.Source();
+
606 Types::vertexId target = edge.Target();
+
607 WriteLinesGeometryObject ( os, graph.VertexAt(source), graph.VertexAt(target), indent );
+
608 ( edgeCounter + 1 < graph.NumberOfEdges() )?last=false:last=true;
+
609 WriteFeatureEnd ( os, last );
+
610 ++edgeCounter;
+
611 });
+
612 // os << "," << std::endl;
+
613 }
+
+
614
+
+
622 inline void WriteLinesGeometryObject ( std::ostream & os
+
623 , TVertex const & sourceVertex
+
624 , TVertex const & targetVertex
+
625 , Types::count indent = 2 )
+
626 {
+
627 WriteGeometry ( os, indent );
+
628 WriteLineHeader ( os, indent + 1 );
+
629 WriteLineContent ( os, sourceVertex, targetVertex, indent + 2 );
+
630 WriteLineFooter ( os, indent );
+
631 }
+
+
632
+
+
639 inline void WriteLineHeader ( std::ostream & os
+
640 , Types::count indent = 3 )
+
641 {
+
642 os << "{";
+
643 NewLine(os);
+
644 Indent( os, indent );
+
645 os << "\"type\": \"LineString\",";
+
646 NewLine(os);
+
647 Indent( os, indent );
+
648 os << "\"coordinates\": [";
+
649 NewLine(os);
+
650 }
+
+
651
+
+
659 inline void WriteLineContent ( std::ostream & os
+
660 , TVertex const & sourceVertex
+
661 , TVertex const & targetVertex
+
662 , Types::count indent = 4 )
+
663 {
+
664 Indent( os, indent );
+
665 WritePointCoordinate ( os
+
666 , sourceVertex.Properties().X()
+
667 , sourceVertex.Properties().Y() );
+
668 os << ',';
+
669 NewLine(os);
+
670 Indent( os, indent );
+
671 WritePointCoordinate ( os
+
672 , targetVertex.Properties().X()
+
673 , targetVertex.Properties().Y() );
+
674 NewLine(os);
+
675 }
+
+
676
+
+
683 inline void WriteLineFooter ( std::ostream & os
+
684 , Types::count indent = 2 )
+
685 {
+
686 Indent( os, indent + 1 );
+
687 os << "]";
+
688 NewLine(os);
+
689 Indent( os, indent );
+
690 os << "}";
+
691 NewLine(os);
+
692 }
+
+
694
+
695 public:
+
697#pragma mark WRITER
+
+
706 bool write ( TNetwork const & network
+
707 , std::string const & filename )
+
708 {
+
709 std::ofstream file;
+
710 file.open(filename, std::ofstream::trunc);
+
711 if (!file.is_open()) return false;
+
712
+
713 // file is empty
+
714 file.seekp(0, std::ios::end);
+
715 return WriteGraph ( file, network.Graph() );
+
716 }
+
+
717
+
+
726 bool write ( TNetwork const & network
+
727 , std::ostream & outputStream )
+
728 {
+
729 return WriteGraph ( outputStream, network.Graph() );
+
730 }
+
+
732
+
733 private:
+
734 Types::count const indent_;
+
735 bool readable_;
+
736};
+
+
737
+
738} // namespace egoa::IO
+
739
+
740#endif // EGOA__IO__GEOJSON_WRITER_HPP
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+ +
egoa::IO::GeoJsonWriter::WriteEdgeProperties
void WriteEdgeProperties(std::ostream &os, TEdgeProperties const &edgeProperty, Types::count indent=2)
Writes edge properties.
Definition GeojsonWriter.hpp:268
+
egoa::IO::GeoJsonWriter::WriteHeader
void WriteHeader(std::ostream &os)
Writes a header.
Definition GeojsonWriter.hpp:149
+
egoa::IO::GeoJsonWriter::WritePointCoordinate
void WritePointCoordinate(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)
Writes a point coordinate.
Definition GeojsonWriter.hpp:537
+
egoa::IO::GeoJsonWriter::write
bool write(TNetwork const &network, std::string const &filename)
Write GeoJSON using the filename.
Definition GeojsonWriter.hpp:706
+
egoa::IO::GeoJsonWriter::WriteGeometry
void WriteGeometry(std::ostream &os, Types::count indent=2)
Writes a geometry.
Definition GeojsonWriter.hpp:409
+
egoa::IO::GeoJsonWriter::WriteFooter
void WriteFooter(std::ostream &os, Types::count indent=0)
Writes a footer.
Definition GeojsonWriter.hpp:161
+
egoa::IO::GeoJsonWriter::Indent
void Indent(std::ostream &os, Types::count depth=1)
Add indent to the output stream.
Definition GeojsonWriter.hpp:104
+
egoa::IO::GeoJsonWriter::WriteLineHeader
void WriteLineHeader(std::ostream &os, Types::count indent=3)
Writes a line header.
Definition GeojsonWriter.hpp:639
+
egoa::IO::GeoJsonWriter::WritePointCoordinate
void WritePointCoordinate(std::ostream &os, TGraph const &graph, Types::vertexId vertexId)
Writes a point coordinate.
Definition GeojsonWriter.hpp:558
+
egoa::IO::GeoJsonWriter::WriteLines
void WriteLines(std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=2)
Writes lines.
Definition GeojsonWriter.hpp:594
+
egoa::IO::GeoJsonWriter::NewLine
void NewLine(std::ostream &os)
Add new line to the output stream.
Definition GeojsonWriter.hpp:119
+
egoa::IO::GeoJsonWriter::WritePropertiesEnd
void WritePropertiesEnd(std::ostream &os, bool last=false, Types::count indent=2)
Writes a properties end.
Definition GeojsonWriter.hpp:351
+
egoa::IO::GeoJsonWriter::WriteVertices
void WriteVertices(std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=1)
Writes points.
Definition GeojsonWriter.hpp:429
+
egoa::IO::GeoJsonWriter::WriteFeaturesEnd
void WriteFeaturesEnd(std::ostream &os, bool last=false, Types::count indent=0)
Writes a features end.
Definition GeojsonWriter.hpp:392
+
egoa::IO::GeoJsonWriter::WritePropertiesBegin
void WritePropertiesBegin(std::ostream &os, Types::count indent=2)
Writes a properties begin.
Definition GeojsonWriter.hpp:211
+
egoa::IO::GeoJsonWriter::WriteLineFooter
void WriteLineFooter(std::ostream &os, Types::count indent=2)
Writes a line footer.
Definition GeojsonWriter.hpp:683
+
egoa::IO::GeoJsonWriter::WritePointCoordinate
void WritePointCoordinate(std::ostream &os, TVertex const &vertex)
Writes a point coordinate.
Definition GeojsonWriter.hpp:573
+
egoa::IO::GeoJsonWriter::WriteFeatureCollection
void WriteFeatureCollection(std::ostream &os)
Writes a feature collection.
Definition GeojsonWriter.hpp:368
+
egoa::IO::GeoJsonWriter::WriteFeatureBegin
void WriteFeatureBegin(std::ostream &os, Types::count indent=1)
Writes a feature begin.
Definition GeojsonWriter.hpp:175
+
egoa::IO::GeoJsonWriter::WritePoint
void WritePoint(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)
Writes a GeoJson point.
Definition GeojsonWriter.hpp:474
+
egoa::IO::GeoJsonWriter::WriteFeaturesBegin
void WriteFeaturesBegin(std::ostream &os)
Writes a features begin.
Definition GeojsonWriter.hpp:379
+
egoa::IO::GeoJsonWriter::WritePoint
void WritePoint(std::ostream &os, TGraph const &graph, Types::vertexId vertexId, Types::count indent=2)
Writes a GeoJson point.
Definition GeojsonWriter.hpp:503
+
egoa::IO::GeoJsonWriter::WritePoint
void WritePoint(std::ostream &os, TVertex const &vertex, Types::count indent=2)
Writes a GeoJson point.
Definition GeojsonWriter.hpp:520
+
egoa::IO::GeoJsonWriter::Readable
bool Readable()
Write a readable GeoJson.
Definition GeojsonWriter.hpp:134
+
egoa::IO::GeoJsonWriter::WriteVertexProperties
void WriteVertexProperties(std::ostream &os, TVertexProperties const &vertexProperty, Types::count indent=2)
Writes vertex properties.
Definition GeojsonWriter.hpp:227
+
egoa::IO::GeoJsonWriter::write
bool write(TNetwork const &network, std::ostream &outputStream)
Write GeoJSON using the output stream.
Definition GeojsonWriter.hpp:726
+
egoa::IO::GeoJsonWriter::WriteFeatureEnd
void WriteFeatureEnd(std::ostream &os, bool last=false, Types::count indent=1)
Writes a feature end.
Definition GeojsonWriter.hpp:194
+
egoa::IO::GeoJsonWriter::WriteGraph
bool WriteGraph(std::ostream &os, TGraph const &graph)
Writes a graph.
Definition GeojsonWriter.hpp:79
+
egoa::IO::GeoJsonWriter::GeoJsonWriter
GeoJsonWriter(Types::count indent=4, bool readable=true)
Constructs a new instance.
Definition GeojsonWriter.hpp:59
+
egoa::IO::GeoJsonWriter::PropertyTemplate
void PropertyTemplate(std::ostream &os, std::string lhs, T const &rhs, bool last=false, Types::count indent=2)
Standard JSON key : value pair template.
Definition GeojsonWriter.hpp:326
+
egoa::IO::GeoJsonWriter::WriteLineContent
void WriteLineContent(std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=4)
Writes a line content.
Definition GeojsonWriter.hpp:659
+
egoa::IO::GeoJsonWriter::WriteLinesGeometryObject
void WriteLinesGeometryObject(std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=2)
Writes a lines geometry object.
Definition GeojsonWriter.hpp:622
+
egoa::IO::GeoJsonWriter::WriteGenerators
void WriteGenerators(std::ostream &os, TNetwork const &network, bool last=false, Types::count indent=1)
Writes points.
Definition GeojsonWriter.hpp:452
+ +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_graph_iterators_8hpp_source.html b/_graph_iterators_8hpp_source.html new file mode 100644 index 00000000..b981ad37 --- /dev/null +++ b/_graph_iterators_8hpp_source.html @@ -0,0 +1,619 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators/GraphIterators.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GraphIterators.hpp
+
+
+
1/*
+
2 * GraphIterators.hpp
+
3 *
+
4 * Created on: Mar 4, 2019
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__GRAPH_ITERATORS_HPP
+
9#define EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__GRAPH_ITERATORS_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif
+
14
+
15#include "Auxiliary/ExecutionPolicy.hpp"
+
16#include "Auxiliary/Types.hpp"
+
17
+
18namespace egoa::internal {
+
19
+
29template<typename GraphType, ExecutionPolicy Policy>
+
30class GraphLoopDifferentiation {};
+
31
+
37template<typename GraphType>
+
+
38class GraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential> {
+
39 // Type aliasing
+
40 using TGraph = GraphType;
+
41 using TVertex = typename TGraph::TVertex;
+
42 using TVertexId = typename TGraph::TVertexId;
+
43 using TEdgeId = typename TGraph::TEdgeId;
+
44
+
45 public:
+
48#pragma mark SEQUENTIAL_VERTEX_LOOPS
+
49
+
67 template<typename FUNCTION>
+
68 inline static
+
+
69 void for_all_vertex_identifiers ( TGraph & graph
+
70 , FUNCTION function )
+
71 {
+
72 for ( auto & vertex : graph.Vertices() )
+
73 {
+
74 auto id = vertex.Identifier();
+
75 function( id );
+
76 }
+
77 }
+
+
78
+
96 template<typename FUNCTION>
+
97 inline static
+
+
98 void for_all_vertices ( TGraph & graph
+
99 , FUNCTION function )
+
100 {
+
101 for ( auto & vertex : graph.Vertices() )
+
102 {
+
103 function( vertex );
+
104 }
+
105 }
+
+
106
+
125 template<typename FUNCTION>
+
126 inline static
+
+
127 void for_all_vertex_tuples ( TGraph & graph
+
128 , FUNCTION function )
+
129 {
+
130 for ( auto & vertex : graph.Vertices() )
+
131 {
+
132 auto id = vertex.Identifier();
+
133 function( id, vertex );
+
134 }
+
135 }
+
+
137
+
140#pragma mark SEQUENTIAL_EDGE_LOOPS
+
141
+
159 template<typename FUNCTION>
+
160 inline static
+
+
161 void for_all_edge_identifiers ( TGraph & graph
+
162 , FUNCTION function )
+
163 {
+
164 for ( auto & edge : graph.Edges() )
+
165 {
+
166 auto id = edge.Identifier();
+
167 function( id );
+
168 }
+
169 }
+
+
170
+
188 template<typename FUNCTION>
+
189 inline static
+
+
190 void for_all_edges ( TGraph & graph
+
191 , FUNCTION function )
+
192 {
+
193 for ( auto & edge : graph.Edges() )
+
194 {
+
195 function( edge );
+
196 }
+
197 }
+
+
198
+
217 template<typename FUNCTION>
+
218 inline static
+
+
219 void for_all_edge_tuples ( TGraph & graph
+
220 , FUNCTION function )
+
221 {
+
222 for ( auto & edge : graph.Edges() )
+
223 {
+
224 auto id = edge.Identifier();
+
225 function( id, edge );
+
226 }
+
227 }
+
+
229
+
232#pragma mark SEQUENTIAL_NEIGHBORHOOD_LOOPS
+
233
+
252 template<typename FUNCTION>
+
253 inline static
+
+
254 void for_all_edges_at ( TGraph & graph
+
255 , TVertex const & vertex
+
256 , FUNCTION function )
+
257 {
+
258 for_all_edges_at( graph, vertex.Identifier(), function );
+
259 }
+
+
260
+
280 template<typename FUNCTION>
+
281 inline static
+
+
282 void for_all_edges_at ( TGraph & graph
+
283 , TVertexId vertexId
+
284 , FUNCTION function )
+
285 {
+
286 for ( auto edgeId : graph.InEdgeIdsAt(vertexId) )
+
287 {
+
288 function( graph.EdgeAt(edgeId) );
+
289 }
+
290 for ( auto edgeId : graph.OutEdgeIdsAt(vertexId) )
+
291 {
+
292 function( graph.EdgeAt(edgeId) );
+
293 }
+
294 }
+
+
295
+
315 template<typename FUNCTION>
+
316 inline static
+
+
317 void for_in_edges_at ( TGraph & graph
+
318 , TVertex const & vertex
+
319 , FUNCTION function )
+
320 {
+
321 for_in_edges_at( graph, vertex.Identifier(), function );
+
322 }
+
+
323
+
343 template<typename FUNCTION>
+
344 inline static
+
+
345 void for_in_edges_at ( TGraph & graph
+
346 , TVertexId vertexId
+
347 , FUNCTION function )
+
348 {
+
349 for ( auto edgeId : graph.InEdgeIdsAt(vertexId) )
+
350 {
+
351 function( graph.EdgeAt(edgeId) );
+
352 }
+
353 }
+
+
354
+
374 template<typename FUNCTION>
+
375 inline static
+
+
376 void for_out_edges_at ( TGraph & graph
+
377 , TVertex const & vertex
+
378 , FUNCTION function )
+
379 {
+
380 for_out_edges_at( graph, vertex.Identifier(), function );
+
381 }
+
+
382
+
402 template<typename FUNCTION>
+
403 inline static
+
+
404 void for_out_edges_at ( TGraph & graph
+
405 , TVertexId vertexId
+
406 , FUNCTION function )
+
407 {
+
408 for ( auto edgeId : graph.OutEdgeIdsAt(vertexId) )
+
409 {
+
410 function( graph.EdgeAt( edgeId ) );
+
411 }
+
412 }
+
+
414};
+
+
415
+
422template<typename GraphType>
+
+
423class GraphLoopDifferentiation<GraphType, ExecutionPolicy::breakable> {
+
424 // Type aliasing
+
425 using TGraph = GraphType;
+
426 using TVertex = typename TGraph::TVertex;
+
427 using TVertexId = typename TGraph::TVertexId;
+
428 using TEdgeId = typename TGraph::TEdgeId;
+
429
+
430 public:
+
433#pragma mark BREAKABLE_VERTEX_LOOPS
+
434
+
455 template<typename FUNCTION>
+
456 inline static
+
+
457 void for_all_vertex_identifiers ( TGraph & graph
+
458 , FUNCTION function )
+
459 {
+
460 for ( auto & vertex : graph.Vertices() )
+
461 {
+
462 auto id = vertex.Identifier();
+
463 bool toContinue = function( id );
+
464 if (!toContinue) return;
+
465 }
+
466 }
+
+
467
+
488 template<typename FUNCTION>
+
489 inline static
+
+
490 void for_all_vertices ( TGraph & graph
+
491 , FUNCTION function )
+
492 {
+
493 for ( auto & vertex : graph.Vertices() )
+
494 {
+
495 bool toContinue = function( vertex );
+
496 if (!toContinue) return;
+
497 }
+
498 }
+
+
499
+
522 template<typename FUNCTION>
+
523 inline static
+
+
524 void for_all_vertex_tuples ( TGraph & graph
+
525 , FUNCTION function )
+
526 {
+
527 for ( auto & vertex : graph.Vertices() )
+
528 {
+
529 auto id = vertex.Identifier();
+
530 bool toContinue = function( id, vertex );
+
531 if (!toContinue) return;
+
532 }
+
533 }
+
+
535
+
538#pragma mark BREAKABLE_EDGE_LOOPS
+
539
+
560 template<typename FUNCTION>
+
561 inline static
+
+
562 void for_all_edge_identifiers ( TGraph & graph
+
563 , FUNCTION function )
+
564 {
+
565 for ( auto & edge : graph.Edges() )
+
566 {
+
567 auto id = edge.Identifier();
+
568 bool toContinue = function( id );
+
569 if (!toContinue) return;
+
570 }
+
571 }
+
+
572
+
593 template<typename FUNCTION>
+
594 inline static
+
+
595 void for_all_edges ( TGraph & graph
+
596 , FUNCTION function )
+
597 {
+
598 for ( auto & edge : graph.Edges() )
+
599 {
+
600 bool toContinue = function( edge );
+
601 if (!toContinue) return;
+
602 }
+
603 }
+
+
604
+
625 template<typename FUNCTION>
+
626 inline static
+
+
627 void for_all_edge_tuples ( TGraph & graph
+
628 , FUNCTION function )
+
629 {
+
630 for ( auto & edge : graph.Edges() )
+
631 {
+
632 auto id = edge.Identifier();
+
633 bool toContinue = function( id, edge );
+
634 if (!toContinue) return;
+
635 }
+
636 }
+
+
638
+
641#pragma mark BREAKABLE_NEIGHBORHOOD_LOOPS
+
664 template<typename FUNCTION>
+
665 inline static
+
+
666 void for_all_edges_at ( TGraph & graph
+
667 , TVertex const & vertex
+
668 , FUNCTION function )
+
669 {
+
670 for_all_edges_at( graph, vertex.Identifier(), function );
+
671 }
+
+
672
+
695 template<typename FUNCTION>
+
696 inline static
+
+
697 void for_all_edges_at ( TGraph & graph
+
698 , TVertexId vertexId
+
699 , FUNCTION function )
+
700 {
+
701 for ( auto edgeId : graph.InEdgeIdsAt(vertexId) )
+
702 {
+
703 bool toContinue = function( graph.EdgeAt(edgeId) );
+
704 if (!toContinue) return;
+
705 }
+
706 for ( auto edgeId : graph.OutEdgeIdsAt(vertexId) )
+
707 {
+
708 bool toContinue = function( graph.EdgeAt(edgeId) );
+
709 if (!toContinue) return;
+
710 }
+
711 }
+
+
712
+
734 template<typename FUNCTION>
+
735 inline static
+
+
736 void for_in_edges_at ( TGraph & graph
+
737 , TVertex const & vertex
+
738 , FUNCTION function)
+
739 {
+
740 for_in_edges_at( graph, vertex.Identifier(), function );
+
741 }
+
+
742
+
764 template<typename FUNCTION>
+
765 inline static
+
+
766 void for_in_edges_at ( TGraph & graph
+
767 , TVertexId vertexId
+
768 , FUNCTION function )
+
769 {
+
770 for ( auto edgeID : graph.InEdgeIdsAt(vertexId) )
+
771 {
+
772 bool toContinue = function( graph.EdgeAt(edgeID) );
+
773 if ( !toContinue ) return;
+
774 }
+
775 }
+
+
776
+
798 template<typename FUNCTION>
+
799 inline static
+
+
800 void for_out_edges_at ( TGraph & graph
+
801 , TVertex const & vertex
+
802 , FUNCTION function)
+
803 {
+
804 for_out_edges_at( graph, vertex.Identifier(), function );
+
805 }
+
+
806
+
828 template<typename FUNCTION>
+
829 inline static
+
+
830 void for_out_edges_at ( TGraph & graph
+
831 , TVertexId vertexId
+
832 , FUNCTION function )
+
833 {
+
834 for ( auto edgeID : graph.OutEdgeIdsAt(vertexId) )
+
835 {
+
836 bool toContinue = function( graph.EdgeAt(edgeID) );
+
837 if ( !toContinue ) return;
+
838 }
+
839 }
+
+
840};
+
+
841
+
842#ifdef OPENMP_AVAILABLE
+
843
+
851template<typename GraphType>
+
852class GraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel> {
+
853 // Type aliasing
+
854 using TGraph = GraphType;
+
855 using TVertex = typename TGraph::TVertex;
+
856 using TVertexId = typename TGraph::TVertexId;
+
857 using TEdgeId = typename TGraph::TEdgeId;
+
858
+
859 public:
+
862#pragma PARALLEL_NEIGHBORHOOD_LOOPS
+
882 template<typename FUNCTION>
+
883 inline static
+
884 void for_all_edges_at ( TGraph & graph
+
885 , TVertex const & vertex
+
886 , FUNCTION function )
+
887 {
+
888 for_all_edges_at( graph, vertex.Identifier(), function );
+
889 }
+
890
+
912 template<typename FUNCTION>
+
913 inline static
+
914 void for_all_edges_at ( TGraph & graph
+
915 , TVertexId vertexId
+
916 , FUNCTION function )
+
917 {
+
918 auto & inEdgeIds = graph.InEdgeIdsAt(vertexId);
+
919 #pragma omp parallel for
+
920 for ( Types::index index = 0
+
921 ; index < inEdgeIds.size()
+
922 ; ++index )
+
923 {
+
924 function( graph.EdgeAt(inEdgeIds[index]) );
+
925 }
+
926
+
927 auto & outEdgeIds = graph.OutEdgeIdsAt(vertexId);
+
928 #pragma omp parallel for
+
929 for ( Types::index index = 0
+
930 ; index < outEdgeIds.size()
+
931 ; ++index )
+
932 {
+
933 function( graph.EdgeAt(outEdgeIds[index]) );
+
934 }
+
935 }
+
936
+
956 template<typename FUNCTION>
+
957 inline static
+
958 void for_in_edges_at ( TGraph & graph
+
959 , TVertex const & vertex
+
960 , FUNCTION function )
+
961 {
+
962 for_in_edges_at( graph, vertex.Identifier(), function );
+
963 }
+
964
+
984 template<typename FUNCTION>
+
985 inline static
+
986 void for_in_edges_at ( TGraph & graph
+
987 , TVertexId vertexId
+
988 , FUNCTION function )
+
989 {
+
990 auto & inEdgeIds = graph.InEdgeIdsAt(vertexId);
+
991 #pragma omp parallel for
+
992 for ( Types::index index = 0
+
993 ; index < inEdgeIds.size()
+
994 ; ++index )
+
995 {
+
996 function( graph.EdgeAt(inEdgeIds[index]) );
+
997 }
+
998 }
+
999
+
1019 template<typename FUNCTION>
+
1020 inline static
+
1021 void for_out_edges_at ( TGraph & graph
+
1022 , TVertex const & vertex
+
1023 , FUNCTION function )
+
1024 {
+
1025 for_out_edges_at( graph, vertex.Identifier(), function );
+
1026 }
+
1027
+
1047 template<typename FUNCTION>
+
1048 inline static
+
1049 void for_out_edges_at( TGraph & graph,
+
1050 TVertexId vertexId,
+
1051 FUNCTION function )
+
1052 {
+
1053 auto & outEdgeIds = graph.OutEdgeIdsAt(vertexId);
+
1054 #pragma omp parallel for
+
1055 for ( Types::index index = 0
+
1056 ; index < outEdgeIds.size()
+
1057 ; ++index )
+
1058 {
+
1059 function( graph.EdgeAt(outEdgeIds[index]) );
+
1060 }
+
1061 }
+
1063};
+
1064
+
1065#else // OPENMP_AVAILABLE
+
1066
+
1072template<typename GraphType>
+
+
1073class GraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel>
+
1074 : public GraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential> {
+
1075};
+
+
1076
+
1077#endif // OPENMP_AVAILABLE
+
1078
+
1079} // namespace egoa::internal
+
1080
+
1081#endif // EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__GRAPH_ITERATORS_HPP
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples
static void for_all_vertex_tuples(TGraph &graph, FUNCTION function)
The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph .
Definition GraphIterators.hpp:524
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers
static void for_all_edge_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all identifiers of edges in the graph .
Definition GraphIterators.hpp:562
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertices
static void for_all_vertices(TGraph &graph, FUNCTION function)
The breakable for loop over all vertex objects in the graph .
Definition GraphIterators.hpp:490
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at
static void for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The breakable for loop over all outgoing edges of a vertex .
Definition GraphIterators.hpp:830
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples
static void for_all_edge_tuples(TGraph &graph, FUNCTION function)
The breakable for loop over all pairs of edge identifiers and edge objects in the graph .
Definition GraphIterators.hpp:627
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges
static void for_all_edges(TGraph &graph, FUNCTION function)
The breakable for loop over all edges in the graph .
Definition GraphIterators.hpp:595
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at
static void for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The breakable for loop over all edges at a vertex .
Definition GraphIterators.hpp:666
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at
static void for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The breakable for loop over all incoming edges of a vertex .
Definition GraphIterators.hpp:736
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at
static void for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The breakable for loop over all outgoing edges of a vertex .
Definition GraphIterators.hpp:800
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at
static void for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The breakable for loop over all edges at a vertex .
Definition GraphIterators.hpp:697
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at
static void for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The breakable for loop over all incoming edges of a vertex .
Definition GraphIterators.hpp:766
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all vertex identifiers in the graph .
Definition GraphIterators.hpp:457
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples
static void for_all_vertex_tuples(TGraph &graph, FUNCTION function)
The for loop over all pairs of vertex identifiers and vertex tuples in the graph .
Definition GraphIterators.hpp:127
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at
static void for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The for loop over all incoming edges of a vertex .
Definition GraphIterators.hpp:345
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at
static void for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The for loop over all incoming edges of a vertex .
Definition GraphIterators.hpp:317
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers
static void for_all_edge_identifiers(TGraph &graph, FUNCTION function)
The for loop over all indentifiers of edges in the graph .
Definition GraphIterators.hpp:161
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertices
static void for_all_vertices(TGraph &graph, FUNCTION function)
The for loop over all vertex objects in the graph .
Definition GraphIterators.hpp:98
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at
static void for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The for loop over all outgoing edges of a vertex .
Definition GraphIterators.hpp:376
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples
static void for_all_edge_tuples(TGraph &graph, FUNCTION function)
The for loop over all pairs of edge identifiers and edge objects in the graph .
Definition GraphIterators.hpp:219
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at
static void for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)
The for loop over all edges at a vertex .
Definition GraphIterators.hpp:254
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at
static void for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The for loop over all outgoing edges of a vertex .
Definition GraphIterators.hpp:404
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at
static void for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)
The for loop over all edges at a vertex .
Definition GraphIterators.hpp:282
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges
static void for_all_edges(TGraph &graph, FUNCTION function)
The for loop over all edges in the graph .
Definition GraphIterators.hpp:190
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The for loop over all vertex identifiers in the graph .
Definition GraphIterators.hpp:69
+
egoa::internal::GraphLoopDifferentiation
The base class for for loops for graphs.
Definition GraphIterators.hpp:30
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_i_o_2_wrapper_2_edge_8hpp_source.html b/_i_o_2_wrapper_2_edge_8hpp_source.html new file mode 100644 index 00000000..5c55d18b --- /dev/null +++ b/_i_o_2_wrapper_2_edge_8hpp_source.html @@ -0,0 +1,138 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Wrapper/Edge.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Edge.hpp
+
+
+
1/*
+
2 * Edge.hpp
+
3 *
+
4 * Created on: May 3, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__WRAPPER__EDGE_HPP
+
9#define EGOA__IO__WRAPPER__EDGE_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12
+
13namespace egoa::io {
+
14
+
15template<typename PropertiesType>
+
+
16class Edge {
+
17public:
+
18 using TProperties = PropertiesType;
+
19
+
20 Edge()
+
21 : source_(Const::INFTY),
+
22 target_(Const::INFTY),
+
23 properties_() {
+
24 }
+
25
+
26 inline Types::vertexId Source() const { return source_; }
+
27 inline Types::vertexId & Source() { return source_; }
+
28
+
29 inline Types::vertexId Target() const { return target_; }
+
30 inline Types::vertexId & Target() { return target_; }
+
31
+
32 inline TProperties & Properties() { return properties_; }
+
33 inline TProperties const & Properties() const { return properties_; }
+
34
+
35private:
+
36 Types::vertexId source_;
+
37 Types::vertexId target_;
+
38 TProperties properties_;
+
39};
+
+
40
+
41} // namespace egoa::io
+
42
+
43#endif // EGOA__IO__WRAPPER__EDGE_HPP
+ +
egoa::io::Edge::source_
Types::vertexId source_
Definition Edge.hpp:36
+
egoa::io::Edge::target_
Types::vertexId target_
Definition Edge.hpp:37
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_ieee_cdf_matlab_parser_8hpp_source.html b/_ieee_cdf_matlab_parser_8hpp_source.html new file mode 100644 index 00000000..7b0318d7 --- /dev/null +++ b/_ieee_cdf_matlab_parser_8hpp_source.html @@ -0,0 +1,541 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Parser/IeeeCdfMatlabParser.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
IeeeCdfMatlabParser.hpp
+
+
+
1/*
+
2 * IeeeCdfMatlabParser.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA___IO___PARSER___IEEE_CDF_MATLAB_PARSER_HPP
+
9#define EGOA___IO___PARSER___IEEE_CDF_MATLAB_PARSER_HPP
+
10
+
11#include <iostream>
+
12#include <sstream>
+
13#include <string>
+
14#include <vector>
+
15#include <unordered_map>
+
16#include <algorithm>
+
17
+
18#include "DataStructures//Networks/PowerGrid.hpp"
+
19
+
20#include "DataStructures/Graphs/StaticGraph.hpp"
+
21
+
22#include "DataStructures/Graphs/Edges/Edge.hpp"
+
23#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
24
+
25#include "DataStructures/Graphs/Vertices/Type.hpp"
+
26#include "DataStructures/Graphs/Vertices/Vertex.hpp"
+
27#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
28#include "DataStructures/Graphs/Vertices/GeneratorProperties.hpp"
+
29#include "DataStructures/Graphs/Vertices/LoadProperties.hpp"
+
30
+
31#include "Auxiliary/Auxiliary.hpp"
+
32
+
33namespace egoa {
+
34
+
35template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType >
+
36 , Edges::ElectricalProperties > >
+
+
37class IeeeCdfMatlabParser final {
+
38
+
39 using TElectricalVertex = typename GraphType::TVertex;
+
40 using TVertexProperties = typename TElectricalVertex::TProperties;
+
41 using TVertex = typename GraphType::TVertex;
+
42
+
43 using TVertexType = typename TVertexProperties::TVertexType;
+
44
+
45 using TGeneratorProperties = Vertices::GeneratorProperties<TVertexType>;
+
46 using TLoadProperties = Vertices::LoadProperties<TVertexType>;
+
47 using TElectricalEdge = typename GraphType::TEdge;
+
48 using TEdgeProperties = typename TElectricalEdge::TProperties;
+
49 using TBound = Bound<>;
+
50 using TNetwork = PowerGrid<GraphType>;
+
51
+
52 private:
+
53 static inline void toUpper ( std::string &str ) {
+
54 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+
55 }
+
56
+
57 static inline void toLower(std::string &str) {
+
58 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+
59 }
+
60
+
61 inline void init () {
+
62 initialized_ = false;
+
63 }
+
64
+
+
71 void readBaseMva ( TNetwork & network ) {
+
72 Types::string str;
+
73 while ( str.compare("mpc.baseMVA") )
+
74 {
+
75 input_stream_ >> str;
+
76 }
+
77 input_stream_.ignore(3);
+
78 getline ( input_stream_, str, ';' );
+
79 network.BaseMva() = atoi(str.c_str());
+
80 }
+
+
81
+
+
88 inline void readCaseName( TNetwork & network ) {
+
89 Types::string str;
+
90 while ( str.compare("function") )
+
91 {
+
92 input_stream_ >> str;
+
93 }
+
94 input_stream_.ignore(6);
+
95 input_stream_ >> str;
+
96 network.Graph().Name() = str;
+
97 }
+
+
98
+
+
120 void readBusMatrix( TNetwork & network ) {
+
121 Types::string str;
+
122
+
123 // Nodes
+
124 while ( str.compare("mpc.bus") )
+
125 {
+
126 input_stream_ >> str;
+
127 }
+
128
+
129 getline(input_stream_, str);
+
130
+
131 TVertexProperties bus;
+
132 TLoadProperties load;
+
133 Types::vertexId identifier;
+
134
+
135 network.AddSnapshotTimestamp( genericTimestamp_ );
+
136 network.AddSnapshotWeighting( genericWeighting_ );
+
137
+
138 input_stream_ >> str;
+
139
+
140 while ( str.compare("];") )
+
141 {
+
142 bus.Name() = str.c_str();
+
143
+
144 input_stream_ >> std::ws >> str;
+
145 bus.Type() = Vertices::to_enum<TVertexType>( atoi( str.c_str() ) );
+
146
+
147 input_stream_ >> std::ws >> str; //bus
+
148 load.RealPowerLoad() = Types::String2double(str) / network.BaseMva();
+
149
+
150 input_stream_ >> str; //bus
+
151 load.ReactivePowerLoad() = Types::String2double(str) / network.BaseMva();
+
152
+
153 input_stream_ >> str;
+
154 bus.ShuntConductance() = Types::String2double(str) / network.BaseMva();
+
155
+
156 input_stream_ >> str;
+
157 bus.ShuntSusceptance() = Types::String2double(str) / network.BaseMva();
+
158
+
159 input_stream_ >> std::ws >> str;
+
160 bus.Area() = Types::String2double(str);
+
161
+
162 input_stream_ >> std::ws >> str;
+
163 bus.VoltageMagnitude() = Types::String2double(str);
+
164
+
165 input_stream_ >> std::ws >> str;
+
166 bus.VoltageAngle() = Types::String2double(str);
+
167
+
168 input_stream_ >> std::ws >> str;
+
169 bus.NominalVoltage() = Types::String2double(str);
+
170
+
171 input_stream_ >> std::ws >> str;
+
172 bus.Zone() = Types::String2double(str);
+
173
+
174 input_stream_ >> std::ws >> str;
+
175 bus.MaximumVoltage() = Types::String2double(str);
+
176
+
177 getline(input_stream_, str,';');
+
178 bus.MinimumVoltage() = Types::String2double(str);
+
179
+
180 bus.Status() = Vertices::BusStatus::active;
+
181 identifier = network.Graph().AddVertex( bus );
+
182 mapVertexName2Id_[bus.Name()]= identifier;
+
183
+
184 //bus
+
185 if ( load.RealPowerLoad() >= 0 )
+
186 {
+
187 load.RealPowerLoadBound().Minimum() = 0;
+
188 load.RealPowerLoadBound().Maximum() = load.RealPowerLoad();
+
189 } else {
+
190 load.RealPowerLoadBound().Minimum() = load.RealPowerLoad(); // TODO
+
191 load.RealPowerLoadBound().Maximum() = 0;
+
192 }
+
193
+
194 if ( load.ReactivePowerLoad() >= 0 )
+
195 {
+
196 load.ReactivePowerLoadBound().Minimum() = 0;
+
197 load.ReactivePowerLoadBound().Maximum() = load.ReactivePowerLoad();
+
198 } else {
+
199 load.ReactivePowerLoadBound().Minimum() = load.ReactivePowerLoad();
+
200 load.ReactivePowerLoadBound().Maximum() = 0;
+
201 }
+
202
+
203 if ( load.RealPowerLoad() > 0 || load.ReactivePowerLoad() > 0 )
+
204 {
+
205 load.Name() = bus.Name();
+
206 load.Type() = Vertices::IeeeBusType::load;
+
207 Types::loadId loadId = network.AddLoadAt( identifier, load );
+
208 if ( load.RealPowerLoad () > 0 )
+
209 { // Add a snapshot only when necessary
+
210 network.AddLoadSnapshotAt(loadId, load.RealPowerLoad() ); // Maximum real power p.u.
+
211 } //@todo Else add load snapshot that has reactive power
+
212 }
+
213 if ( load.RealPowerLoad () < 0 )
+
214 { // real power generator if real power demand is negative
+
215 TGeneratorProperties generator;
+
216 generator.Name () = bus.Name();
+
217 generator.RealPower () = std::fabs ( load.RealPowerLoad() );
+
218 // Add real power bounds using the absolute value of the demand
+
219 generator.RealPowerBound().Minimum() = 0;
+
220 generator.RealPowerBound().Maximum() = generator.RealPower ();
+
221
+
222 if ( load.ReactivePowerLoad () < 0 )
+
223 {
+
224 generator.ReactivePower () = std::fabs ( load.ReactivePowerLoad () );
+
225 // Add reactive power bounds using the absolute value of the demand
+
226 generator.ReactivePowerBound().Minimum() = 0;
+
227 generator.ReactivePowerBound().Maximum() = generator.ReactivePower ();
+
228 } // else is already done before by adding a load vertex
+
229 } else if ( load.ReactivePowerLoad () < 0 )
+
230 { // reactive power generator if reactive power demand is negative
+
231 TGeneratorProperties generator;
+
232 generator.Name () = bus.Name();
+
233 generator.ReactivePower () = std::fabs ( load.ReactivePowerLoad () );
+
234 // Add reactive power bounds using the absolute value of the demand
+
235 generator.ReactivePowerBound().Minimum() = 0;
+
236 generator.ReactivePowerBound().Maximum() = generator.ReactivePower ();
+
237 } // else is already done before by adding a load vertex
+
238
+
239 input_stream_ >> str;
+
240 }
+
241
+
242 input_stream_.seekg (0, input_stream_.beg); //move the position to the begin of the file
+
243 }
+
+
244
+
245
+
+
270 void readBranchMatrix( TNetwork & network ) {
+
271 Types::string str;
+
272
+
273 network.ThetaBound().Minimum() = 0.0;
+
274 network.ThetaBound().Maximum() = 0.0;
+
275
+
276 // TODO this can be done smarter, currently whole file scanned again
+
277 while ( str.compare("mpc.branch") )
+
278 {
+
279 input_stream_ >> str;
+
280 }
+
281
+
282 getline(input_stream_, str);
+
283 Types::string src, dest;
+
284
+
285 input_stream_ >> str;
+
286
+
287 while(str.compare("];"))
+
288 {
+
289 TEdgeProperties edge;
+
290 src = str;
+
291
+
292 input_stream_ >> dest;
+
293
+
294 // edge.Source() = mapVertexName2Id_[src];
+
295 // edge.Target() = mapVertexName2Id_[dest];
+
296
+
297 // r in the data
+
298 input_stream_ >> str;
+
299 edge.Resistance() = Types::String2double(str);
+
300
+
301 // x in the data
+
302 input_stream_ >> str;
+
303 edge.Reactance() = Types::String2double(str);
+
304
+
305 // b in the data
+
306 input_stream_ >> str;
+
307 edge.Charge() = Types::String2double(str);
+
308
+
309 // Rate A in the data
+
310 input_stream_ >> str;
+
311 edge.ThermalLimit() = Types::String2double(str) / network.BaseMva();
+
312
+
313 // Rate B in the data
+
314 input_stream_ >> std::ws >> str;
+
315 edge.ThermalLimitB() = Types::String2double(str) / network.BaseMva();
+
316
+
317 // Rate C in the data
+
318 input_stream_ >> std::ws >> str;
+
319 edge.ThermalLimitC() = Types::String2double(str) / network.BaseMva();
+
320
+
321 // Tap ratio tau in the data
+
322 input_stream_ >> std::ws >> str;
+
323 if(atof(str.c_str()) == 0)
+
324 { //
+
325 edge.TapRatio() = 1.0;
+
326 } else
+
327 edge.TapRatio() = Types::String2double(str);
+
328
+
329 // theta shift in the data
+
330 input_stream_ >> str;
+
331 edge.AngleShift() = Types::String2double(str) * Const::PI / 180;
+
332 edge.TapRatioCosThetaShift() = edge.TapRatio() * cos( edge.AngleShift() );
+
333 edge.TapRatioSinThetaShift() = edge.TapRatio() * sin( edge.AngleShift() );
+
334
+
335 // Status in the data
+
336 input_stream_ >> str;
+
337 edge.Status() = Types::String2integer(str);
+
338
+
339 // angmin in the data
+
340 input_stream_ >> str;
+
341 edge.ThetaBound().Minimum() = Types::String2double(str) * Const::PI / 180 ;
+
342 network.ThetaBound().Minimum() += edge.ThetaBound().Minimum(); //m_theta_lb
+
343
+
344 // angmax in the data
+
345 input_stream_ >> str;
+
346 edge.ThetaBound().Maximum() = Types::String2double(str) * Const::PI / 180;
+
347 network.ThetaBound().Maximum() += edge.ThetaBound().Maximum();
+
348
+
349 network.Graph().AddEdge(mapVertexName2Id_[src], mapVertexName2Id_[dest], edge);
+
350
+
351 getline(input_stream_, str,'\n');
+
352 input_stream_ >> str;
+
353 } // while
+
354 }
+
+
355
+
+
386 void readGeneratorMatrix( TNetwork & network ) {
+
387 Types::string str;
+
388
+
389 while ( str.compare("mpc.gen") ) {
+
390 input_stream_ >> str;
+
391 }
+
392
+
393 getline(input_stream_, str);
+
394 input_stream_ >> str;
+
395
+
396 while ( str.compare("];") ) {
+
397 TGeneratorProperties generator;
+
398
+
399 generator.Name() = str.c_str();
+
400
+
401 input_stream_ >> str;
+
402 generator.RealPower() = Types::String2double(str) / network.BaseMva();
+
403
+
404 input_stream_ >> str;
+
405 generator.ReactivePower() = Types::String2double(str) / network.BaseMva();
+
406
+
407 input_stream_ >> str;
+
408 generator.ReactivePowerBound().Maximum() = Types::String2double(str) / network.BaseMva();
+
409
+
410 input_stream_ >> str;
+
411 generator.ReactivePowerBound().Minimum() = Types::String2double(str) / network.BaseMva();
+
412
+
413 input_stream_ >> std::ws >> str;
+
414 generator.VoltageMagnitude() = Types::String2double(str);
+
415
+
416 input_stream_ >> std::ws >> str;
+
417 generator.NominalPower() = Types::String2double(str);
+
418
+
419 input_stream_ >> std::ws >> str;
+
420 Types::index status = Types::String2integer(str);
+
421 if ( status )
+
422 generator.Status() = Vertices::BusStatus::active;
+
423 else
+
424 generator.Status() = Vertices::BusStatus::inactive;
+
425
+
426 input_stream_ >> str;
+
427 generator.RealPowerBound().Maximum() = Types::String2double(str) / network.BaseMva();
+
428
+
429 input_stream_ >> str;
+
430 generator.RealPowerBound().Minimum() = Types::String2double(str) / network.BaseMva();
+
431
+
432 input_stream_ >> std::ws >> str;
+
433 generator.Pc1() = Types::String2double(str);
+
434
+
435 input_stream_ >> std::ws >> str;
+
436 generator.Pc2() = Types::String2double(str);
+
437
+
438 input_stream_ >> std::ws >> str;
+
439 generator.Qc1Bound().Minimum() = Types::String2double(str);
+
440
+
441 input_stream_ >> std::ws >> str;
+
442 generator.Qc1Bound().Maximum() = Types::String2double(str);
+
443
+
444 input_stream_ >> std::ws >> str;
+
445 generator.Qc2Bound().Minimum() = Types::String2double(str);
+
446
+
447 input_stream_ >> std::ws >> str;
+
448 generator.Qc2Bound().Maximum() = Types::String2double(str);
+
449
+
450 input_stream_ >> std::ws >> str;
+
451 generator.RampAgc() = Types::String2double(str);
+
452
+
453 input_stream_ >> std::ws >> str;
+
454 generator.Ramp10() = Types::String2double(str);
+
455
+
456 input_stream_ >> std::ws >> str;
+
457 generator.Ramp30() = Types::String2double(str);
+
458
+
459 input_stream_ >> std::ws >> str;
+
460 generator.RampQ() = Types::String2double(str);
+
461
+
462 input_stream_ >> std::ws >> str;
+
463 generator.Apf() = Types::String2double(str);
+
464
+
465 getline(input_stream_, str,'\n');
+
466
+
467 Types::generatorId generatorId = network.AddGeneratorAt(mapVertexName2Id_[generator.Name()], generator);
+
468 network.AddGeneratorRealPowerSnapshotAt( generatorId, generator.RealPower() );
+
469
+
470 // Get first item in the new line
+
471 input_stream_ >> str;
+
472 }
+
473 input_stream_.seekg (0, input_stream_.beg);
+
474 }
+
+
475
+
483 // void readGeneratorCostFunctionMatrix( TNetwork & network );
+
484
+
485
+
+
486 bool readNetwork( TNetwork & network ) {
+
487 readCaseName( network );
+
488 readBaseMva( network );
+
489 readBusMatrix( network );
+
490 readGeneratorMatrix( network );
+
491 // readGeneratorCostFunctionMatrix( network );
+
492 readBranchMatrix( network );
+
493
+
494 return true;
+
495 }
+
+
496
+
497 public:
+
498 explicit IeeeCdfMatlabParser ( std::istream & input_stream )
+
499 : input_stream_(input_stream)
+
500 {
+
501 init();
+
502 }
+
503
+
504 bool read ( TNetwork & network ) {
+
505 return readNetwork( network );
+
506 }
+
507
+
508 private:
+
509 std::istream & input_stream_;
+
510 bool initialized_;
+
511 std::unordered_map<Types::name, Types::index> mapVertexName2Id_;
+
512
+
513 const Types::string genericTimestamp_ = "0000-00-00 00:00:00";
+
514 const Types::real genericWeighting_ = 1.0;
+
515};
+
+
516
+
517} // namespace egoa
+
518
+
519#endif // EGOA__IO__PARSER___IEEE_CDF_MATLAB_PARSER_HPP
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+ +
egoa::IeeeCdfMatlabParser::readCaseName
void readCaseName(TNetwork &network)
Read the name of the case.
Definition IeeeCdfMatlabParser.hpp:88
+
egoa::IeeeCdfMatlabParser::readNetwork
bool readNetwork(TNetwork &network)
Gammelig.
Definition IeeeCdfMatlabParser.hpp:486
+
egoa::IeeeCdfMatlabParser::readBaseMva
void readBaseMva(TNetwork &network)
Read base MVA from an m-file in IEEE Common Data Format.
Definition IeeeCdfMatlabParser.hpp:71
+
egoa::IeeeCdfMatlabParser::readBranchMatrix
void readBranchMatrix(TNetwork &network)
Read the branch matrix.
Definition IeeeCdfMatlabParser.hpp:270
+
egoa::IeeeCdfMatlabParser::readGeneratorMatrix
void readGeneratorMatrix(TNetwork &network)
Read generator matrix.
Definition IeeeCdfMatlabParser.hpp:386
+
egoa::IeeeCdfMatlabParser::readBusMatrix
void readBusMatrix(TNetwork &network)
Read the bus matrix.
Definition IeeeCdfMatlabParser.hpp:120
+ +
egoa::Vertices::GeneratorProperties
Class having all generator properties.
Definition GeneratorProperties.hpp:28
+
egoa::Vertices::LoadProperties
Class having all load properties.
Definition LoadProperties.hpp:24
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_kruskal_8hpp_source.html b/_kruskal_8hpp_source.html new file mode 100644 index 00000000..a806d568 --- /dev/null +++ b/_kruskal_8hpp_source.html @@ -0,0 +1,165 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/SpanningTree/Kruskal.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Kruskal.hpp
+
+
+
1/*
+
2 * Kruskal.hpp
+
3 *
+
4 * Created on: Nov 22, 2018
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__SPANNING_TREES__KRUSKAL_HPP
+
9#define EGOA__ALGORITHMS__SPANNING_TREES__KRUSKAL_HPP
+
10
+
11#include "Algorithms/SpanningTree/MST.hpp"
+
12
+
13#include "DataStructures/Container/UnionFind.hpp"
+
14
+
15namespace egoa {
+
28template<typename GraphType>
+
+
29class Kruskal final : public MST<GraphType> {
+
30
+
31 using TSpanningTree = MST<GraphType>;
+
32 using typename TSpanningTree::TGraph;
+
33 using typename TSpanningTree::TEdge;
+
34 using typename TSpanningTree::TComparator;
+
35
+
36 public:
+
37 Kruskal(TGraph & graph,
+
38 TComparator comparator)
+
39 : TSpanningTree(graph, std::move(comparator))
+
40 {}
+
41
+
42 virtual ~Kruskal() {}
+
43
+
+
57 virtual inline void Run() override {
+
58 UnionFind unionFind( this->Graph().NumberOfVertices() );
+
59
+
60 // Fill vector with edge identifiers
+
61 std::vector<Types::edgeId> edges;
+
62 edges.reserve(this->Graph().NumberOfEdges());
+
63 this->Graph().template for_all_edge_identifiers<ExecutionPolicy::sequential>([&edges](Types::edgeId id) {
+
64 edges.push_back(id);
+
65 });
+
66
+
67 // Sort the edges by their weights
+
68 std::sort( edges.begin(), edges.end(), this->Comparator());
+
69
+
70 std::vector<Types::edgeId> spanningTreeEdges;
+
71
+
72 for ( Types::edgeId edge : edges )
+
73 {
+
74 Types::vertexId source = this->Graph().EdgeAt( edge ).Source();
+
75 Types::vertexId target = this->Graph().EdgeAt( edge ).Target();
+
76 if ( !unionFind.InSameComponent( source, target ) ) {
+
77 unionFind.Union( source, target );
+
78 spanningTreeEdges.push_back( edge );
+
79 }
+
80 }
+
81
+
82 this->SetResult(std::move(spanningTreeEdges));
+
83 }
+
+
84};
+
+
85
+
86} // namespace egoa
+
87
+
88#endif // EGOA__ALGORITHMS__SPANNING_TREES__KRUSKAL_HPP
+
egoa::Kruskal
An implementation of Kruskal's algorithm for finding minimum spanning trees.
Definition Kruskal.hpp:29
+
egoa::Kruskal::Run
virtual void Run() override
Kruskal's Algorithm.
Definition Kruskal.hpp:57
+
egoa::MST
Base class for minimum spanning tree algorithms.
Definition MST.hpp:38
+
egoa::MST::SetResult
void SetResult(std::vector< Types::edgeId > &&edges)
Builds a subgraph object representing the spanning tree given by the edges.
Definition MST.hpp:86
+
egoa::UnionFind
This class describes an union find.
Definition UnionFind.hpp:19
+
egoa::UnionFind::Union
void Union(Types::vertexId u, Types::vertexId v)
Merges the two subtrees—if exist—of both components together.
Definition UnionFind.hpp:57
+
egoa::UnionFind::InSameComponent
bool InSameComponent(Types::vertexId u, Types::vertexId v)
Are both vertices in the same component.
Definition UnionFind.hpp:82
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_label_8hpp_source.html b/_label_8hpp_source.html new file mode 100644 index 00000000..266d84d5 --- /dev/null +++ b/_label_8hpp_source.html @@ -0,0 +1,276 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Labels/Label.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Label.hpp
+
+
+
1/*
+
2 * Label.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__LABELS__LABEL_HPP
+
9#define EGOA__DATA_STRUCTURES__LABELS__LABEL_HPP
+
10
+
11#include <unordered_set>
+
12
+
13#include "Auxiliary/Auxiliary.hpp"
+
14#include "DataStructures/Graphs/Edges/Edge.hpp"
+
15#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
16
+
17namespace egoa {
+
18
+
31template< typename ElementType = Edges::Edge<Edges::ElectricalProperties>
+
32 , typename VertexSetContainer = std::unordered_set<Types::vertexId>
+
33 , typename PointerType = Types::vertexId >
+
+
34class Label {
+
35 public:
+
36 // Type aliasing
+
37 using TVertexId = Types::vertexId;
+
39 using TElement = ElementType;
+
40 using TVertexSet= VertexSetContainer;
+
42 using TPointer = PointerType;
+
43
+
44 using TLabel = Label<TElement,TVertexSet, TPointer>;
+
46 public:
+
49#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
50
+
+
59 Label( Types::vertexId vertexId )
+
60 : index_(Const::NONE)
+
61 , vertexId_(vertexId)
+
62 , valid_(true)
+
63 // , marked_(false)
+
64 , previousVertexId_(Const::NONE)
+
65 , previousLabelId_(Const::NONE)
+
66 {}
+
+
67
+
76 Label ( Label const & label ) = default;
+
77
+
81 ~Label() {}
+
83
+
86#pragma mark DOMINATION_OPERATORS
+
87 // inline bool operator< ( Label const & rhs ) const { return true; }
+
88 // inline bool operator<=( Label const & rhs ) const { return true; }
+
89 // inline bool operator> ( Label const & rhs ) const { return true; }
+
90 // inline bool operator>=( Label const & rhs ) const { return true; }
+
92
+
95#pragma mark COMPARISON_OPERATORS
+
96 // inline bool operator==( Label const & rhs ) const { return true; }
+
97 // inline bool operator!=( Label const & rhs ) const { return true; }
+
99
+
102#pragma mark CONCATENATION_OPERATORS
+
103
+
111 // inline Label & operator+=( TElement const & rhs ) {}
+
112
+
113 // inline Label operator+ ( TElement const & rhs ) const {};
+
114
+
116
+
119#pragma mark GETTER_AND_SETTER
+
120
+
+
131 inline Types::labelId Index () const
+
132 {
+
133 return index_;
+
134 }
+
+
135
+
+
148 inline Types::labelId & Index ()
+
149 {
+
150 return index_;
+
151 }
+
+
152
+
+
158 inline bool Valid () const
+
159 {
+
160 return valid_;
+
161 }
+
+
162
+
+
172 inline bool & Valid()
+
173 {
+
174 return valid_;
+
175 }
+
+
176
+
184 // inline Types::real Value() const {}
+
185
+
+
191 inline Types::vertexId Vertex() const
+
192 {
+
193 return vertexId_;
+
194 }
+
+
195
+
+
205 inline Types::vertexId & Vertex()
+
206 {
+
207 return vertexId_;
+
208 }
+
+
209
+
+
215 inline TPointer PreviousVertex() const
+
216 {
+
217 return previousVertexId_;
+
218 }
+
+
219
+
+
229 inline TPointer & PreviousVertex()
+
230 {
+
231 return previousVertexId_;
+
232 }
+
+
233
+
+
239 inline TPointer PreviousLabel() const
+
240 {
+
241 return previousLabelId_;
+
242 }
+
+
243
+
+
261 inline TPointer & PreviousLabel()
+
262 {
+
263 return previousLabelId_;
+
264 }
+
+
266
+
267#pragma mark OUTPUT
+
+
276 friend std::ostream & operator<< ( std::ostream & os
+
277 , Label const & rhs )
+
278 {
+
279 return os << "(" << rhs.Value() << "," << rhs.Valid() << ")";
+
280 }
+
+
281
+
282#pragma mark MEMBERS
+
283 private:
+
284 Types::labelId index_;
+
285 Types::vertexId vertexId_;
+
287 bool valid_;
+
289 TPointer previousVertexId_;
+
290 TPointer previousLabelId_;
+
292};
+
+
293
+
294} // namespace egoa
+
295
+
296#endif // EGOA__DATA_STRUCTURES__LABELS__LABEL_HPP
+
egoa::Label
Interface for label.
Definition Label.hpp:34
+
egoa::Label::Valid
bool & Valid()
Setter for the valid flag.
Definition Label.hpp:172
+
egoa::Label::PreviousVertex
TPointer PreviousVertex() const
Getter for the previous vertex.
Definition Label.hpp:215
+
egoa::Label::Vertex
Types::vertexId & Vertex()
Setter for the vertex identifier.
Definition Label.hpp:205
+
egoa::Label::PreviousLabel
TPointer PreviousLabel() const
Getter and setter for the previous label.
Definition Label.hpp:239
+
egoa::Label::Valid
bool Valid() const
Getter for the valid flag.
Definition Label.hpp:158
+
egoa::Label::Label
Label(Label const &label)=default
Copy constructor.
+
egoa::Label::~Label
~Label()
Destroys the label object.
Definition Label.hpp:81
+
egoa::Label::TVertexSet
VertexSetContainer TVertexSet
Definition Label.hpp:40
+
egoa::Label::vertexId_
Types::vertexId vertexId_
Definition Label.hpp:285
+
egoa::Label::index_
Types::labelId index_
Definition Label.hpp:284
+
egoa::Label::TVertexId
Types::vertexId TVertexId
Definition Label.hpp:37
+
egoa::Label::TElement
ElementType TElement
Definition Label.hpp:39
+
egoa::Label::operator<<
friend std::ostream & operator<<(std::ostream &os, Label const &rhs)
Output stream.
Definition Label.hpp:276
+
egoa::Label::Label
Label(Types::vertexId vertexId)
Constructs the label object.
Definition Label.hpp:59
+
egoa::Label::Vertex
Types::vertexId Vertex() const
Getter for the value of the label.
Definition Label.hpp:191
+
egoa::Label::Index
Types::labelId Index() const
Getter for the label identifier.
Definition Label.hpp:131
+
egoa::Label::valid_
bool valid_
Definition Label.hpp:287
+
egoa::Label::previousVertexId_
TPointer previousVertexId_
Definition Label.hpp:289
+
egoa::Label::PreviousLabel
TPointer & PreviousLabel()
Setter for the previous label.
Definition Label.hpp:261
+
egoa::Label::PreviousVertex
TPointer & PreviousVertex()
Setter for the previous vertex.
Definition Label.hpp:229
+
egoa::Label::Index
Types::labelId & Index()
Setter for the label identifier.
Definition Label.hpp:148
+
egoa::Label::previousLabelId_
TPointer previousLabelId_
Definition Label.hpp:290
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_load_properties_8hpp_source.html b/_load_properties_8hpp_source.html new file mode 100644 index 00000000..06ca8bd9 --- /dev/null +++ b/_load_properties_8hpp_source.html @@ -0,0 +1,297 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices/LoadProperties.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
LoadProperties.hpp
+
+
+
1/*
+
2 * LoadProperties.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__LOAD_PROPERTIES_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__LOAD_PROPERTIES_HPP
+
10
+
11#include "Type.hpp"
+
12#include "DataStructures/Bound.hpp"
+
13
+
14namespace egoa::Vertices {
+
15
+
23template<class VertexType = Vertices::IeeeBusType>
+
+
24class LoadProperties {
+
25
+
26 // Template type aliasing
+
27 using TVertexType = VertexType;
+
28 using TBound = Bound<Types::real>;
+
29
+
30 public:
+
33#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
34
+
+
38 LoadProperties ( )
+
39 : name_("")
+
40 , type_(TVertexType::load)
+
41 , realPowerLoad_(0.0)
+
42 , realPowerLoadBound_( TBound( 0.0, 0.0 ) )
+
43 , reactivePowerLoad_(0.0)
+
44 , reactivePowerLoadBound_( TBound( 0.0, 0.0 ) )
+
45 {}
+
+
46
+
+
52 LoadProperties ( Types::name name )
+
53 : name_(name)
+
54 , type_(TVertexType::load)
+
55 , realPowerLoad_(0.0)
+
56 , realPowerLoadBound_( TBound( 0.0, 0.0 ) )
+
57 , reactivePowerLoad_(0.0)
+
58 , reactivePowerLoadBound_( TBound( 0.0, 0.0 ) )
+
59 {}
+
+
61
+
64#pragma mark GENERAL_INFORMATION
+
65
+
+
71 inline Types::name & Name ()
+
72 {
+
73 return name_;
+
74 }
+
+
75
+
+
81 inline Types::name Name () const
+
82 {
+
83 return name_;
+
84 }
+
+
85
+
+
91 inline TVertexType & Type ()
+
92 {
+
93 return type_;
+
94 }
+
+
95
+
+
101 inline TVertexType const & Type () const
+
102 {
+
103 return type_;
+
104 }
+
+
106
+
109#pragma mark REAL_POWER_LOAD
+
110
+
+
119 inline Types::real RealPowerLoad () const
+
120 {
+
121 return realPowerLoad_;
+
122 }
+
+
123
+
+
132 inline Types::real & RealPowerLoad ()
+
133 {
+
134 return realPowerLoad_;
+
135 }
+
+
136
+
+
146 inline TBound RealPowerLoadBound () const
+
147 {
+
148 return realPowerLoadBound_;
+
149 }
+
+
150
+
+
160 inline TBound & RealPowerLoadBound ()
+
161 {
+
162 return realPowerLoadBound_;
+
163 }
+
+
165
+
168#pragma mark REACTIVE_POWER_LOAD
+
169
+
+
179 inline Types::real ReactivePowerLoad () const
+
180 {
+
181 return reactivePowerLoad_;
+
182 }
+
+
183
+
+
193 inline Types::real & ReactivePowerLoad ()
+
194 {
+
195 return reactivePowerLoad_;
+
196 }
+
+
197
+
+
207 inline TBound ReactivePowerLoadBound () const
+
208 {
+
209 return reactivePowerLoadBound_;
+
210 }
+
+
211
+
+
222 inline TBound & ReactivePowerLoadBound ()
+
223 {
+
224 return reactivePowerLoadBound_;
+
225 }
+
+
227
+
230#pragma mark COMPARATORS
+
231
+
+
240 inline bool operator!= ( LoadProperties const & rhs ) const
+
241 {
+
242 return !( this == rhs );
+
243 }
+
+
244
+
+
253 inline bool operator== ( LoadProperties const & rhs ) const
+
254 {
+
255 if ( Name() != rhs.Name() ) return false;
+
256 if ( Type() != rhs.Type() ) return false;
+
257
+
258 if ( RealPowerLoad() != rhs.RealPowerLoad() ) return false;
+
259 if ( RealPowerLoadBound().Minimum() != rhs.RealPowerLoadBound().Minimum() ) return false;
+
260 if ( RealPowerLoadBound().Maximum() != rhs.RealPowerLoadBound().Maximum() ) return false;
+
261
+
262 if ( ReactivePowerLoad() != rhs.ReactivePowerLoad() ) return false;
+
263 if ( ReactivePowerLoadBound().Minimum() != rhs.ReactivePowerLoadBound().Minimum() ) return false;
+
264 if ( ReactivePowerLoadBound().Maximum() != rhs.ReactivePowerLoadBound().Maximum() ) return false;
+
265
+
266 return true;
+
267 }
+
+
269
+
270 private:
+
271#pragma mark MEMBER
+
274 Types::name name_;
+
275 TVertexType type_;
+
277
+
280 Types::real realPowerLoad_;
+
281 TBound realPowerLoadBound_;
+
285
+
288 Types::real reactivePowerLoad_;
+
291 TBound reactivePowerLoadBound_;
+
295};
+
+
296
+
297} // namespace egoa
+
298
+
299#endif // EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__LOAD_PROPERTIES_HPP
+ +
egoa::Bound::Minimum
TBound Minimum() const
Getter of the minimum of the bound.
Definition Bound.hpp:61
+
egoa::Bound::Maximum
TBound Maximum() const
Getter of the maximum of the bound.
Definition Bound.hpp:85
+
egoa::Vertices::LoadProperties
Class having all load properties.
Definition LoadProperties.hpp:24
+
egoa::Vertices::LoadProperties::Name
Types::name & Name()
Getter for the name of the vertex.
Definition LoadProperties.hpp:71
+
egoa::Vertices::LoadProperties::ReactivePowerLoadBound
TBound & ReactivePowerLoadBound()
Getter and setter for the reactive power demand bound in per unit (p.u.) nominal power (MVAr).
Definition LoadProperties.hpp:222
+
egoa::Vertices::LoadProperties::Name
Types::name Name() const
Getter and setter for the name of the vertex.
Definition LoadProperties.hpp:81
+
egoa::Vertices::LoadProperties::RealPowerLoad
Types::real RealPowerLoad() const
Getter for the real power demand set point in per unit (p.u.) nominal power (MW).
Definition LoadProperties.hpp:119
+ +
egoa::Vertices::LoadProperties::ReactivePowerLoadBound
TBound ReactivePowerLoadBound() const
Getter for the reactive power demand bound in per unit (p.u.) nominal power (MVAr).
Definition LoadProperties.hpp:207
+
egoa::Vertices::LoadProperties::ReactivePowerLoad
Types::real & ReactivePowerLoad()
Getter for the reactive power demand in per unit (p.u.) nominal power (MVAr).
Definition LoadProperties.hpp:193
+
egoa::Vertices::LoadProperties::RealPowerLoadBound
TBound RealPowerLoadBound() const
Getter for the real power demand bound in per unit (p.u.) nominal power (MW).
Definition LoadProperties.hpp:146
+ + +
egoa::Vertices::LoadProperties::operator!=
bool operator!=(LoadProperties const &rhs) const
Inequality comparator.
Definition LoadProperties.hpp:240
+
egoa::Vertices::LoadProperties::LoadProperties
LoadProperties(Types::name name)
Constructs the object.
Definition LoadProperties.hpp:52
+
egoa::Vertices::LoadProperties::LoadProperties
LoadProperties()
Constructs the object.
Definition LoadProperties.hpp:38
+
egoa::Vertices::LoadProperties::Type
TVertexType const & Type() const
Getter and setter for the type of the vertex.
Definition LoadProperties.hpp:101
+
egoa::Vertices::LoadProperties::Type
TVertexType & Type()
Getter for the type of the vertex.
Definition LoadProperties.hpp:91
+ +
egoa::Vertices::LoadProperties::ReactivePowerLoad
Types::real ReactivePowerLoad() const
Getter for the reactive power demand in per unit (p.u.) nominal power (MVAr).
Definition LoadProperties.hpp:179
+
egoa::Vertices::LoadProperties::RealPowerLoadBound
TBound & RealPowerLoadBound()
Getter and setter for the real power demand bound in per unit (p.u.) nominal power (MW).
Definition LoadProperties.hpp:160
+ + +
egoa::Vertices::LoadProperties::operator==
bool operator==(LoadProperties const &rhs) const
Equality comparator.
Definition LoadProperties.hpp:253
+
egoa::Vertices::LoadProperties::RealPowerLoad
Types::real & RealPowerLoad()
Getter and setter for the real power demand set point in per unit (p.u.) nominal power (MW).
Definition LoadProperties.hpp:132
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_m_s_t_8hpp_source.html b/_m_s_t_8hpp_source.html new file mode 100644 index 00000000..3cfd1370 --- /dev/null +++ b/_m_s_t_8hpp_source.html @@ -0,0 +1,186 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/SpanningTree/MST.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
MST.hpp
+
+
+
1/*
+
2 * MST.hpp
+
3 *
+
4 * Created on: Nov 11, 2018
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__SPANNING_TREE__MST_HPP
+
9#define EGOA__ALGORITHMS__SPANNING_TREE__MST_HPP
+
10
+
11#include <functional>
+
12#include <ostream>
+
13#include <utility>
+
14#include <vector>
+
15
+
16#include "Auxiliary/Constants.hpp"
+
17#include "Auxiliary/ExecutionPolicy.hpp"
+
18#include "Auxiliary/Types.hpp"
+
19
+
20#include "DataStructures/Graphs/Subgraph.hpp"
+
21
+
22namespace egoa {
+
37template< typename GraphType>
+
+
38class MST {
+
39 protected:
+
40 using TGraph = GraphType;
+
41 using TEdge = typename TGraph::TEdge;
+
42 using TComparator = std::function<bool(Types::edgeId, Types::edgeId)>;
+
43
+
44 public:
+
45 MST ( TGraph & graph,
+
46 TComparator comparator)
+
47 : graph_(graph)
+
48 , comparator_(std::move(comparator))
+
49 {}
+
50
+
51 virtual ~MST() {}
+
52
+
53 virtual void Run() = 0;
+
54
+
+
62 inline Subgraph<TGraph> const & Result() const
+
63 {
+
64 return spanningTree_;
+
65 }
+
+
66
+
67 friend std::ostream & operator<<( std::ostream & os, MST const & rhs )
+
68 {
+
69 auto & graph = rhs.spanningTree_.Graph();
+
70 for ( auto edgeId : rhs.spanningTree_.Edges() )
+
71 {
+
72 auto & edge = graph.EdgeAt(edgeId);
+
73 os << "(" << edge.Source() << ", " << edge.Target() << ");\n";
+
74 }
+
75 return os;
+
76 }
+
77
+
78 protected:
+
79
+
+
86 void SetResult(std::vector<Types::edgeId> && edges)
+
87 {
+
88 std::vector<Types::vertexId> vertices;
+
89 vertices.reserve(Graph().NumberOfVertices());
+
90 Graph().template for_all_vertex_identifiers<ExecutionPolicy::sequential>( [&vertices](Types::vertexId id)
+
91 {
+
92 vertices.push_back(id);
+
93 });
+
94
+
95 spanningTree_ = Subgraph<TGraph> ( & graph_, std::move(vertices), std::move(edges) );
+
96 }
+
+
97
+
100 inline GraphType const & Graph() const { return graph_; }
+
101 inline GraphType & Graph() { return graph_; }
+
102
+
103 inline TComparator const & Comparator() const { return comparator_; }
+
105
+
106 private:
+
107 GraphType & graph_;
+
108 TComparator comparator_;
+
109 Subgraph<TGraph> spanningTree_{&graph_, {}, {}};
+
110};
+
+
111
+
112} // namespace egoa
+
113
+
114#endif // EGOA__ALGORITHMS__SPANNING_TREE__MST_HPP
+
egoa::MST
Base class for minimum spanning tree algorithms.
Definition MST.hpp:38
+
egoa::MST::Result
Subgraph< TGraph > const & Result() const
Returns the caluclated spanning tree after Run() has been called.
Definition MST.hpp:62
+
egoa::MST::SetResult
void SetResult(std::vector< Types::edgeId > &&edges)
Builds a subgraph object representing the spanning tree given by the edges.
Definition MST.hpp:86
+
egoa::MST::graph_
GraphType & graph_
Definition MST.hpp:107
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_mapping_binary_heap_8hpp_source.html b/_mapping_binary_heap_8hpp_source.html new file mode 100644 index 00000000..f1ffb32a --- /dev/null +++ b/_mapping_binary_heap_8hpp_source.html @@ -0,0 +1,543 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/MappingBinaryHeap.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
MappingBinaryHeap.hpp
+
+
+
1/*
+
2 * MappingBinaryHeap.hpp
+
3 *
+
4 * Created on: Feb 19, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__MAPPING_BINARY_HEAP_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__MAPPING_BINARY_HEAP_HPP
+
10
+
11#include "Auxiliary/Auxiliary.hpp"
+
12#include "Auxiliary/ContainerLoop.hpp"
+
13#include "Auxiliary/ExecutionPolicy.hpp"
+
14
+
15#include "Exceptions/Assertions.hpp"
+
16
+
17#include <functional>
+
18#include <unordered_map>
+
19#include <utility>
+
20#include <vector>
+
21
+
22namespace egoa {
+
23
+
69template<typename ElementType,
+
70 typename KeyType,
+
71 typename MapType = std::unordered_map<ElementType, Types::index>>
+
+
72class MappingBinaryHeap {
+
73public:
+
77 using TElement = ElementType;
+
81 using TKey = KeyType;
+
85 using TMap = MapType;
+
89 using TIterator = typename std::vector<std::pair<TElement, TKey>>::const_iterator;
+
93 using TComparator = std::function<bool(TKey const &, TKey const &)>;
+
94
+
97
+
+
104 MappingBinaryHeap(TComparator comparator = std::less<TKey>(),
+
105 TMap map = TMap())
+
106 : elementKeyPairs_(),
+
107 map_(std::move(map)),
+
108 comparator_(std::move(comparator))
+
109 {}
+
+
110
+
+
118 MappingBinaryHeap(std::vector<std::pair<TElement, TKey>> elementsKeyPairs,
+
119 TComparator comparator = std::less<TKey>(),
+
120 TMap map = TMap())
+
121 : elementKeyPairs_(std::move(elementsKeyPairs)),
+
122 map_(std::move(map)),
+
123 comparator_(std::move(comparator))
+
124 {
+
125 MakeHeapProperty();
+
126 }
+
+
127
+
138 template<typename It>
+
+
139 MappingBinaryHeap(It first,
+
140 It last,
+
141 TComparator comparator = std::less<TKey>(),
+
142 TMap map = TMap())
+
143 : elementKeyPairs_(first, last),
+
144 map_(std::move(map)),
+
145 comparator_(std::move(comparator))
+
146 {}
+
+
148
+
149#pragma mark ELEMENT_ACCESS
+
152
+
+
159 std::pair<TElement, TKey> const & Top() const {
+
160 USAGE_ASSERT(!Empty());
+
161 return elementKeyPairs_.front();
+
162 }
+
+
163
+
+
171 TElement const & TopElement() const {
+
172 USAGE_ASSERT(!Empty());
+
173 return elementKeyPairs_.front().first;
+
174 }
+
+
175
+
+
183 TKey const & TopKey() const {
+
184 USAGE_ASSERT(!Empty());
+
185 return elementKeyPairs_.front().second;
+
186 }
+
+
187
+
+
197 TKey const & KeyOf(TElement const & element) const {
+
198 USAGE_ASSERT ( HasKeyOf( element ) );
+
199 return KeyAt(IndexOf(element));
+
200 }
+
+
201
+
+
209 bool HasKeyOf(TElement const & element) const {
+
210 return map_.find(element) != map_.end();
+
211 }
+
+
213
+
214#pragma mark ADD_ELEMENTS
+
217
+
+
225 void Insert(TElement element, TKey key) {
+
226 USAGE_ASSERT(!HasKeyOf(element));
+
227
+
228 Insert(std::make_pair(std::move(element), std::move(key)));
+
229 }
+
+
230
+
+
238 void Insert(std::pair<TElement, TKey> pair) {
+
239 USAGE_ASSERT(!HasKeyOf(pair.first));
+
240
+
241 elementKeyPairs_.push_back(std::move(pair));
+
242 Types::index index = MaximumIndex();
+
243 map_[elementKeyPairs_.back().first] = index;
+
244
+
245 SiftUp();
+
246 }
+
+
247
+
+
258 MappingBinaryHeap & operator+=(std::pair<TElement, TKey> pair) {
+
259 Insert(std::move(pair));
+
260 return *this;
+
261 }
+
+
262
+
278
+
283 template<typename... Args>
+
+
284 void Emplace(Args && ... args) {
+
285 elementKeyPairs_.emplace_back(std::forward<Args>(args)...);
+
286 Types::index index = MaximumIndex();
+
287 map_[elementKeyPairs_.back().first] = index;
+
288
+
289 SiftUp();
+
290 }
+
+
292
+
295#pragma mark REMOVE_ELEMENTS
+
+
303 std::pair<TElement, TKey> DeleteTop() {
+
304 USAGE_ASSERT(!Empty());
+
305 ESSENTIAL_ASSERT(ComplyHeapProperty());
+
306
+
307 Swap(0, MaximumIndex());
+
308
+
309 auto top = std::move(elementKeyPairs_.back());
+
310 elementKeyPairs_.pop_back();
+
311 map_.erase(top.first);
+
312
+
313 if (!Empty()) SiftDown();
+
314
+
315 return top;
+
316 }
+
+
317
+
+
323 void Pop() {
+
324 USAGE_ASSERT(!Empty());
+
325 ESSENTIAL_ASSERT(ComplyHeapProperty());
+
326
+
327 Swap(0, MaximumIndex());
+
328
+
329 map_.erase(elementKeyPairs_.back().first);
+
330 elementKeyPairs_.pop_back();
+
331
+
332 if (!Empty()) SiftDown();
+
333 }
+
+
334
+
+
342 std::pair<TElement, TKey> Delete(TElement const & element) {
+
343 USAGE_ASSERT(HasKeyOf(element));
+
344
+
345 Types::index index = IndexOf(element);
+
346 Swap(index, MaximumIndex());
+
347
+
348 auto deleted = std::move(elementKeyPairs_.back());
+
349 elementKeyPairs_.pop_back();
+
350 map_.erase(element);
+
351
+
352 if (!Empty() && index <= MaximumIndex()) {
+
353 SiftDown(index);
+
354 SiftUp(index);
+
355 }
+
356
+
357 return deleted;
+
358 }
+
+
359
+
+
363 void Clear() {
+
364 elementKeyPairs_.clear();
+
365 map_.clear();
+
366 }
+
+
368
+
371#pragma mark CHANGE_ELEMENTS
+
+
380 void ChangeKey(const TElement & element, TKey newKey) {
+
381 USAGE_ASSERT(HasKeyOf(element));
+
382 ESSENTIAL_ASSERT(ComplyHeapProperty());
+
383
+
384 Types::index index = IndexOf(element);
+
385 KeyAt(index) = std::move(newKey);
+
386 SiftUp(index);
+
387 SiftDown(index);
+
388
+
389 ESSENTIAL_ASSERT(ComplyHeapProperty());
+
390 }
+
+
392
+
395#pragma mark CAPACITY
+
+
401 bool Empty() const {
+
402 return elementKeyPairs_.empty();
+
403 }
+
+
404
+
+
410 Types::count Size() const {
+
411 return elementKeyPairs_.size();
+
412 }
+
+
414
+
415#pragma COMPARATOR
+
416
+
419
+
424 inline std::function<bool (TKey const &, TKey const &)>
+
+
425 const & Comparator() const
+
426 {
+
427 return comparator_;
+
428 }
+
+
429
+
+
442 inline void Comparator( std::function<bool (TKey const &, TKey const &)> comparator )
+
443 {
+
444 comparator_ = comparator;
+
445 MakeHeapProperty();
+
446 }
+
+
448
+
451#pragma mark ITERATORS
+
452 TIterator begin() const { return elementKeyPairs_.cbegin(); }
+
453 TIterator end() const { return elementKeyPairs_.cend(); }
+
455
+
456
+
457#pragma mark LOOPS
+
471 template<ExecutionPolicy Policy, typename FUNCTION>
+
+
472 void for_all_elements( FUNCTION function ) const {
+
473 internal::ContainerLoop<Policy>::for_each(elementKeyPairs_, function);
+
474 }
+
+
475
+
476#pragma mark SWAP
+
+
483 inline friend void swap(MappingBinaryHeap & first, MappingBinaryHeap & second) {
+
484 using std::swap;
+
485 swap(first.elementKeyPairs_, second.elementKeyPairs_);
+
486 swap(first.map_, second.map_);
+
487 }
+
+
488
+
489private:
+
490#pragma mark ACCESSORS
+
491 inline TElement & ElementAt( Types::index index ) { ESSENTIAL_ASSERT( index < Size() ); return elementKeyPairs_[index].first; }
+
492 inline TElement const & ElementAt( Types::index index ) const { ESSENTIAL_ASSERT( index < Size() ); return elementKeyPairs_[index].first; }
+
493 inline TKey & KeyAt( Types::index index ) { ESSENTIAL_ASSERT( index < Size() ); return elementKeyPairs_[index].second; }
+
494 inline TKey const & KeyAt( Types::index index ) const { ESSENTIAL_ASSERT( index < Size() ); return elementKeyPairs_[index].second; }
+
495
+
496 inline Types::index LeftChildIdOf( Types::index index ) const { return ( 2 * index + 1 ); }
+
497 inline Types::index RightChildIdOf( Types::index index ) const { return ( 2 * index + 2 ); }
+
498 inline bool HasChildren( Types::index index ) const { return LeftChildIdOf(index) < Size(); }
+
499 inline bool HasLeftChild( Types::index index ) const { return LeftChildIdOf(index) < Size(); }
+
500 inline bool HasRightChild( Types::index index ) const { return RightChildIdOf(index) < Size(); }
+
501 inline Types::index ParentIdOf( Types::index index ) const { return floor( ( index - 1 ) / 2 ); }
+
502 inline bool HasParent( Types::index index ) const { return index > 0; }
+
503
+
504 Types::index IndexOf(TElement const & element) const {
+
505 return map_.at(element);
+
506 }
+
507
+
513 Types::index MaximumIndex() const { return elementKeyPairs_.size() - 1; }
+
514
+
515#pragma mark SIFTS
+
516
+
+
522 void SiftUp() {
+
523 ESSENTIAL_ASSERT(!Empty());
+
524 SiftUp(MaximumIndex());
+
525 }
+
+
526
+
+
534 void SiftUp(Types::index index) {
+
535 ESSENTIAL_ASSERT(index < Size());
+
536 while (HasParent(index) && Comparator()( KeyAt(index), KeyAt(ParentIdOf(index)) )) {
+
537 Types::index parentIndex = ParentIdOf(index);
+
538 Swap(index, parentIndex);
+
539 index = parentIndex;
+
540 }
+
541 }
+
+
542
+
+
548 void SiftDown() {
+
549 ESSENTIAL_ASSERT(!Empty());
+
550 SiftDown(0);
+
551 }
+
+
552
+
+
560 void SiftDown(Types::index index) {
+
561 ESSENTIAL_ASSERT(index < Size());
+
562 while(HasChildren(index)) {
+
563 Types::index childIndex = SelectSwappableChildAt(index);
+
564 if (!Comparator()( KeyAt(childIndex), KeyAt(index) )) return;
+
565 Swap(index, childIndex);
+
566 index = childIndex;
+
567 }
+
568 }
+
+
569
+
570#pragma mark SWAP
+
571
+
+
579 void Swap(Types::index first, Types::index second) {
+
580 using std::swap;
+
581 swap(ElementAt(first), ElementAt(second));
+
582 swap(KeyAt(first), KeyAt(second));
+
583
+
584 map_[ElementAt(first)] = first;
+
585 map_[ElementAt(second)] = second;
+
586 }
+
+
587
+
+
596 inline Types::index SelectSwappableChildAt ( Types::index index ) const {
+
597 ESSENTIAL_ASSERT( HasChildren(index) );
+
598 if ( !HasRightChild(index) ) {
+
599 return LeftChildIdOf( index );
+
600 }
+
601
+
602 ESSENTIAL_ASSERT( HasRightChild(index) );
+
603 Types::index leftChildId = LeftChildIdOf(index);
+
604 Types::index rightChildId = RightChildIdOf(index);
+
605 if ( Comparator()( KeyAt(leftChildId), KeyAt(rightChildId) ) ) {
+
606 return LeftChildIdOf( index );
+
607 }
+
608 return RightChildIdOf( index );
+
609 }
+
+
610
+
611#pragma mark HEAP_PROPERTY_METHODS
+
+
617 bool ComplyHeapProperty() const {
+
618 // We only need to check the indices until Size() / 2 because all other elements do
+
619 // not have children.
+
620 for (Types::index index = 0; index < Size() / 2; ++index) {
+
621 if (!ComplyHeapProperty(index)) return false;
+
622 }
+
623 return true;
+
624 }
+
+
625
+
+
635 bool ComplyHeapProperty(Types::index index) const {
+
636 if (!HasChildren(index)) return true;
+
637 if (Comparator()( KeyAt(LeftChildIdOf(index)), KeyAt(index) )) return false;
+
638 if (!HasRightChild(index)) return true;
+
639 return !Comparator()(KeyAt(RightChildIdOf(index)), KeyAt(index));
+
640 }
+
+
641
+
+
645 void MakeHeapProperty() {
+
646 for ( Types::rcount counter = Size() / 2 - 1;
+
647 counter >= 0;
+
648 --counter )
+
649 {
+
650 SiftDown( counter );
+
651 }
+
652 ESSENTIAL_ASSERT( ComplyHeapProperty() );
+
653 }
+
+
654
+
655#pragma mark MEMBERS
+
660 std::vector<std::pair<TElement, TKey>> elementKeyPairs_;
+
664 TMap map_;
+
668 TComparator comparator_;
+
669};
+
+
670
+
671} // namespace egoa
+
672
+
673
+
674
+
675#endif // EGOA__DATA_STRUCTURES__CONTAINER__MAPPING_BINARY_HEAP_HPP
+
egoa::MappingBinaryHeap
Class for binary heap data structure, in which elements are sorted by keys.
Definition MappingBinaryHeap.hpp:72
+
egoa::MappingBinaryHeap::Delete
std::pair< TElement, TKey > Delete(TElement const &element)
Deletes an element from the heap.
Definition MappingBinaryHeap.hpp:342
+
egoa::MappingBinaryHeap::Top
std::pair< TElement, TKey > const & Top() const
The element and the key at the top of the heap.
Definition MappingBinaryHeap.hpp:159
+
egoa::MappingBinaryHeap::HasKeyOf
bool HasKeyOf(TElement const &element) const
Determines if the element exist in the heap.
Definition MappingBinaryHeap.hpp:209
+
egoa::MappingBinaryHeap::operator+=
MappingBinaryHeap & operator+=(std::pair< TElement, TKey > pair)
Inserts the element with the given key.
Definition MappingBinaryHeap.hpp:258
+
egoa::MappingBinaryHeap::elementKeyPairs_
std::vector< std::pair< TElement, TKey > > elementKeyPairs_
Pairs of elements and their keys; ordered such that the heap property is satisfied.
Definition MappingBinaryHeap.hpp:660
+
egoa::MappingBinaryHeap::map_
TMap map_
The mapping from elements to indices in elementKeyPairs_.
Definition MappingBinaryHeap.hpp:664
+
egoa::MappingBinaryHeap::for_all_elements
void for_all_elements(FUNCTION function) const
Iterates over all elements in the heap.
Definition MappingBinaryHeap.hpp:472
+
egoa::MappingBinaryHeap::MappingBinaryHeap
MappingBinaryHeap(It first, It last, TComparator comparator=std::less< TKey >(), TMap map=TMap())
Constructs the heap filled with the element-key-pairs.
Definition MappingBinaryHeap.hpp:139
+
egoa::MappingBinaryHeap::Pop
void Pop()
Deletes the top element.
Definition MappingBinaryHeap.hpp:323
+
egoa::MappingBinaryHeap::ComplyHeapProperty
bool ComplyHeapProperty() const
Whether the heap property is fulfilled.
Definition MappingBinaryHeap.hpp:617
+
egoa::MappingBinaryHeap::SelectSwappableChildAt
Types::index SelectSwappableChildAt(Types::index index) const
Selects the smallest child, where smallest is measured according to the comparator.
Definition MappingBinaryHeap.hpp:596
+
egoa::MappingBinaryHeap::DeleteTop
std::pair< TElement, TKey > DeleteTop()
Deletes the top element and returns it and its key.
Definition MappingBinaryHeap.hpp:303
+
egoa::MappingBinaryHeap::ComplyHeapProperty
bool ComplyHeapProperty(Types::index index) const
Whether the element at position index is smaller than its childred.
Definition MappingBinaryHeap.hpp:635
+
egoa::MappingBinaryHeap::Swap
void Swap(Types::index first, Types::index second)
Swaps the elements and keys at the indices first and second and updates the mapping.
Definition MappingBinaryHeap.hpp:579
+
egoa::MappingBinaryHeap::Comparator
std::function< bool(TKey const &, TKey const &)> const & Comparator() const
The comparator.
Definition MappingBinaryHeap.hpp:425
+
egoa::MappingBinaryHeap::TMap
MapType TMap
The type of the mapping from elements to indices.
Definition MappingBinaryHeap.hpp:85
+
egoa::MappingBinaryHeap::ChangeKey
void ChangeKey(const TElement &element, TKey newKey)
Changes the key of the element.
Definition MappingBinaryHeap.hpp:380
+
egoa::MappingBinaryHeap::Size
Types::count Size() const
The number of elements in the heap.
Definition MappingBinaryHeap.hpp:410
+
egoa::MappingBinaryHeap::SiftUp
void SiftUp(Types::index index)
Sifts the element at index up.
Definition MappingBinaryHeap.hpp:534
+
egoa::MappingBinaryHeap::MaximumIndex
Types::index MaximumIndex() const
The largest index of elements in the heap.
Definition MappingBinaryHeap.hpp:513
+
egoa::MappingBinaryHeap::SiftDown
void SiftDown(Types::index index)
Sifts the element at index down.
Definition MappingBinaryHeap.hpp:560
+
egoa::MappingBinaryHeap::MappingBinaryHeap
MappingBinaryHeap(std::vector< std::pair< TElement, TKey > > elementsKeyPairs, TComparator comparator=std::less< TKey >(), TMap map=TMap())
Constructs an heap containing the given elements.
Definition MappingBinaryHeap.hpp:118
+
egoa::MappingBinaryHeap::SiftUp
void SiftUp()
Sifts the last element in the heap up.
Definition MappingBinaryHeap.hpp:522
+
egoa::MappingBinaryHeap::Empty
bool Empty() const
Whether the heap is empty.
Definition MappingBinaryHeap.hpp:401
+
egoa::MappingBinaryHeap::TComparator
std::function< bool(TKey const &, TKey const &)> TComparator
The type of the comparator.
Definition MappingBinaryHeap.hpp:93
+
egoa::MappingBinaryHeap::Comparator
void Comparator(std::function< bool(TKey const &, TKey const &)> comparator)
Changes the comparator.
Definition MappingBinaryHeap.hpp:442
+
egoa::MappingBinaryHeap::TIterator
typename std::vector< std::pair< TElement, TKey > >::const_iterator TIterator
The type of the iterators.
Definition MappingBinaryHeap.hpp:89
+
egoa::MappingBinaryHeap::MakeHeapProperty
void MakeHeapProperty()
Ensures that the heap property is satisfied.
Definition MappingBinaryHeap.hpp:645
+
egoa::MappingBinaryHeap::TKey
KeyType TKey
The type of the keys.
Definition MappingBinaryHeap.hpp:81
+
egoa::MappingBinaryHeap::Clear
void Clear()
Removes all elements from the heap.
Definition MappingBinaryHeap.hpp:363
+
egoa::MappingBinaryHeap::Emplace
void Emplace(Args &&... args)
Constructs an element-key-pair inplace.
Definition MappingBinaryHeap.hpp:284
+
egoa::MappingBinaryHeap::swap
friend void swap(MappingBinaryHeap &first, MappingBinaryHeap &second)
Swaps the contents of two heaps.
Definition MappingBinaryHeap.hpp:483
+
egoa::MappingBinaryHeap::SiftDown
void SiftDown()
Sifts the first element in the heap down.
Definition MappingBinaryHeap.hpp:548
+
egoa::MappingBinaryHeap::comparator_
TComparator comparator_
The comparator used to compare the keys.
Definition MappingBinaryHeap.hpp:668
+
egoa::MappingBinaryHeap::Insert
void Insert(TElement element, TKey key)
Inserts the element with the given key.
Definition MappingBinaryHeap.hpp:225
+
egoa::MappingBinaryHeap::KeyOf
TKey const & KeyOf(TElement const &element) const
The key of the element.
Definition MappingBinaryHeap.hpp:197
+
egoa::MappingBinaryHeap::TopKey
TKey const & TopKey() const
The key of the element at the top of the heap.
Definition MappingBinaryHeap.hpp:183
+
egoa::MappingBinaryHeap::MappingBinaryHeap
MappingBinaryHeap(TComparator comparator=std::less< TKey >(), TMap map=TMap())
Constructs an empty heap, in which the elements are sorted by their keys in increasing order.
Definition MappingBinaryHeap.hpp:104
+
egoa::MappingBinaryHeap::TopElement
TElement const & TopElement() const
The element at the top of the heap.
Definition MappingBinaryHeap.hpp:171
+
egoa::MappingBinaryHeap::TElement
ElementType TElement
The type of the elements in the heap.
Definition MappingBinaryHeap.hpp:77
+
egoa::MappingBinaryHeap::Insert
void Insert(std::pair< TElement, TKey > pair)
Inserts the element with the given key.
Definition MappingBinaryHeap.hpp:238
+
egoa
Definition Color.cpp:15
+
egoa::internal::ContainerLoop
Loops over containers.
Definition ContainerLoop.hpp:28
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_mathematical_model_2_types_8hpp_source.html b/_mathematical_model_2_types_8hpp_source.html new file mode 100644 index 00000000..7f5c3079 --- /dev/null +++ b/_mathematical_model_2_types_8hpp_source.html @@ -0,0 +1,584 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/MathematicalModel/Types.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Types.hpp
+
+
+
1/*
+
2 * Types.hpp
+
3 *
+
4 * Created on: May 14, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__MATHEMATICAL_MODEL__TYPE_HPP
+
9#define EGOA__MATHEMATICAL_MODEL__TYPE_HPP
+
10
+
11#include "Exceptions/Assertions.hpp"
+
12
+
13// include only if cplex is available
+
14#ifdef CPLEX_AVAILABLE
+
15 #include <ilconcert/iloexpression.h>
+
16 #include <ilcplex/ilocplexi.h>
+
17#endif
+
18
+
19// include only if Gurobi is available
+
20#ifdef GUROBI_AVAILABLE
+
21 #include "gurobi_c++.h"
+
22#endif
+
23
+
24
+
25namespace egoa::Solvers {
+
26
+
27#pragma mark SOLVER_TYPES
+
28
+
32enum class Status {
+
33 loaded = 0
+
34 , feasible = 1
+
35 , optimal = 2
+
36 , infeasible = 3
+
37 , inf_or_unb = 4
+
38 , unbounded = 5
+
39 , cutoff = 6
+
40 , iteration_limit = 7
+
41 , node_limit = 8
+
42 , time_limit = 9
+
43 , solution_limit = 10
+
44 , interrupted = 11
+
45 , numeric = 12
+
46 , suboptimal = 13
+
47 , inprogress = 14
+
48 , user_obj_limit = 15
+
49 , error = 16
+
50 , unknown = 99
+
51};
+
52
+
53enum class VariableType {
+
54 continuous = 0
+
55 , semicontinuous = 1
+
56 , binary = 2
+
57 , integer = 3
+
58 , semiinteger = 4
+
59 , unknown = 99
+
60};
+
61
+
62enum class ObjectiveSense {
+
63 minimize = 0
+
64 , maximize = 1
+
65 , unknown = 99
+
66};
+
67
+
68
+
69enum class Algorithm {
+
70 automatical = 0
+
71 , primal = 1
+
72 , dual = 2
+
73 , network = 3
+
74 , barrier = 4
+
75 , sifting = 5
+
76 , concurrent = 6
+
77 , feasOpt = 7
+
78 , mip = 8
+
79 , unknown = 99
+
80};
+
81
+
82enum class NodeFileStrategy {
+
83 standard = 0
+
84 , inMemoryCompressed = 1
+
85 , onDisk = 2
+
86 , onDiskCompressed = 3
+
87 , unknown = 99
+
88};
+
89
+
90#pragma mark OBJECTIVE_SENSE_CONVERSION
+
91
+
92inline ObjectiveSense GurobiToObjectiveSense ( Types::integer const modelSense )
+
93{
+
94 if ( 1 == modelSense ) {
+
95 return ObjectiveSense::minimize;
+
96 } else if ( -1 == modelSense ) {
+
97 return ObjectiveSense::maximize;
+
98 } else {
+
99 return ObjectiveSense::unknown;
+
100 }
+
101}
+
102
+
103inline Types::integer ObjectiveSenseToGurobi ( ObjectiveSense const & modelSense )
+
104{
+
105 if ( ObjectiveSense::minimize == modelSense ) {
+
106 return 1;
+
107 } else if ( ObjectiveSense::maximize == modelSense ) {
+
108 return -1;
+
109 } else {
+
110 return 1;
+
111 }
+
112}
+
113
+
114#ifdef CPLEX_AVAILABLE
+
115//https://www.ibm.com/support/knowledgecenter/SS9UKU_12.6.0/com.ibm.cplex.zos.help/refcppcplex/html/enumerations/IloObjective_Sense.html
+
116inline ObjectiveSense CplexToObjectiveSense ( Types::integer const modelSense )
+
117{
+
118 if ( 1 == modelSense ) {
+
119 return ObjectiveSense::minimize;
+
120 } else if ( -1 == modelSense ) {
+
121 return ObjectiveSense::maximize;
+
122 } else {
+
123 return ObjectiveSense::unknown;
+
124 }
+
125}
+
126
+
127inline Types::integer ObjectiveSenseToCplex ( ObjectiveSense const & modelSense )
+
128{
+
129 if ( ObjectiveSense::minimize == modelSense ) {
+
130 return 1;
+
131 } else if ( ObjectiveSense::maximize == modelSense ) {
+
132 return -1;
+
133 } else {
+
134 return 1;
+
135 }
+
136}
+
137#endif // CPLEX_AVAILABLE
+
138
+
139#pragma mark VARIABLE_TYPE_CONVERSION
+
140
+
141#ifdef GUROBI_AVAILABLE
+
142
+
143inline VariableType GurobiToVariableType ( char const variableType )
+
144{
+
145 if ( GRB_CONTINUOUS == variableType ) { // "C"
+
146 return VariableType::continuous;
+
147 } else if ( GRB_SEMICONT == variableType ) {
+
148 return VariableType::semicontinuous;
+
149 } else if ( GRB_BINARY == variableType ) { // "B"
+
150 return VariableType::binary;
+
151 } else if ( GRB_INTEGER == variableType ) {
+
152 return VariableType::integer;
+
153 } else if ( GRB_SEMIINT == variableType ) {
+
154 return VariableType::semiinteger;
+
155 } else {
+
156 return VariableType::unknown;
+
157 }
+
158}
+
159
+
160inline char VariableTypeToGurobi ( VariableType const & variableType )
+
161{
+
162 if ( VariableType::continuous == variableType ) {
+
163 return GRB_CONTINUOUS;
+
164 } else if ( VariableType::semicontinuous == variableType ) {
+
165 return GRB_SEMICONT;
+
166 } else if ( VariableType::binary == variableType ) {
+
167 return GRB_BINARY;
+
168 } else if ( VariableType::integer == variableType ) {
+
169 return GRB_INTEGER;
+
170 } else if ( VariableType::semiinteger == variableType ) {
+
171 return GRB_SEMIINT;
+
172 } else {
+
173 USAGE_ASSERT(false && "Unknown Variable Type");
+
174 }
+
175}
+
176#endif // GUROBI_AVAILABLE
+
177
+
178#ifdef CPLEX_AVAILABLE
+
179
+
180// https://www.ibm.com/support/knowledgecenter/SS9UKU_12.6.0/com.ibm.cplex.zos.help/refcppcplex/html/enumerations/IloNumVar_Type.html
+
181inline VariableType CplexToVariableType ( IloNumVar::Type variableType )
+
182{
+
183 if ( ILOFLOAT == variableType ) {
+
184 return VariableType::continuous;
+
185 } else if ( ILOBOOL == variableType ) {
+
186 return VariableType::binary;
+
187 } else if ( ILOINT == variableType ) {
+
188 return VariableType::integer;
+
189 } else {
+
190 return VariableType::unknown;
+
191 }
+
192}
+
193
+
194// https://www.ibm.com/support/knowledgecenter/SS9UKU_12.6.0/com.ibm.cplex.zos.help/refcppcplex/html/enumerations/IloNumVar_Type.html
+
195inline IloNumVar::Type VariableTypeToCplex ( VariableType const & variableType )
+
196{
+
197 if ( VariableType::continuous == variableType ) {
+
198 return ILOFLOAT;
+
199 } else if ( VariableType::semicontinuous == variableType ) {
+
200 USAGE_ASSERT(false && "Semi-continuous does not exist as cplex type");
+
201 } else if ( VariableType::binary == variableType ) {
+
202 return ILOBOOL;
+
203 } else if ( VariableType::integer == variableType ) {
+
204 return ILOINT;
+
205 } else if ( VariableType::semiinteger == variableType ) {
+
206 USAGE_ASSERT(false && "Semi-integer does not exist as cplex type");
+
207 } else {
+
208 USAGE_ASSERT(false && "Unknown Variable Type");
+
209 }
+
210}
+
211
+
212#endif // CPLEX_AVAILABLE
+
213
+
214#pragma mark SOLVER_STATUS_CONVERSION
+
215
+
216inline Types::string SolverStatusToString ( Status const & status )
+
217{
+
218 if ( Status::loaded == status ) {
+
219 return "loaded";
+
220 } else if ( Status::optimal == status ) {
+
221 return "optimal";
+
222 } else if ( Status::infeasible == status ) {
+
223 return "infeasible";
+
224 } else if ( Status::inf_or_unb == status ) {
+
225 return "inf_or_unb";
+
226 } else if ( Status::unbounded == status ) {
+
227 return "unbounded";
+
228 } else if ( Status::cutoff == status ) {
+
229 return "cutoff";
+
230 } else if ( Status::iteration_limit == status ) {
+
231 return "iteration_limit";
+
232 } else if ( Status::node_limit == status ) {
+
233 return "node_limit";
+
234 } else if ( Status::time_limit == status ) {
+
235 return "time_limit";
+
236 } else if ( Status::solution_limit == status ) {
+
237 return "solution_limit";
+
238 } else if ( Status::interrupted == status ) {
+
239 return "interrupted";
+
240 } else if ( Status::numeric == status ) {
+
241 return "numeric";
+
242 } else if ( Status::suboptimal == status ) {
+
243 return "suboptimal";
+
244 } else if ( Status::inprogress == status ) {
+
245 return "inprogress";
+
246 } else if ( Status::user_obj_limit == status ) {
+
247 return "user_obj_limit";
+
248 } else {
+
249 return "unknown";
+
250 }
+
251}
+
252
+
253inline Status StringToSolverStatus ( Types::string const & status )
+
254{
+
255 if ( "loaded" == status ) {
+
256 return Status::loaded;
+
257 } else if ( "optimal" == status ) {
+
258 return Status::optimal;
+
259 } else if ( "infeasible" == status ) {
+
260 return Status::infeasible;
+
261 } else if ( "inf_or_unb" == status ) {
+
262 return Status::inf_or_unb;
+
263 } else if ( "unbounded" == status ) {
+
264 return Status::unbounded;
+
265 } else if ( "cutoff" == status ) {
+
266 return Status::cutoff;
+
267 } else if ( "iteration_limit" == status ) {
+
268 return Status::iteration_limit;
+
269 } else if ( "node_limit" == status ) {
+
270 return Status::node_limit;
+
271 } else if ( "time_limit" == status ) {
+
272 return Status::time_limit;
+
273 } else if ( "solution_limit" == status ) {
+
274 return Status::solution_limit;
+
275 } else if ( "interrupted" == status ) {
+
276 return Status::interrupted;
+
277 } else if ( "numeric" == status ) {
+
278 return Status::numeric;
+
279 } else if ( "suboptimal" == status ) {
+
280 return Status::suboptimal;
+
281 } else if ( "inprogress" == status ) {
+
282 return Status::inprogress;
+
283 } else if ( "user_obj_limit" == status ) {
+
284 return Status::user_obj_limit;
+
285 } else {
+
286 return Status::unknown;
+
287 }
+
288}
+
289
+
290#ifdef GUROBI_AVAILABLE
+
291
+
292inline Status GurobiToSolverStatus ( Types::count const & status )
+
293{
+
294 if ( GRB_LOADED == status ) {
+
295 return Status::loaded;
+
296 } else if ( GRB_OPTIMAL == status ) { // 2
+
297 return Status::optimal;
+
298 } else if ( GRB_INFEASIBLE == status ) { // 3
+
299 return Status::infeasible;
+
300 } else if ( GRB_INF_OR_UNBD == status ) { // 4
+
301 return Status::inf_or_unb;
+
302 } else if ( GRB_UNBOUNDED == status ) { // 5
+
303 return Status::unbounded;
+
304 } else if ( GRB_CUTOFF == status ) { // 6
+
305 return Status::cutoff;
+
306 } else if ( GRB_ITERATION_LIMIT == status ) { // 7
+
307 return Status::iteration_limit;
+
308 } else if ( GRB_NODE_LIMIT == status ) { // 8
+
309 return Status::node_limit;
+
310 } else if ( GRB_TIME_LIMIT == status ) { // 9
+
311 return Status::time_limit;
+
312 } else if ( GRB_SOLUTION_LIMIT == status ) { // 10
+
313 return Status::solution_limit;
+
314 } else if ( GRB_INTERRUPTED == status ) { // 11
+
315 return Status::interrupted;
+
316 } else if ( GRB_NUMERIC == status ) { // 12
+
317 return Status::numeric;
+
318 } else if ( GRB_SUBOPTIMAL == status ) { // 13
+
319 return Status::suboptimal;
+
320 } else if ( GRB_INPROGRESS == status ) { // 14
+
321 return Status::inprogress;
+
322 } else if ( GRB_USER_OBJ_LIMIT == status ) { // 15
+
323 return Status::user_obj_limit;
+
324 } else {
+
325 return Status::unknown;
+
326 }
+
327}
+
328#endif // GUROBI_AVAILABLE
+
329
+
330#ifdef CPLEX_AVAILABLE
+
331//https://www.ibm.com/support/knowledgecenter/SS9UKU_12.6.0/com.ibm.cplex.zos.help/refcppcplex/html/enumerations/IloAlgorithm_Status.html
+
332inline Status CplexToSolverStatus ( IloAlgorithm::Status const & status )
+
333{
+
334 if ( IloAlgorithm::Status::Feasible == status ) {
+
335 return Status::feasible;
+
336 } else if ( IloAlgorithm::Status::Optimal == status ) {
+
337 return Status::optimal;
+
338 } else if ( IloAlgorithm::Status::Infeasible == status ) {
+
339 return Status::infeasible;
+
340 } else if ( IloAlgorithm::Status::InfeasibleOrUnbounded == status ) {
+
341 return Status::inf_or_unb;
+
342 } else if ( IloAlgorithm::Status::Unbounded == status ) {
+
343 return Status::unbounded;
+
344 } else if ( IloAlgorithm::Status::Error == status ) {
+
345 return Status::error;
+
346 } else if ( IloAlgorithm::Status::Unknown == status ) {
+
347 return Status::unknown;
+
348 } else {
+
349 return Status::unknown;
+
350 }
+
351}
+
352#endif // CPLEX_AVAILABLE
+
353
+
354#pragma mark ALGORITHM_CONVERSION
+
355
+
356#ifdef CPLEX_AVAILABLE
+
357// https://www.ibm.com/support/knowledgecenter/SSSA5P_12.8.0/ilog.odms.cplex.help/refcppcplex/html/classes/IloCplex.html
+
358inline Algorithm CplexToAlgorithm ( IloCplex::Algorithm const algorithm )
+
359{
+
360 if ( IloCplex::Auto == static_cast<IloCplex::WriteLevelType>( algorithm ) ) {
+
361 return Algorithm::automatical;
+
362 } else if ( IloCplex::Primal == algorithm ) {
+
363 return Algorithm::primal;
+
364 } else if ( IloCplex::Dual == algorithm ) {
+
365 return Algorithm::dual;
+
366 } else if ( IloCplex::Network == algorithm ) {
+
367 return Algorithm::network;
+
368 } else if ( IloCplex::Barrier == algorithm ) {
+
369 return Algorithm::barrier;
+
370 } else if ( IloCplex::Sifting == algorithm ) {
+
371 return Algorithm::sifting;
+
372 } else if ( IloCplex::Concurrent == algorithm ) {
+
373 return Algorithm::concurrent;
+
374 } else if ( IloCplex::FeasOpt == algorithm ) {
+
375 return Algorithm::feasOpt;
+
376 } else if ( IloCplex::MIP == algorithm ) {
+
377 return Algorithm::mip;
+
378 } else {
+
379 return Algorithm::unknown;
+
380 }
+
381}
+
382
+
383inline IloCplex::Algorithm AlgorithmToCplex ( Algorithm const & algorithm )
+
384{
+
385 if ( Algorithm::automatical == algorithm ) {
+
386 return static_cast<IloCplex::Algorithm>( IloCplex::Auto );
+
387 } else if ( Algorithm::primal == algorithm ) {
+
388 return IloCplex::Primal;
+
389 } else if ( Algorithm::dual == algorithm ) {
+
390 return IloCplex::Dual;
+
391 } else if ( Algorithm::network == algorithm ) {
+
392 return IloCplex::Network;
+
393 } else if ( Algorithm::barrier == algorithm ) {
+
394 return IloCplex::Barrier;
+
395 } else if ( Algorithm::sifting == algorithm ) {
+
396 return IloCplex::Sifting;
+
397 } else if ( Algorithm::concurrent == algorithm ) {
+
398 return IloCplex::Concurrent;
+
399 } else if ( Algorithm::feasOpt == algorithm ) {
+
400 return IloCplex::FeasOpt;
+
401 } else if ( Algorithm::mip == algorithm ) {
+
402 return IloCplex::MIP;
+
403 } else {
+
404 return static_cast<IloCplex::Algorithm>( IloCplex::Auto );
+
405 }
+
406}
+
407#endif // CPLEX_AVAILABLE
+
408
+
409#pragma mark NODE_FILE_STRATEGY_CONVERSION
+
410
+
411inline Types::count NodeFileStrategyToInteger ( NodeFileStrategy const & strategy )
+
412{
+
413 if ( NodeFileStrategy::standard == strategy ) {
+
414 return 0;
+
415 } else if ( NodeFileStrategy::inMemoryCompressed == strategy ) {
+
416 return 1;
+
417 } else if ( NodeFileStrategy::onDisk == strategy ) {
+
418 return 2;
+
419 } else if ( NodeFileStrategy::onDiskCompressed == strategy ) {
+
420 return 3;
+
421 } else {
+
422 USAGE_ASSERT(false && "Node File Strategy does not exist");
+
423 }
+
424}
+
425
+
426#pragma mark ILO_BOOLEAN_CONVERSION
+
427
+
428#ifdef CPLEX_AVAILABLE
+
438inline bool IloBoolToBoolean ( IloBool const & boolean )
+
439{
+
440 if ( IloTrue == boolean ) { return true; }
+
441 else if ( IloFalse == boolean ) { return false; }
+
442 else { USAGE_ASSERT ( false && "IloBool does not exist" ) }
+
443}
+
444#endif // CPLEX_AVAILABLE
+
445
+
446#pragma mark OUTPUT_OPERATOR
+
447
+
448inline std::ostream & operator<<( std::ostream & os, const Status & rhs )
+
449{
+
450 if ( rhs == Status::loaded ) { os << "loaded"; }
+
451 else if ( rhs == Status::optimal ) { os << "optimal"; }
+
452 else if ( rhs == Status::infeasible ) { os << "infeasible"; }
+
453 else if ( rhs == Status::inf_or_unb ) { os << "inf_or_unb";}
+
454 else if ( rhs == Status::unbounded ) { os << "unbounded"; }
+
455 else if ( rhs == Status::cutoff ) { os << "cutoff"; }
+
456 else if ( rhs == Status::iteration_limit) { os << "iteration_limit"; }
+
457 else if ( rhs == Status::node_limit ) { os << "node_limit"; }
+
458 else if ( rhs == Status::time_limit ) { os << "time_limit"; }
+
459 else if ( rhs == Status::solution_limit ) { os << "solution_limit"; }
+
460 else if ( rhs == Status::interrupted ) { os << "interrupted"; }
+
461 else if ( rhs == Status::numeric ) { os << "numeric"; }
+
462 else if ( rhs == Status::suboptimal ) { os << "suboptimal"; }
+
463 else if ( rhs == Status::inprogress ) { os << "inprogress"; }
+
464 else if ( rhs == Status::user_obj_limit ) { os << "user_obj_limit"; }
+
465 else { os << "unknown"; }
+
466 return os;
+
467}
+
468
+
469inline std::ostream & operator<<( std::ostream & os, VariableType const & rhs )
+
470{
+
471 if ( rhs == VariableType::continuous ) { os << "continuous"; }
+
472 else if ( rhs == VariableType::semicontinuous ) { os << "semicontinuous"; }
+
473 else if ( rhs == VariableType::binary ) { os << "binary"; }
+
474 else if ( rhs == VariableType::integer ) { os << "integer";}
+
475 else if ( rhs == VariableType::semiinteger ) { os << "semiinteger"; }
+
476 else { os << "unknown"; }
+
477 return os;
+
478}
+
479
+
480
+
481inline std::ostream & operator<<( std::ostream & os, ObjectiveSense const & rhs )
+
482{
+
483 if ( rhs == ObjectiveSense::minimize ) { os << "minimize"; }
+
484 else if ( rhs == ObjectiveSense::maximize ) { os << "maximize"; }
+
485 else { os << "unknown"; }
+
486 return os;
+
487}
+
488
+
489inline std::ostream & operator<<( std::ostream & os, Algorithm const & rhs )
+
490{
+
491 if ( rhs == Algorithm::automatical ) { os << "Auto"; }
+
492 else if ( rhs == Algorithm::primal ) { os << "Primal"; }
+
493 else if ( rhs == Algorithm::dual ) { os << "Dual"; }
+
494 else if ( rhs == Algorithm::network ) { os << "Network"; }
+
495 else if ( rhs == Algorithm::barrier ) { os << "Barrier"; }
+
496 else if ( rhs == Algorithm::sifting ) { os << "Sifting"; }
+
497 else if ( rhs == Algorithm::concurrent ) { os << "Concurrent"; }
+
498 else if ( rhs == Algorithm::feasOpt ) { os << "FeasOpt"; }
+
499 else if ( rhs == Algorithm::mip ) { os << "MIP"; }
+
500 else { os << "None"; }
+
501 return os;
+
502}
+
503
+
504} // namespace egoa::Solver
+
505
+
506#endif // EGOA__MATHEMATICAL_MODEL__TYPE_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_omitting_iterator_8hpp_source.html b/_omitting_iterator_8hpp_source.html new file mode 100644 index 00000000..a72e12ad --- /dev/null +++ b/_omitting_iterator_8hpp_source.html @@ -0,0 +1,194 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators/OmittingIterator.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
OmittingIterator.hpp
+
+
+
1/*
+
2 * OmittingIterator.hpp
+
3 *
+
4 * Created on: May 13, 2019
+
5 * Author: Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__ITERATORS__OMITTING_ITERATOR_HPP
+
9#define EGOA__DATA_STRUCTURES__ITERATORS__OMITTING_ITERATOR_HPP
+
10
+
11#include <iterator>
+
12
+
13namespace egoa {
+
14
+
22template <typename ElementVectorIt,
+
23 typename BoolVectorIt>
+
+
24class OmittingIterator {
+
25public:
+
26 using iterator_category = std::input_iterator_tag;
+
27 using value_type = typename ElementVectorIt::value_type;
+
28 using difference_type = Types::difference;
+
29 using pointer = ElementVectorIt;
+
30 using reference = typename ElementVectorIt::reference;
+
31
+
+
42 OmittingIterator(ElementVectorIt elementIterator,
+
43 ElementVectorIt elementEnd,
+
44 BoolVectorIt existsIterator)
+
45 : elementIterator_(elementIterator),
+
46 elementEnd_(elementEnd),
+
47 existsIterator_(existsIterator) {
+
48 if (elementIterator_ != elementEnd_ && !*existsIterator_) {
+
49 GoToNextExistingElement();
+
50 }
+
51 }
+
+
52
+
53 OmittingIterator & operator++() {
+
54 GoToNextExistingElement();
+
55 return *this;
+
56 }
+
57 OmittingIterator operator++(int) {
+
58 OmittingIterator copy = *this;
+
59 ++*this;
+
60 return copy;
+
61 }
+
62 OmittingIterator & operator--() {
+
63 GoToPreviousExistingElement();
+
64 return *this;
+
65 }
+
66 OmittingIterator operator--(int) {
+
67 OmittingIterator copy = *this;
+
68 --*this;
+
69 return copy;
+
70 }
+
71 reference operator*() {
+
72 return *elementIterator_;
+
73 }
+
74 pointer operator->() {
+
75 return elementIterator_;
+
76 }
+
77 friend bool operator==(const OmittingIterator & left, const OmittingIterator & right) {
+
78 return left.elementIterator_ == right.elementIterator_;
+
79 }
+
80 friend bool operator!=(const OmittingIterator & left, const OmittingIterator & right) {
+
81 return !(left == right);
+
82 }
+
83private:
+
+
88 void GoToNextExistingElement() {
+
89 do {
+
90 ++elementIterator_;
+
91 ++existsIterator_;
+
92 } while (elementIterator_ != elementEnd_ && !*existsIterator_);
+
93 }
+
+
94
+
+
99 void GoToPreviousExistingElement() {
+
100 do {
+
101 --elementIterator_;
+
102 --existsIterator_;
+
103 } while (!*existsIterator_);
+
104 }
+
+
105
+
111 ElementVectorIt elementIterator_;
+
115 ElementVectorIt elementEnd_;
+
120 BoolVectorIt existsIterator_;
+
121};
+
+
122
+
123} // namespace egoa
+
124
+
125#endif // EGOA__DATA_STRUCTURES__ITERATORS__OMITTING_ITERATOR_HPP
+
egoa::OmittingIterator
An iterator that omits elements of a range if another range of bool indicates that the element is inv...
Definition OmittingIterator.hpp:24
+
egoa::OmittingIterator::GoToPreviousExistingElement
void GoToPreviousExistingElement()
Goes to the previous existing element.
Definition OmittingIterator.hpp:99
+
egoa::OmittingIterator::elementEnd_
ElementVectorIt elementEnd_
The iterator pointing behind the range of elements.
Definition OmittingIterator.hpp:115
+
egoa::OmittingIterator::elementIterator_
ElementVectorIt elementIterator_
The current element.
Definition OmittingIterator.hpp:111
+
egoa::OmittingIterator::OmittingIterator
OmittingIterator(ElementVectorIt elementIterator, ElementVectorIt elementEnd, BoolVectorIt existsIterator)
Constructs an omitting iterator.
Definition OmittingIterator.hpp:42
+
egoa::OmittingIterator::GoToNextExistingElement
void GoToNextExistingElement()
Goes to the next existing element.
Definition OmittingIterator.hpp:88
+
egoa::OmittingIterator::existsIterator_
BoolVectorIt existsIterator_
The iterator pointing to the bool corresponding to the element pointed to by elementIterator_.
Definition OmittingIterator.hpp:120
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_power_grid_8hpp_source.html b/_power_grid_8hpp_source.html new file mode 100644 index 00000000..57932c7e --- /dev/null +++ b/_power_grid_8hpp_source.html @@ -0,0 +1,2255 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Networks/PowerGrid.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PowerGrid.hpp
+
+
+
1/*
+
2 * PowerGrid.hpp
+
3 *
+
4 * Created on: Sep 16, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__POWER_GRID_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__POWER_GRID_HPP
+
10
+
11// for assert
+
12#include "Exceptions/Assertions.hpp"
+
13
+
14#include <algorithm>
+
15#include <iterator>
+
16
+
17#include <QDebug>
+
18
+
19#include "Auxiliary/ExecutionPolicy.hpp"
+
20
+
21#include "DataStructures/Graphs/DynamicGraph.hpp"
+
22#include "DataStructures/Graphs/StaticGraph.hpp"
+
23#include "DataStructures/Graphs/Subgraph.hpp"
+
24
+
25#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
26#include "DataStructures/Graphs/Vertices/LoadProperties.hpp"
+
27#include "DataStructures/Graphs/Vertices/GeneratorProperties.hpp"
+
28#include "DataStructures/Graphs/Vertices/Type.hpp"
+
29
+
30#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
31
+
32#include "DataStructures/Iterators/PowerGridIterators.hpp"
+
33
+
34#include "DataStructures/Networks/GenerationStrategy.hpp"
+
35
+
36namespace egoa {
+
37
+
38template < typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>,
+
39 Edges::ElectricalProperties>,
+
40 typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>,
+
41 typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType> >
+
+
42class PowerGrid {
+
43 public:
+
44 // Template type aliasing
+
45 // Vertices
+
46 using TVertex = typename GraphType::TVertex;
+
47 using TVertexProperties = typename GraphType::TVertexProperties;
+
48 using TGeneratorProperties = GeneratorProperty; //GeneratorType;
+
49 using TLoadProperties = LoadProperty; // LoadType;
+
50 // Edges
+
51 using TEdge = typename GraphType::TEdge;
+
52 using TEdgeProperties = typename GraphType::TEdgeProperties;
+
53 // Graph structures
+
54 using TGraph = GraphType;
+
55 using TNetwork = PowerGrid;
+
56 // Others
+
57 using TBound = Bound<>;
+
58
+
59 public:
+
62#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
63
+
+
67 PowerGrid()
+
68 : baseMva_(1.0)
+
69 , thetaBound_( -Const::REAL_INFTY, Const::REAL_INFTY )
+
70 , verticesWithGeneratorCount_(0)
+
71 , numberOfGenerators_(0)
+
72 , numberOfLoads_(0)
+
73 , generatorBoundType_(Vertices::BoundType::unknown)
+
74 , loadBoundType_(Vertices::BoundType::unknown)
+
75 , graph_()
+
76 {}
+
+
78
+
79 public:
+
82#pragma mark GETTER_AND_SETTER
+
83
+
+
89 inline TGraph const & Graph() const
+
90 {
+
91 return graph_;
+
92 }
+
+
93
+
+
99 inline TGraph & Graph()
+
100 {
+
101 return graph_;
+
102 }
+
+
103
+
+
109 inline Types::real BaseMva() const
+
110 {
+
111 return baseMva_;
+
112 }
+
+
113
+
+
119 inline Types::real & BaseMva()
+
120 {
+
121 return baseMva_;
+
122 }
+
+
123
+
+
129 inline TBound ThetaBound () const
+
130 {
+
131 return thetaBound_;
+
132 }
+
+
133
+
+
139 inline TBound & ThetaBound ()
+
140 {
+
141 return thetaBound_;
+
142 }
+
+
144
+
147#pragma mark BOUND_RELATED_METHODS
+
148
+
+
155 inline Vertices::BoundType const & GeneratorBoundType () const
+
156 {
+
157 return generatorBoundType_;
+
158 }
+
+
159
+
+
166 inline Vertices::BoundType & GeneratorBoundType ()
+
167 {
+
168 return generatorBoundType_;
+
169 }
+
+
170
+
+
177 inline Vertices::BoundType const & LoadBoundType () const
+
178 {
+
179 return loadBoundType_;
+
180 }
+
+
181
+
+
188 inline Vertices::BoundType & LoadBoundType ()
+
189 {
+
190 return loadBoundType_;
+
191 }
+
+
192
+
+
219 inline void MakeBounded ()
+
220 {
+
221 generatorBoundType_ = Vertices::BoundType::bounded;
+
222 loadBoundType_ = Vertices::BoundType::bounded;
+
223 }
+
+
224
+
+
247 inline void MakeUnbounded ()
+
248 {
+
249 generatorBoundType_ = Vertices::BoundType::unbounded;
+
250 loadBoundType_ = Vertices::BoundType::unbounded;
+
251 }
+
+
252
+
+
285 inline void MakePureUnbounded ()
+
286 {
+
287 generatorBoundType_ = Vertices::BoundType::unbounded;
+
288 loadBoundType_ = Vertices::BoundType::pureunbounded;
+
289 }
+
+
290
+
+
315 inline void MakeExact ()
+
316 {
+
317 generatorBoundType_ = Vertices::BoundType::exact;
+
318 loadBoundType_ = Vertices::BoundType::exact;
+
319 }
+
+
320
+
+
326 inline bool IsBounded () const
+
327 {
+
328 return ( (generatorBoundType_ == Vertices::BoundType::bounded) &&
+
329 (loadBoundType_ == Vertices::BoundType::bounded) );
+
330 }
+
+
331
+
+
337 inline bool IsUnbounded () const
+
338 {
+
339 return ( (generatorBoundType_ == Vertices::BoundType::unbounded) &&
+
340 (loadBoundType_ == Vertices::BoundType::unbounded) );
+
341 }
+
+
342
+
+
348 inline bool IsPureUnbounded () const
+
349 {
+
350 return ( ( (generatorBoundType_ == Vertices::BoundType::unbounded) ||
+
351 (generatorBoundType_ == Vertices::BoundType::pureunbounded)
+
352 ) &&
+
353 ( loadBoundType_ == Vertices::BoundType::pureunbounded)
+
354 );
+
355 }
+
+
356
+
+
362 inline bool IsExact () const
+
363 {
+
364 return ( ( generatorBoundType_ == Vertices::BoundType::exact )
+
365 && ( loadBoundType_ == Vertices::BoundType::exact ) );
+
366 }
+
+
367
+
+
373 inline Vertices::BoundType NetworkBoundType () const
+
374 {
+
375 if ( IsExact() ) return Vertices::BoundType::exact;
+
376 else if ( IsBounded() ) return Vertices::BoundType::bounded;
+
377 else if ( IsUnbounded() ) return Vertices::BoundType::unbounded;
+
378 else if ( IsPureUnbounded() ) return Vertices::BoundType::pureunbounded;
+
379 return Vertices::BoundType::unknown;
+
380 }
+
+
381
+
+
387 inline Types::name NetworkType () const
+
388 {
+
389 std::ostringstream temp;
+
390 temp << NetworkBoundType();
+
391 return temp.str();
+
392 }
+
+
394
+
397#pragma mark OUTPUT_METHODS
+
398
+
+
407 friend std::ostream & operator<< ( std::ostream & os
+
408 , PowerGrid<TGraph> const & rhs )
+
409 {
+
410 os << std::string(20, '-');
+
411
+
412 os << "\nBuses\n" << std::string(7, '-') << "\n";
+
413 TVertexProperties::Header(os);
+
414 rhs.Graph().template for_all_vertices<ExecutionPolicy::sequential>([&rhs, &os]( TVertex u )
+
415 {
+
416 u.Properties().Line( os, rhs.BaseMva() );
+
417 });
+
418
+
419 os << "\nGenerators\n" << std::string(11, '-') << "\n";
+
420 TGeneratorProperties::HeaderBusGeneratorName(os);
+
421 rhs.template for_all_generator_tuple<ExecutionPolicy::sequential>( [&rhs, &os]( Types::vertexId vertexId, TGeneratorProperties u )
+
422 {
+
423 u.Line( os, rhs.Graph().VertexAt(vertexId).Properties().Name(), rhs.BaseMva() );
+
424 });
+
425
+
426 os << "\nBranches\n" << std::string(9, '-') << "\n";
+
427 TEdgeProperties::Header(os);
+
428 rhs.Graph().template for_all_edges<ExecutionPolicy::sequential>([&rhs, &os]( TEdge e )
+
429 {
+
430 e.Properties().Line( os, rhs.Graph().VertexAt(e.Source()).Properties().Name(), rhs.Graph().VertexAt(e.Target()).Properties().Name(), rhs.BaseMva() );
+
431 });
+
432
+
433 os << "\nMinDegree: " << rhs.Graph().MinDegree() << "\n";
+
434 os << "MaxDegree: " << rhs.Graph().MaxDegree() << "\n";
+
435
+
436 return os;
+
437 }
+
+
439
+
442#pragma mark ADD_AND_REMOVE_GENERATOR_VERTICES
+
443
+
+
457 inline Types::generatorId AddGeneratorAt ( Types::vertexId vertexId
+
458 , TGeneratorProperties const & generatorProperty )
+
459 {
+
460 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
461
+
462 // Add the generator property to the set V_G
+
463 generators_.emplace_back( std::move( generatorProperty ) );
+
464 generatorExists_.emplace_back( true );
+
465 ++numberOfGenerators_;
+
466
+
467 // Add a pointer from V to V_G, since we can have multiple
+
468 // generators per vertex
+
469 if ( vertexId >= generatorsAtVertex_.size() )
+
470 {
+
471 generatorsAtVertex_.resize ( Graph().NumberOfVertices() );
+
472 }
+
473 ESSENTIAL_ASSERT ( generatorsAtVertex_.size() > vertexId );
+
474
+
475 //@TODO reuse empty slots
+
476 Types::generatorId newId = generators_.size() - 1;
+
477 generatorsAtVertex_[vertexId].emplace_back ( newId );
+
478
+
479 return newId;
+
480 }
+
+
481
+
498 inline Types::generatorId AddGeneratorAt ( Types::vertexId vertexId
+
499 , TGeneratorProperties && generatorProperty )
+
500 {
+
501 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
502
+
503 // Add the generator property to the set V_G
+
504 generators_.emplace_back( std::move( generatorProperty ) );
+
505 generatorExists_.emplace_back( true );
+
506 ++numberOfGenerators_;
+
507
+
508 // Add a pointer from V to V_G, since we can have multiple
+
509 // generators per vertex
+
510 if ( vertexId >= generatorsAtVertex_.size() )
+
511 {
+
512 generatorsAtVertex_.resize ( Graph().NumberOfVertices() );
+
513 }
+
514 ESSENTIAL_ASSERT ( generatorsAtVertex_.size() > vertexId ); // use update
+
515
+
516 //@TODO reuse empty slots
+
517 Types::generatorId newId = generators_.size() - 1;
+
518 generatorsAtVertex_[vertexId].emplace_back( newId );
+
519
+
520 return newId;
+
521 }
+
522
+
523 // Avoid implicit conversions
+
524 inline Types::generatorId AddGeneratorAt ( int vertexId, TGeneratorProperties generatorProperty ) = delete;
+
525 inline Types::generatorId AddGeneratorAt ( char vertexId, TGeneratorProperties generatorProperty ) = delete;
+
526
+
538 inline Types::generatorId AddGeneratorAt ( TVertex const & vertex
+
539 , TGeneratorProperties const & generatorProperty )
+
540 {
+
541 Types::vertexId vertexId = vertex.Identifier();
+
542
+
543 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
544
+
545 return AddGeneratorAt ( vertexId, std::move( generatorProperty ) );
+
546 }
+
547
+
563 inline Types::generatorId AddGeneratorAt ( TVertex const & vertex
+
564 , TGeneratorProperties && generatorProperty )
+
565 {
+
566 Types::vertexId vertexId = vertex.Identifier();
+
567
+
568 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
569
+
570 return AddGeneratorAt ( vertexId, std::move ( generatorProperty ) );
+
571 }
+
572
+
580 inline void RemoveGeneratorAt ( Types::vertexId vertexId
+
581 , Types::generatorId generatorId )
+
582 {
+
583 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
584 USAGE_ASSERT ( HasGenerator ( generatorId ) );
+
585
+
586 // Remove generator object from V_G implicitly
+
587 generatorExists_[ generatorId ] = false;
+
588
+
589 // Reduce the number of generators
+
590 --numberOfGenerators_;
+
591
+
592 // Remove generator pointer from V to V_G
+
593 auto result = std::find ( generatorsAtVertex_[vertexId].begin()
+
594 , generatorsAtVertex_[vertexId].end()
+
595 , generatorId
+
596 );
+
597 if ( result != generatorsAtVertex_[vertexId].end() )
+
598 {
+
599 std::swap ( *result
+
600 , generatorsAtVertex_[vertexId].back() );
+
601 generatorsAtVertex_[vertexId].pop_back();
+
602 } else {
+
603 USAGE_ASSERT ( false
+
604 && "The generatorId does not exist in generatorsAtVertex_[vertexId]!" );
+
605 }
+
606 }
+
607
+
608 // Avoid implicit conversions
+
609 inline void RemoveGeneratorAt ( Types::vertexId vertexId, int generatorId ) = delete;
+
610 inline void RemoveGeneratorAt ( Types::vertexId vertexId, char generatorId ) = delete;
+
611 inline void RemoveGeneratorAt ( int vertexId, Types::generatorId generatorId ) = delete;
+
612 inline void RemoveGeneratorAt ( int vertexId, int generatorId ) = delete;
+
613 inline void RemoveGeneratorAt ( int vertexId, char generatorId ) = delete;
+
614 inline void RemoveGeneratorAt ( char vertexId, Types::generatorId generatorId ) = delete;
+
615 inline void RemoveGeneratorAt ( char vertexId, int generatorId ) = delete;
+
616 inline void RemoveGeneratorAt ( char vertexId, char generatorId ) = delete;
+
617
+
626 inline void RemoveGeneratorAt ( Types::vertexId vertexId
+
627 , TGeneratorProperties & generatorProperty )
+
628 {
+
629 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
630
+
631 Types::generatorId generatorId = GeneratorId( generatorProperty );
+
632
+
633 ESSENTIAL_ASSERT ( HasGenerator ( generatorId ) );
+
634
+
635 RemoveGeneratorAt ( vertexId, generatorId );
+
636 }
+
637
+
638 // Avoid implicit conversions
+
639 inline void RemoveGeneratorAt ( int vertexId, TGeneratorProperties & generatorProperty ) = delete;
+
640 inline void RemoveGeneratorAt ( char vertexId, TGeneratorProperties & generatorProperty ) = delete;
+
642
+
645#pragma mark GENERATOR_ACCESSORS
+
646
+
657 inline bool HasGenerator ( Types::generatorId generatorId ) const
+
658 {
+
659 return ( generatorId < generators_.size()
+
660 && generatorExists_[generatorId] );
+
661 }
+
662
+
663 // Avoid implicit conversions
+
664 inline bool HasGenerator ( int generatorId ) const = delete;
+
665 inline bool HasGenerator ( char generatorId ) const = delete;
+
666
+
676 inline bool HasGenerator ( TGeneratorProperties const & generatorProperty ) const
+
677 {
+
678 return HasGenerator ( GeneratorId ( generatorProperty ) );
+
679 }
+
680
+
690 inline bool HasGeneratorAt ( Types::vertexId vertexId ) const
+
691 {
+
692 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
693 return ( generatorsAtVertex_.size() > vertexId
+
694 && !( generatorsAtVertex_[vertexId].empty() ) );
+
695 }
+
696
+
697 // Avoid implicit conversions
+
698 inline bool HasGeneratorAt ( int vertexId ) const = delete;
+
699 inline bool HasGeneratorAt ( char vertexId ) const = delete;
+
700
+
710 inline bool HasGeneratorAt ( TVertex const & vertex ) const
+
711 {
+
712 Types::vertexId vertexId = Graph().VertexId ( vertex );
+
713 USAGE_ASSERT( Graph().VertexExists ( vertexId ) );
+
714 return HasGeneratorAt ( vertexId );
+
715 }
+
716
+
732 inline Types::generatorId GeneratorId ( TGeneratorProperties const & generatorProperty ) const
+
733 {
+
734 Types::generatorId generatorId = FindGenerator ( generatorProperty, generators_ );
+
735 return generatorId;
+
736 }
+
737
+
745 inline void GeneratorIds ( Types::vertexId vertexId
+
746 , std::vector<Types::generatorId> & generatorIds ) const
+
747 {
+
748 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
749
+
750 if ( HasGeneratorAt( vertexId ) )
+
751 {
+
752 generatorIds = generatorsAtVertex_[ vertexId ];
+
753 }
+
754 }
+
755
+
756 // Avoid implicit conversions
+
757 inline void GeneratorIds ( Types::vertexId vertexId, std::vector<int> & generatorIds ) const = delete;
+
758 inline void GeneratorIds ( Types::vertexId vertexId, std::vector<char> & generatorIds ) const = delete;
+
759 inline void GeneratorIds ( int vertexId, std::vector<Types::generatorId> & generatorIds ) const = delete;
+
760 inline void GeneratorIds ( int vertexId, std::vector<int> & generatorIds ) const = delete;
+
761 inline void GeneratorIds ( int vertexId, std::vector<char> & generatorIds ) const = delete;
+
762 inline void GeneratorIds ( char vertexId, std::vector<Types::generatorId> & generatorIds ) const = delete;
+
763 inline void GeneratorIds ( char vertexId, std::vector<int> & generatorIds ) const = delete;
+
764 inline void GeneratorIds ( char vertexId, std::vector<char> & generatorIds ) const = delete;
+
765
+
774 inline TGeneratorProperties & GeneratorAt ( Types::generatorId generatorId )
+
775 {
+
776 USAGE_ASSERT ( HasGenerator ( generatorId ) );
+
777 return generators_[generatorId];
+
778 }
+
779
+
788 inline TGeneratorProperties const & GeneratorAt ( Types::generatorId generatorId ) const
+
789 {
+
790 USAGE_ASSERT ( HasGenerator ( generatorId ) );
+
791
+
792 return generators_[ generatorId ];
+
793 }
+
794
+
820 inline void GeneratorsAt ( Types::vertexId vertexId
+
821 , std::vector<Types::generatorId> & generatorIds ) const
+
822 {
+
823 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
824
+
825 for_all_generator_identifiers_at <ExecutionPolicy::sequential> ( vertexId,
+
826 [this, &generatorIds](Types::generatorId generatorId)
+
827 {
+
828 generatorIds.emplace_back( generatorId );
+
829 }
+
830 );
+
831 }
+
832
+
855 inline void GeneratorsAt ( Types::vertexId vertexId
+
856 , std::vector<TGeneratorProperties> & generators ) const
+
857 {
+
858 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
859
+
860 for_all_generator_identifiers_at <ExecutionPolicy::sequential> ( vertexId,
+
861 [this, &generators](Types::generatorId generatorId)
+
862 {
+
863 generators.emplace_back( generators_[generatorId] );
+
864 }
+
865 );
+
866 }
+
867
+
868 // Avoid implicit conversions
+
869 inline void GeneratorsAt ( int vertexId, std::vector<TGeneratorProperties> & generators ) const = delete;
+
870 inline void GeneratorsAt ( char vertexId, std::vector<TGeneratorProperties> & generators ) const = delete;
+
871
+
894 inline void GeneratorsAt ( TVertex const & vertex
+
895 , std::vector<Types::generatorId> & generatorIds ) const
+
896 {
+
897 Types::vertexId vertexId = Graph().VertexId( vertex );
+
898 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
899
+
900 GeneratorsAt ( vertexId, generatorIds );
+
901 }
+
902
+
925 inline void GeneratorsAt ( TVertex const & vertex
+
926 , std::vector<TGeneratorProperties> & generators ) const
+
927 {
+
928 Types::vertexId vertexId = Graph().VertexId( vertex );
+
929 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
930
+
931 GeneratorsAt ( vertexId, generators );
+
932 }
+
933
+
948 inline Types::generatorId FindGenerator ( TGeneratorProperties const & generatorProperty
+
949 , std::vector<TGeneratorProperties> const & generators ) const
+
950 {
+
951 auto result = std::find ( generators.begin()
+
952 , generators.end()
+
953 , generatorProperty );
+
954
+
955 if ( result == generators.end() )
+
956 {
+
957 return Const::NONE;
+
958 }
+
959 return static_cast<Types::generatorId> ( std::distance( generators.begin(), result ) );
+
960 }
+
962
+
963
+
966#pragma mark TOTAL_POWER_GENERATION_AT_VERTEX
+
967
+
1000 template<Vertices::GenerationStrategyDifferentiationType Strategy>
+
1001 inline TBound TotalRealPowerGenerationBoundAt ( Types::vertexId vertexId
+
1002 , Types::index timestampPosition = 0 ) const
+
1003 {
+
1004 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1005
+
1006 if ( !HasGeneratorAt(vertexId) ) return TBound ( 0.0, 0.0 );
+
1007
+
1008 if ( generatorBoundType_ == Vertices::BoundType::unbounded
+
1009 || generatorBoundType_ == Vertices::BoundType::pureunbounded )
+
1010 { // PUREUNBOUNDED || UNBOUNDED
+
1011 return TBound ( 0, Const::REAL_INFTY );
+
1012 }
+
1013 else if ( generatorBoundType_ == Vertices::BoundType::bounded )
+
1014 { // BOUNDED
+
1015 TBound pg ( 0.0, 0.0 );
+
1016 for_all_generators_at <ExecutionPolicy::sequential> ( vertexId,
+
1017 [ &pg ]( TGeneratorProperties const & generatorProperty )
+
1018 {
+
1019 if ( generatorProperty.IsActive() )
+
1020 {
+
1021 pg.Maximum() += generatorProperty.RealPowerBound().Maximum();
+
1022 pg.Minimum() += generatorProperty.RealPowerBound().Minimum();
+
1023 }
+
1024 }
+
1025 );
+
1026 return pg;
+
1027 } else
+
1028 { // EXACT
+
1029 ESSENTIAL_ASSERT ( generatorBoundType_ == Vertices::BoundType::exact );
+
1030 auto gen = TotalRealPowerGenerationAt<Strategy> ( vertexId, timestampPosition );
+
1031 return TBound ( gen, gen );
+
1032 }
+
1033 }
+
1034
+
1035 // Avoid implicit conversions
+
1036 inline TBound TotalRealPowerGenerationBoundAt ( int vertexId ) const = delete;
+
1037 inline TBound TotalRealPowerGenerationBoundAt ( int vertexId, int timestampPosition ) const = delete;
+
1038 inline TBound TotalRealPowerGenerationBoundAt ( int vertexId, char timestampPosition ) const = delete;
+
1039 inline TBound TotalRealPowerGenerationBoundAt ( char vertexId ) const = delete;
+
1040 inline TBound TotalRealPowerGenerationBoundAt ( char vertexId, int timestampPosition ) const = delete;
+
1041 inline TBound TotalRealPowerGenerationBoundAt ( char vertexId, char timestampPosition ) const = delete;
+
1042
+
1059 template<Vertices::GenerationStrategyDifferentiationType Strategy>
+
1060 inline Types::real TotalRealPowerGenerationAt ( Types::vertexId vertexId
+
1061 , Types::index timestampPosition = 0 ) const
+
1062 {
+
1063 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1064
+
1065 return internal::GenerationStrategyDifferentiation < TNetwork const, Strategy >
+
1066 ::TotalRealPowerGenerationAt ( *this
+
1067 , vertexId
+
1068 , timestampPosition );
+
1069 }
+
1070
+
1071 // Avoid implicit conversions
+
1072 inline Types::real TotalRealPowerGenerationAt ( int vertexId ) const = delete;
+
1073 inline Types::real TotalRealPowerGenerationAt ( char vertexId ) const = delete;
+
1074
+
1100 template<Vertices::GenerationStrategyDifferentiationType Strategy>
+
1101 inline TBound TotalReactivePowerGenerationBoundAt ( Types::vertexId vertexId
+
1102 , Types::index timestampPosition = 0 ) const
+
1103 {
+
1104 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1105
+
1106 TBound qg( 0.0, 0.0 );
+
1107 if ( HasGeneratorAt( vertexId )
+
1108 && ( ( generatorBoundType_ == Vertices::BoundType::unbounded )
+
1109 || ( generatorBoundType_ == Vertices::BoundType::pureunbounded ) )
+
1110 )
+
1111 { // PUREUNBOUNDED || UNBOUNDED
+
1112 return TBound( 0, Const::REAL_INFTY );
+
1113 } else if ( HasGeneratorAt( vertexId )
+
1114 && ( generatorBoundType_ == Vertices::BoundType::bounded ) )
+
1115 { // BOUNDED
+
1116 for_all_generators_at <ExecutionPolicy::sequential> ( vertexId,
+
1117 [ &qg ]( TGeneratorProperties const & generator )
+
1118 {
+
1119 if ( generator.IsActive() )
+
1120 {
+
1121 qg.Maximum() += generator.ReactivePowerBound().Maximum();
+
1122 qg.Minimum() += generator.ReactivePowerBound().Minimum();
+
1123 }
+
1124 }
+
1125 );
+
1126 } else if ( HasGeneratorAt( vertexId )
+
1127 && ( generatorBoundType_ == Vertices::BoundType::exact ) )
+
1128 { // EXACT
+
1129 qg.Maximum() = TotalReactivePowerGenerationAt<Strategy> ( vertexId
+
1130 , timestampPosition );
+
1131 qg.Minimum() = qg.Maximum();
+
1132 }
+
1133 return qg;
+
1134 }
+
1135
+
1136 // Avoid implicit conversions
+
1137 inline TBound TotalReactivePowerGenerationBoundAt ( int vertexId ) const = delete;
+
1138 inline TBound TotalReactivePowerGenerationBoundAt ( char vertexId ) const = delete;
+
1139
+
1160 template<Vertices::GenerationStrategyDifferentiationType Strategy>
+
1161 inline Types::real TotalReactivePowerGenerationAt ( Types::vertexId vertexId
+
1162 , Types::index timestampPosition = 0 ) const
+
1163 {
+
1164 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1165
+
1166 return internal::GenerationStrategyDifferentiation < TNetwork const, Strategy >
+
1167 ::TotalReactivePowerGenerationAt ( *this
+
1168 , vertexId
+
1169 , timestampPosition );
+
1170 }
+
1171
+
1172 // Avoid implicit conversions
+
1173 inline Types::real TotalReactivePowerGenerationAt ( int vertexId ) const = delete;
+
1174 inline Types::real TotalReactivePowerGenerationAt ( char vertexId ) const = delete;
+
1176
+
1179#pragma mark ADD_AND_REMOVE_LOADS
+
1180
+
1190 inline Types::loadId AddLoadAt ( Types::vertexId vertexId
+
1191 , TLoadProperties load )
+
1192 {
+
1193 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1194
+
1195 // Add load to the set of loads V_L
+
1196 loads_.push_back ( std::move ( load ) );
+
1197 loadExists_.emplace_back ( true );
+
1198 ++numberOfLoads_;
+
1199
+
1200 // Add pointer from V to V_L for that particular load
+
1201 if ( loadsAtVertex_.size() <= vertexId )
+
1202 {
+
1203 loadsAtVertex_.resize( Graph().NumberOfVertices() );
+
1204 }
+
1205 ESSENTIAL_ASSERT ( loadsAtVertex_.size() > vertexId );
+
1206
+
1207 loadsAtVertex_[vertexId].emplace_back( loads_.size() - 1 );
+
1208 return ( loads_.size() - 1 );
+
1209 }
+
1210
+
1211 // Avoid implicit conversions
+
1212 inline Types::loadId AddLoadAt ( int vertexId, TLoadProperties load ) = delete;
+
1213 inline Types::loadId AddLoadAt ( char vertexId, TLoadProperties load ) = delete;
+
1214
+
1224 inline Types::loadId AddLoadAt ( TVertex const & vertex
+
1225 , TLoadProperties const & load )
+
1226 {
+
1227 Types::vertexId vertexId = Graph().VertexId( vertex );
+
1228
+
1229 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1230
+
1231 return AddLoadAt ( vertexId, load );
+
1232 }
+
1233
+
1243 inline Types::loadId AddLoadAt ( TVertex const & vertex
+
1244 , TLoadProperties && load )
+
1245 {
+
1246 Types::vertexId vertexId = Graph().VertexId ( vertex );
+
1247
+
1248 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1249
+
1250 return AddLoadAt ( vertexId, std::move ( load ) );
+
1251 }
+
1252
+
1260 inline void RemoveLoadAt ( Types::vertexId vertexId
+
1261 , Types::loadId loadId )
+
1262 {
+
1263 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1264 USAGE_ASSERT ( HasLoad ( loadId ) );
+
1265
+
1266 // Remove load properties from V_L implicitly
+
1267 loadExists_[ loadId ] = false;
+
1268
+
1269 // Reduce the number of loads
+
1270 --numberOfLoads_;
+
1271
+
1272 // Remove load pointer from V to V_L
+
1273 auto result = std::find ( loadsAtVertex_[vertexId].begin()
+
1274 , loadsAtVertex_[vertexId].end()
+
1275 , loadId
+
1276 );
+
1277 if ( result != loadsAtVertex_[vertexId].end() )
+
1278 {
+
1279 std::swap ( *result
+
1280 , loadsAtVertex_[vertexId].back() );
+
1281 loadsAtVertex_[vertexId].pop_back();
+
1282 } else {
+
1283 USAGE_ASSERT ( false
+
1284 && "The loadId does not exist in loadsAtVertex_[vertexId]!" );
+
1285 }
+
1286 }
+
1287
+
1288 // Avoid implicit conversions
+
1289 inline void RemoveLoadAt ( Types::vertexId vertexId, int loadId ) = delete;
+
1290 inline void RemoveLoadAt ( Types::vertexId vertexId, char loadId ) = delete;
+
1291 inline void RemoveLoadAt ( int vertexId, Types::loadId loadId ) = delete;
+
1292 inline void RemoveLoadAt ( int vertexId, int loadId ) = delete;
+
1293 inline void RemoveLoadAt ( int vertexId, char loadId ) = delete;
+
1294 inline void RemoveLoadAt ( char vertexId, Types::loadId loadId ) = delete;
+
1295 inline void RemoveLoadAt ( char vertexId, int loadId ) = delete;
+
1296 inline void RemoveLoadAt ( char vertexId, char loadId ) = delete;
+
1297
+
1305 inline void RemoveLoadAt ( Types::vertexId vertexId
+
1306 , TLoadProperties & load )
+
1307 {
+
1308 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1309
+
1310 Types::loadId loadId = LoadId( load );
+
1311
+
1312 ESSENTIAL_ASSERT ( HasLoad ( loadId ) );
+
1313
+
1314 RemoveLoadAt ( vertexId, loadId );
+
1315 }
+
1316
+
1317 // Avoid implicit conversions
+
1318 inline void RemoveLoadAt ( int vertexId, TLoadProperties & load ) = delete;
+
1319 inline void RemoveLoadAt ( char vertexId, TLoadProperties & load ) = delete;
+
1321
+
1324#pragma mark LOAD_ACCESSORS
+
1325
+
1334 inline bool HasLoad ( Types::loadId loadId ) const
+
1335 {
+
1336 return ( loadId < loads_.size() )
+
1337 && loadExists_[ loadId ] ;
+
1338 }
+
1339
+
1340 // Avoid implicit conversions
+
1341 inline bool HasLoad ( int loadId ) const = delete;
+
1342 inline bool HasLoad ( char loadId ) const = delete;
+
1343
+
1351 inline bool HasLoad ( TLoadProperties const & load ) const
+
1352 {
+
1353 return ( Const::NONE != LoadId ( load ) );
+
1354 }
+
1355
+
1365 inline bool HasLoadAt ( Types::vertexId vertexId ) const
+
1366 {
+
1367 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1368 return ( loadsAtVertex_.size() > vertexId
+
1369 && !( loadsAtVertex_[vertexId].empty() ) );
+
1370 }
+
1371
+
1372 // Avoid implicit conversions
+
1373 inline bool HasLoadAt ( int vertexId ) const = delete;
+
1374 inline bool HasLoadAt ( char vertexId ) const = delete;
+
1375
+
1385 inline bool HasLoadAt ( TVertex const & vertex ) const
+
1386 {
+
1387 Types::vertexId vertexId = Graph().VertexId ( vertex );
+
1388 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1389 return HasLoadAt ( vertexId );
+
1390 }
+
1391
+
1400 inline Types::loadId LoadId ( TLoadProperties const & load ) const
+
1401 {
+
1402 auto result = std::find ( loads_.begin()
+
1403 , loads_.end()
+
1404 , load );
+
1405 if ( result == loads_.end() )
+
1406 {
+
1407 return Const::NONE;
+
1408 }
+
1409 return std::distance ( loads_.begin(), result );
+
1410 }
+
1411
+
1419 inline void LoadIds ( Types::vertexId vertexId
+
1420 , std::vector<Types::loadId> & loadIds ) const
+
1421 {
+
1422 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
1423 USAGE_ASSERT ( vertexId < loadsAtVertex_.size() );
+
1424
+
1425 if ( HasLoadAt ( vertexId ) )
+
1426 {
+
1427 loadIds = loadsAtVertex_[vertexId];
+
1428 }
+
1429 }
+
1430
+
1431 // Avoid implicit conversions
+
1432 inline void LoadIds ( Types::vertexId vertexId, std::vector<int> & loadIds ) const = delete;
+
1433 inline void LoadIds ( Types::vertexId vertexId, std::vector<char> & loadIds ) const = delete;
+
1434 inline void LoadIds ( int vertexId, std::vector<Types::loadId> & loadIds ) const = delete;
+
1435 inline void LoadIds ( int vertexId, std::vector<int> & loadIds ) const = delete;
+
1436 inline void LoadIds ( int vertexId, std::vector<char> & loadIds ) const = delete;
+
1437 inline void LoadIds ( char vertexId, std::vector<Types::loadId> & loadIds ) const = delete;
+
1438 inline void LoadIds ( char vertexId, std::vector<int> & loadIds ) const = delete;
+
1439 inline void LoadIds ( char vertexId, std::vector<char> & loadIds ) const = delete;
+
1440
+
1447 inline void LoadIds ( TVertex const & vertex
+
1448 , std::vector<Types::loadId> & loadIds ) const
+
1449 {
+
1450 Types::vertexId vertexId = Graph().VertexId ( vertex );
+
1451
+
1452 USAGE_ASSERT( vertexId < Graph().Vertices().size() );
+
1453 USAGE_ASSERT( vertexId < loadsAtVertex_.size() );
+
1454
+
1455 if ( HasLoadAt( vertexId ) )
+
1456 {
+
1457 loadIds = loadsAtVertex_[vertexId];
+
1458 }
+
1459 }
+
1460
+
1461 // Avoid implicit conversions
+
1462 inline void LoadIds ( TVertex const & vertex, std::vector<int> & loadIds ) const = delete;
+
1463 inline void LoadIds ( TVertex const & vertex, std::vector<char> & loadIds ) const = delete;
+
1464
+
1472 inline TLoadProperties & LoadAt ( Types::loadId loadId )
+
1473 {
+
1474 USAGE_ASSERT ( HasLoad ( loadId ) );
+
1475 return loads_[loadId];
+
1476 }
+
1477
+
1485 inline TLoadProperties const & LoadAt ( Types::loadId loadId ) const
+
1486 {
+
1487 USAGE_ASSERT ( HasLoad ( loadId ) );
+
1488 return loads_[loadId];
+
1489 }
+
1490
+
1497 inline void LoadsAt ( Types::vertexId vertexId
+
1498 , std::vector<TLoadProperties> & loads ) const
+
1499 {
+
1500 USAGE_ASSERT( Graph().VertexExists( vertexId ) );
+
1501
+
1502 if ( HasLoadAt( vertexId ) )
+
1503 {
+
1504 std::vector<Types::labelId> loadIds;
+
1505 LoadIds( vertexId, loadIds );
+
1506 for ( auto id : loadIds )
+
1507 {
+
1508 loads.emplace_back( loads_[id] );
+
1509 }
+
1510 }
+
1511 }
+
1512
+
1519 inline void LoadsAt ( TVertex const & vertex
+
1520 , std::vector<TLoadProperties> & loads ) const
+
1521 {
+
1522 Types::vertexId vertexId = Graph().VertexId ( vertex );
+
1523 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
1524
+
1525 if ( HasLoadAt( vertexId ) )
+
1526 {
+
1527 std::vector<Types::loadId> loadIds;
+
1528 LoadIds ( vertexId, loadIds );
+
1529 for ( auto id : loadIds )
+
1530 {
+
1531 loads.emplace_back( loads_[id] );
+
1532 }
+
1533 }
+
1534 }
+
1536
+
1539#pragma mark TOTAL_POWER_LOAD_AT_VERTEX
+
1540
+
1550 inline Types::real RealPowerLoadAt ( Types::vertexId vertexId
+
1551 , Types::index snapshotId = 0 ) const
+
1552 {
+
1553 USAGE_ASSERT( Graph().VertexExists( vertexId ) );
+
1554
+
1555 Types::loadSnapshot result = 0;
+
1556 for_all_real_power_load_snapshots_at (
+
1557 vertexId,
+
1558 snapshotId,
+
1559 [&result](Types::loadSnapshot load )
+
1560 {
+
1561 result += load;
+
1562 }
+
1563 );
+
1564
+
1565 return result;
+
1566 }
+
1567
+
1577 inline Types::real RealPowerLoadAt ( TVertex const & vertex
+
1578 , Types::index snapshotId = 0 ) const
+
1579 {
+
1580 USAGE_ASSERT ( Graph().VertexExists( vertex.Identifier() ) );
+
1581 return RealPowerLoadAt( vertex.Identifier(), snapshotId );
+
1582 }
+
1583
+
1595 inline TBound TotalRealPowerLoadBoundAt( Types::vertexId vertexId
+
1596 , Types::index timestamp = 0 ) const
+
1597 {
+
1598 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1599
+
1600 if ( loadBoundType_ == Vertices::BoundType::pureunbounded )
+
1601 { // PUREUNBOUNDED
+
1602 if ( HasGeneratorAt ( vertexId ) )
+
1603 { //@todo use when implemented the breakable loop to break after infty was found
+
1604 Types::real loadMax = 0.0;
+
1605 for_all_loads_at<ExecutionPolicy::sequential> ( vertexId,
+
1606 [ &loadMax ]( TLoadProperties const & load )
+
1607 {
+
1608 if ( load.RealPowerLoadBound().Maximum() < Const::REAL_INFTY
+
1609 && loadMax < Const::REAL_INFTY )
+
1610 {
+
1611 loadMax += load.RealPowerLoadBound().Maximum();
+
1612 } else {
+
1613 loadMax = Const::REAL_INFTY;
+
1614 }
+
1615 }
+
1616 );
+
1617 return TBound ( 0, loadMax );
+
1618 }
+
1619 return TBound ( 0, Const::REAL_INFTY );
+
1620 } else if ( loadBoundType_ == Vertices::BoundType::unbounded )
+
1621 { // UNBOUNDED
+
1622 return TBound ( 0, Const::REAL_INFTY );
+
1623 } else if ( loadBoundType_ == Vertices::BoundType::exact )
+
1624 { // EXACT: For power flow (PF) calculation
+
1625 auto loadValue = TotalRealPowerLoadAt(vertexId, timestamp);
+
1626 return TBound ( loadValue, loadValue );
+
1627 }
+
1628 // BOUNDED
+
1629 //@todo use when implemented the breakable loop to break after infty was found
+
1630 Types::real loadMin = 0.0;
+
1631 Types::real loadMax = 0.0;
+
1632 for_all_loads_at<ExecutionPolicy::sequential> ( vertexId,
+
1633 [ &loadMin, &loadMax ]( TLoadProperties const & load )
+
1634 {
+
1635 if ( load.RealPowerLoadBound().Minimum() < Const::REAL_INFTY
+
1636 && loadMin < Const::REAL_INFTY )
+
1637 {
+
1638 loadMin += load.RealPowerLoadBound().Minimum();
+
1639 } else {
+
1640 loadMin = Const::REAL_INFTY;
+
1641 }
+
1642
+
1643 if ( load.RealPowerLoadBound().Maximum() < Const::REAL_INFTY
+
1644 && loadMax < Const::REAL_INFTY )
+
1645 {
+
1646 loadMax += load.RealPowerLoadBound().Maximum();
+
1647 } else {
+
1648 loadMax = Const::REAL_INFTY;
+
1649 }
+
1650 }
+
1651 );
+
1652 return TBound ( loadMin, loadMax );
+
1653 }
+
1654
+
1665 inline Types::real TotalRealPowerLoadAt( Types::vertexId vertexId,
+
1666 Types::index timestampPosition ) const
+
1667 {
+
1668 USAGE_ASSERT ( Graph().VertexExists( vertexId ) );
+
1669
+
1670 if ( !HasLoadAt ( vertexId ) ) return 0.0;
+
1671
+
1672 Types::real total = 0;
+
1673 for_all_load_identifiers_at<ExecutionPolicy::breakable>( vertexId,
+
1674 [ this, &total, timestampPosition ]( Types::loadId loadId )
+
1675 {
+
1676 auto myLoad = LoadSnapshotOf(loadId, timestampPosition);
+
1677 if ( myLoad >= Const::REAL_INFTY )
+
1678 {
+
1679 total = Const::REAL_INFTY;
+
1680 return false;
+
1681 }
+
1682 total += myLoad;
+
1683 return true;
+
1684 }
+
1685 );
+
1686 return total;
+
1687 }
+
1688
+
1696 inline TBound TotalReactivePowerLoadBoundAt( Types::vertexId vertexId ) const
+
1697 {
+
1698 USAGE_ASSERT ( Graph().VertexExists ( vertexId ) );
+
1699
+
1700 if ( loadBoundType_ == Vertices::BoundType::pureunbounded )
+
1701 { // PUREUNBOUNDED
+
1702 if ( HasGeneratorAt( vertexId ) )
+
1703 {
+
1704 return TBound( 0, Graph().VertexAt( vertexId ).ReactivePowerLoadBound().Maximum() );
+
1705 }
+
1706 return TBound( 0, Const::REAL_INFTY );
+
1707 } else if ( loadBoundType_ == Vertices::BoundType::unbounded )
+
1708 { // UNBOUNDED
+
1709 return TBound( 0, Const::REAL_INFTY );
+
1710 } else if ( loadBoundType_ == Vertices::BoundType::exact )
+
1711 { // EXACT: For power flow (PF) calculation
+
1712 return TBound ( Graph().VertexAt( vertexId ).ReactivePowerLoad()
+
1713 , Graph().VertexAt( vertexId ).ReactivePowerLoad() );
+
1714 }
+
1715 return TBound ( Graph().VertexAt( vertexId ).ReactivePowerLoadBound().Minimum()
+
1716 , Graph().VertexAt( vertexId ).ReactivePowerLoadBound().Maximum() );
+
1717 }
+
1719
+
1722#pragma mark SNAPSHOT_ACCESSORS_AND_MODIFIERS
+
1723
+
1742 inline void AddGeneratorRealPowerSnapshotAt ( Types::generatorId generatorId
+
1743 , Types::generatorSnapshot maximumRealPowerGenerationPu )
+
1744 {
+
1745 USAGE_ASSERT ( HasGenerator ( generatorId ) );
+
1746 // USAGE_ASSERT ( maximumRealPowerGenerationPu != Const::NONE );
+
1747
+
1748 if ( generatorRealPowerSnapshots_.size() <= generatorId )
+
1749 {
+
1750 UpdateGeneratorSnapshotSize();
+
1751 }
+
1752 ESSENTIAL_ASSERT( generatorId < generatorRealPowerSnapshots_.size() );
+
1753 generatorRealPowerSnapshots_[ generatorId ].emplace_back( maximumRealPowerGenerationPu );
+
+
1754 }
+
1755
+
+
1760 inline void UpdateGeneratorSnapshotSize ()
+
1761 {
+
1762 generatorRealPowerSnapshots_.resize( generators_.size() );
+
+
1763 }
+
1764
+
+
1769 inline void UpdateLoadSnapshotSize( )
+
1770 {
+
+
1771 loadSnapshots_.resize( loads_.size() );
+
1772 }
+
1773
+
1777 void OutputGeneratorSnaps()
+
1778 {
+
1779 for ( Types::count counter = 0
+
1780 ; counter < timestamps_.size()
+
1781 ; ++counter )
+
1782 {
+
1783 std::cout << std::setw(5) << timestamps_[counter];
+
1784 for ( Types::vertexId generatorId = 0
+
1785 ; generatorId < generatorRealPowerSnapshots_.size()
+
1786 ; ++generatorId )
+
1787 {
+
1788 if ( generatorRealPowerSnapshots_[generatorId].size() == 0
+
1789 || GeneratorRealPowerSnapshotAt ( generatorId, counter ) == Const::NONE )
+
1790 {
+
1791 continue; // If the generator has no snapshot available
+
+
1792 }
+
1793 std::cout << " - " << std::setw(5) << GeneratorRealPowerSnapshotAt ( generatorId, counter );
+
1794 }
+
1795 std::cout << std::endl;
+
+
1796 }
+
1797 }
+
1798
+
1802 void OutputLoadSnaps()
+
1803 {
+
1804 for ( Types::count counter = 0
+
1805 ; counter < timestamps_.size()
+
1806 ; ++counter )
+
1807 {
+
1808 std::cout << std::setw(5) << timestamps_[counter];
+
1809 for ( Types::vertexId loadId = 0
+
1810 ; loadId < loadSnapshots_.size()
+
1811 ; ++loadId )
+
1812 {
+
+
1813 if ( loadSnapshots_[loadId].size() == 0 || LoadSnapshotOf ( loadId, counter ) == Const::NONE ) continue; // If the generator has no snapshot available
+
1814 std::cout << " - " << std::setw(5) << LoadSnapshotOf ( loadId, counter );
+
1815 }
+
1816 std::cout << std::endl;
+
1817 }
+
1818 }
+
1819
+
1828 inline void AddLoadSnapshotAt ( Types::loadId loadId
+
1829 , Types::loadSnapshot snapshot )
+
1830 {
+
1831 USAGE_ASSERT ( HasLoad ( loadId ) );
+
1832 USAGE_ASSERT ( snapshot < Const::NONE );
+
1833
+
1834 if ( loadSnapshots_.size() <= loadId
+
1835 || loadSnapshots_.empty() )
+
1836 {
+
1837 UpdateLoadSnapshotSize();
+
1838 }
+
1839
+
1840 loadSnapshots_[loadId].emplace_back( snapshot );
+
1841 }
+
+
1842
+
+
1848 inline void AddSnapshotWeighting( Types::weightSnapshot weight )
+
1849 {
+
1850 USAGE_ASSERT( weight != Const::NONE );
+
1851 snapshotWeights_.emplace_back( weight );
+
1852 }
+
1853
+
1862 inline void AddSnapshotTimestamp( Types::timestampSnapshot timestamp )
+
1863 {
+
1864 USAGE_ASSERT ( !timestamp.empty() );
+
1865 timestamps_.emplace_back( timestamp );
+
1866 }
+
1867
+
1877 inline Types::index PositionOf ( Types::timestampSnapshot timestamp ) const
+
1878 {
+
1879 auto result = std::find ( timestamps_.begin()
+
1880 , timestamps_.end()
+
1881 , timestamp );
+
1882 if ( result != timestamps_.end() )
+
1883 {
+
1884 return std::distance( timestamps_.begin(), result );
+
1885 } else {
+
1886 return Const::NONE;
+
1887 }
+
1888 }
+
1889
+
1897 inline Types::timestampSnapshot TimestampAt ( Types::index timestampPosition ) const
+
1898 {
+
1899 USAGE_ASSERT ( timestampPosition < timestamps_.size() );
+
1900 return timestamps_[timestampPosition];
+
1901 }
+
1903
+
1906#pragma mark GENERATOR_REAL_POWER_SNAPSHOT
+
1923 inline Types::generatorSnapshot GeneratorRealPowerSnapshotAt ( Types::generatorId generatorId
+
1924 , Types::timestampSnapshot timestamp ) const
+
1925 {
+
1926 USAGE_ASSERT ( generatorId < NumberOfGenerators() );
+
1927 USAGE_ASSERT ( !timestamp.empty() );
+
1928
+
1929 Types::index position = PositionOf ( timestamp );
+
1930 if ( position != Const::NONE )
+
1931 {
+
1932 return GeneratorRealPowerSnapshotAt ( generatorId, position );
+
1933 } else
+
1934 { // No snapshot available
+
1935 return Const::NONE;
+
1936 }
+
1937 }
+
1938
+
1952 inline Types::generatorSnapshot GeneratorRealPowerSnapshotAt ( TGeneratorProperties const & generator
+
1953 , Types::timestampSnapshot timestamp ) const
+
1954 {
+
1955 Types::generatorId generatorId = GeneratorId ( generator );
+
1956 USAGE_ASSERT ( generatorId != Const::NONE );
+
1957
+
1958 return GeneratorRealPowerSnapshotAt ( generatorId, timestamp );
+
1959 }
+
1960
+
1976 inline Types::generatorSnapshot GeneratorRealPowerSnapshotAt ( Types::generatorId generatorId
+
1977 , Types::index timestampPosition ) const
+
1978 {
+
1979 USAGE_ASSERT ( generatorId < NumberOfGenerators() );
+
1980 USAGE_ASSERT ( !timestamps_.empty() );
+
1981
+
1982 if ( generatorId >= generatorRealPowerSnapshots_.size() )
+
1983 {
+
1984 return Const::NONE;
+
1985 }
+
1986 if ( timestampPosition >= generatorRealPowerSnapshots_[generatorId].size() )
+
1987 {
+
1988 return Const::NONE;
+
1989 }
+
1990 return generatorRealPowerSnapshots_[generatorId][timestampPosition];
+
1991 }
+
1992
+
2006 inline Types::generatorSnapshot GeneratorRealPowerSnapshotAt ( TGeneratorProperties const & generator
+
2007 , Types::index timestampPosition ) const
+
2008 {
+
2009 Types::generatorId generatorId = GeneratorId ( generator );
+
2010 USAGE_ASSERT ( generatorId != Const::NONE );
+
2011
+
2012 return GeneratorRealPowerSnapshotAt ( generatorId, timestampPosition );
+
2013 }
+
2014
+
2029 inline void GeneratorRealPowerSnapshotsAt ( Types::timestampSnapshot timestamp
+
2030 , std::vector<Types::generatorSnapshot> & snapshotsAtTimestamp ) const
+
2031 {
+
2032 USAGE_ASSERT ( !timestamps_.empty() );
+
2033 USAGE_ASSERT ( snapshotsAtTimestamp.empty() );
+
2034
+
2035 Types::index position = PositionOf( timestamp );
+
2036 if ( position != Const::NONE )
+
2037 {
+
2038 for ( Types::vertexId generatorId = 0
+
2039 ; generatorId < generatorRealPowerSnapshots_.size()
+
2040 ; ++generatorId )
+
2041 { // if there is a snapshot at a generator there should be at least position many
+
2042 ESSENTIAL_ASSERT ( generatorRealPowerSnapshots_[generatorId].size() > position );
+
2043 if ( generatorRealPowerSnapshots_[generatorId].size() == 0 )
+
2044 { // No snapshots available at the generator with generatorId
+
2045 snapshotsAtTimestamp.emplace_back( Const::NONE );
+
2046 }
+
2047 snapshotsAtTimestamp.emplace_back( GeneratorRealPowerSnapshotAt ( generatorId, position ) );
+
2048 } // for
+
2049 } // if position
+
2050 }
+
2052
+
2056#pragma mark GENERATOR_REACTIVE_POWER_SNAPSHOT
+
2057
+
2073 inline Types::generatorSnapshot GeneratorReactivePowerSnapshotAt ( Types::generatorId generatorId
+
2074 , Types::timestampSnapshot timestamp ) const
+
2075 {
+
2076 USAGE_ASSERT ( generatorId < NumberOfGenerators() );
+
2077 USAGE_ASSERT ( !timestamps_.empty() );
+
2078
+
2079 Types::index position = PositionOf ( timestamp );
+
2080 if ( position != Const::NONE )
+
2081 {
+
2082 return GeneratorReactivePowerSnapshotAt ( generatorId, position );
+
2083 } else
+
2084 { // No snapshot available
+
2085 return Const::NONE;
+
2086 }
+
2087 }
+
2088
+
2102 inline Types::generatorSnapshot GeneratorReactivePowerSnapshotAt ( TGeneratorProperties const & generator
+
2103 , Types::timestampSnapshot timestamp ) const
+
2104 {
+
2105 Types::generatorId generatorId = GeneratorId ( generator );
+
2106 USAGE_ASSERT ( generatorId != Const::NONE );
+
2107
+
2108 return GeneratorReactivePowerSnapshotAt ( generatorId, timestamp );
+
2109 }
+
2110
+
2128 inline Types::generatorSnapshot GeneratorReactivePowerSnapshotAt ( Types::generatorId generatorId
+
2129 , Types::index timestampPosition ) const
+
2130 {
+
2131 USAGE_ASSERT ( generatorId < NumberOfGenerators() );
+
2132
+
2133 // if ( generatorId >= generatorReactivePowerSnapshots_.size() )
+
2134 // {
+
2135 // return Const::NONE;
+
2136 // }
+
2137 // if ( timestampPosition >= generatorReactivePowerSnapshots_[generatorId].size() )
+
2138 // {
+
2139 // return Const::NONE;
+
2140 // }
+
2141 return GeneratorAt ( generatorId ).ReactivePower(); // generatorReactivePowerSnapshots_[generatorId][timestampPosition];
+
2142 }
+
2143
+
2157 inline Types::generatorSnapshot GeneratorReactivePowerSnapshotAt ( TGeneratorProperties const & generator
+
2158 , Types::index timestampPosition ) const
+
2159 {
+
2160 Types::generatorId generatorId = GeneratorId ( generator );
+
2161 USAGE_ASSERT ( generatorId != Const::NONE );
+
2162
+
2163 return GeneratorReactivePowerSnapshotAt ( generatorId, timestampPosition );
+
2164 }
+
2166
+
2169#pragma mark LOAD_SNAPSHOT_LOGIC
+
2170
+
2180 inline Types::loadSnapshot LoadSnapshotOf ( Types::loadId loadId
+
2181 , Types::timestampSnapshot timestamp )
+
2182 {
+
2183 USAGE_ASSERT ( loadId != Const::NONE );
+
2184 USAGE_ASSERT ( loadId < loads_.size() );
+
2185 USAGE_ASSERT ( !timestamps_.empty() );
+
2186
+
2187 Types::index position = PositionOf( timestamp );
+
2188 return LoadSnapshotOf ( loadId, position );
+
2189 }
+
2190
+
2200 inline Types::loadSnapshot LoadSnapshotOf ( Types::loadId loadId
+
2201 , Types::timestampSnapshot timestamp ) const
+
2202 {
+
2203 USAGE_ASSERT ( loadId != Const::NONE );
+
2204 USAGE_ASSERT ( loadId < loads_.size() );
+
2205 USAGE_ASSERT ( ! timestamps_.empty() );
+
2206
+
2207 Types::index position = PositionOf( timestamp );
+
2208 return LoadSnapshotOf ( loadId, position );
+
2209 }
+
2210
+
2221 inline Types::loadSnapshot LoadSnapshotOf ( Types::loadId loadId
+
2222 , Types::index timestampPosition )
+
2223 {
+
2224 USAGE_ASSERT ( loadId != Const::NONE );
+
2225 USAGE_ASSERT ( loadId < loads_.size() );
+
2226 USAGE_ASSERT ( timestampPosition != Const::NONE );
+
2227 USAGE_ASSERT ( loadSnapshots_[loadId].size() <= timestamps_.size());
+
2228 USAGE_ASSERT ( timestampPosition <= loadSnapshots_[loadId].size()
+
2229 || loadSnapshots_[loadId].size() == 0 );
+
2230
+
2231 if ( loadSnapshots_[loadId].size() != 0 )
+
2232 {
+
2233 return loadSnapshots_[loadId][timestampPosition];
+
2234 } else
+
2235 { // No snapshot available at the load with loadId
+
2236 return Const::NONE;
+
2237 }
+
2238 }
+
2239
+
2250 inline Types::loadSnapshot LoadSnapshotOf ( Types::loadId loadId
+
2251 , Types::index timestampPosition ) const
+
2252 {
+
2253 USAGE_ASSERT ( loadId != Const::NONE );
+
2254 USAGE_ASSERT ( loadId < loads_.size() );
+
2255 USAGE_ASSERT ( timestampPosition != Const::NONE );
+
2256 USAGE_ASSERT ( loadSnapshots_[loadId].size() <= timestamps_.size());
+
2257 USAGE_ASSERT ( timestampPosition <= loadSnapshots_[loadId].size()
+
2258 || loadSnapshots_[loadId].size() == 0 );
+
2259
+
2260 if ( loadSnapshots_[loadId].size() != 0 )
+
2261 {
+
2262 return loadSnapshots_[loadId][timestampPosition];
+
2263 } else
+
2264 { // No snapshot available at the load with loadId
+
2265 return Const::NONE;
+
2266 }
+
2267 }
+
2268
+
2279 inline void LoadSnapshotsAt ( Types::vertexId vertexId
+
2280 , Types::index timestampPosition
+
2281 , std::vector<Types::loadSnapshot> & loadSnapshots )
+
2282 {
+
2283 USAGE_ASSERT ( vertexId < Graph().Vertices().size() );
+
2284 USAGE_ASSERT ( timestampPosition != Const::NONE );
+
2285 USAGE_ASSERT ( loadSnapshots.empty() );
+
2286
+
2287 std::vector<Types::loadId> loadIds;
+
2288 LoadsAt(vertexId, loadIds);
+
2289
+
2290 for ( Types::index index = 0
+
2291 ; index < loadIds.size()
+
2292 ; ++index)
+
2293 {
+
2294 loadSnapshots.emplace_back( loadSnapshots_[ loadIds[index] ][timestampPosition] );
+
2295 }
+
2296 }
+
2297
+
2307 inline void LoadSnapshotsAt ( TVertex const & vertex
+
2308 , Types::index timestampPosition
+
2309 , std::vector<Types::loadSnapshot> & loadSnapshots )
+
2310 {
+
2311 USAGE_ASSERT( loadSnapshots.empty() );
+
2312
+
2313 Types::vertexId vertexId = VertexId( vertex );
+
2314 ESSENTIAL_ASSERT( vertexId < Graph().Vertices().size() );
+
2315
+
2316 LoadSnapshotsAt ( vertexId, timestampPosition, loadSnapshots );
+
2317 }
+
2318
+
2328 inline void LoadSnapshotsAt ( Types::timestampSnapshot timestamp
+
2329 , std::vector<Types::loadSnapshot> & loadSnapshotsAtTimestamp )
+
2330 {
+
2331 USAGE_ASSERT ( !timestamps_.empty() );
+
2332 USAGE_ASSERT ( loadSnapshotsAtTimestamp.empty() );
+
2333
+
2334 Types::index position = PositionOf( timestamp );
+
2335 if ( position != Const::NONE )
+
2336 {
+
2337 for ( Types::loadId loadId = 0
+
2338 ; loadId < loadSnapshots_.size()
+
2339 ; ++loadId )
+
2340 {
+
2341 if ( loadSnapshots_[loadId].size() == 0 )
+
2342 { // No snapshot available
+
2343 loadSnapshotsAtTimestamp.emplace_back( Const::NONE );
+
2344 }
+
2345 loadSnapshotsAtTimestamp.emplace_back( LoadSnapshotOf ( loadId, position ) );
+
2346 }
+
2347 }
+
2348 }
+
2350
+
2353#pragma mark GENERATOR_LOOPS
+
2354
+
2374 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2375 inline
+
2376 void for_all_generators ( FUNCTION function )
+
2377 {
+
2378 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2379 ::for_all_generators ( *this
+
2380 , function );
+
2381 }
+
2382
+
2402 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2403 inline
+
2404 void for_all_generators ( FUNCTION function ) const
+
2405 {
+
2406 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2407 ::for_all_generators ( *this
+
2408 , function );
+
2409 }
+
2410
+
2431 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2432 inline
+
2433 void for_all_generators_at ( TVertex const & vertex
+
2434 , FUNCTION function )
+
2435 {
+
2436 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2437 ::for_all_generators_at ( vertex
+
2438 , *this
+
2439 , function );
+
2440 }
+
2441
+
2462 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2463 inline
+
2464 void for_all_generators_at ( TVertex const & vertex
+
2465 , FUNCTION function ) const
+
2466 {
+
2467 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2468 ::for_all_generators_at ( vertex
+
2469 , *this
+
2470 , function );
+
2471 }
+
2472
+
2493 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2494 inline
+
2495 void for_all_generators_at ( Types::vertexId vertexId
+
2496 , FUNCTION function )
+
2497 {
+
2498 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2499 ::for_all_generators_at ( vertexId
+
2500 , *this
+
2501 , function );
+
2502 }
+
2503
+
2524 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2525 inline
+
2526 void for_all_generators_at ( Types::vertexId vertexId
+
2527 , FUNCTION function ) const
+
2528 {
+
2529 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2530 ::for_all_generators_at ( vertexId
+
2531 , *this
+
2532 , function );
+
2533 }
+
2534
+
2554 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2555 inline
+
2556 void for_all_vertex_identifiers_with_generator ( FUNCTION function )
+
2557 {
+
2558 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2559 ::for_all_vertex_identifiers_with_generator ( *this
+
2560 , function );
+
2561 }
+
2562
+
2582 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2583 inline
+
2584 void for_all_vertex_identifiers_with_generator ( FUNCTION function ) const
+
2585 {
+
2586 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2587 ::for_all_vertex_identifiers_with_generator ( *this
+
2588 , function );
+
2589 }
+
2590
+
2611 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2612 inline
+
2613 void for_all_generator_identifiers_at ( TVertex const & vertex
+
2614 , FUNCTION function )
+
2615 {
+
2616 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2617 ::for_all_generator_identifiers_at ( vertex
+
2618 , *this
+
2619 , function );
+
2620 }
+
2621
+
2642 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2643 inline
+
2644 void for_all_generator_identifiers_at ( TVertex const & vertex
+
2645 , FUNCTION function ) const
+
2646 {
+
2647 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2648 ::for_all_generator_identifiers_at ( vertex
+
2649 , *this
+
2650 , function );
+
2651 }
+
2652
+
2673 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2674 inline
+
2675 void for_all_generator_identifiers_at ( Types::vertexId vertexId
+
2676 , FUNCTION function )
+
2677 {
+
2678 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2679 ::for_all_generator_identifiers_at ( vertexId
+
2680 , *this
+
2681 , function );
+
2682 }
+
2683
+
2704 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2705 inline
+
2706 void for_all_generator_identifiers_at ( Types::vertexId vertexId
+
2707 , FUNCTION function ) const
+
2708 {
+
2709 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2710 ::for_all_generator_identifiers_at ( vertexId
+
2711 , *this
+
2712 , function );
+
2713 }
+
2714
+
2736 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2737 inline
+
2738 void for_all_generator_tuple ( FUNCTION function )
+
2739 {
+
2740 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2741 ::for_all_generator_tuple ( *this
+
2742 , function );
+
2743 }
+
2744
+
2766 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2767 inline
+
2768 void for_all_generator_tuple ( FUNCTION function ) const
+
2769 {
+
2770 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2771 ::for_all_generator_tuple ( *this
+
2772 , function );
+
2773 }
+
2774
+
2796 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2797 inline
+
2798 void for_all_generators_tuple ( FUNCTION function )
+
2799 {
+
2800 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2801 ::for_all_generators_tuple ( *this
+
2802 , function );
+
2803 }
+
2804
+
2826 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2827 inline
+
2828 void for_all_generators_tuple ( FUNCTION function ) const
+
2829 {
+
2830 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2831 ::for_all_generators_tuple ( *this
+
2832 , function );
+
2833 }
+
2835
+
2838#pragma mark GENERATOR_SNAPSHOT_LOOPS
+
2858 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2859 inline
+
2860 void for_all_real_power_generator_snapshots ( FUNCTION function )
+
2861 {
+
2862 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2863 ::for_all_real_power_generator_snapshots ( *this
+
2864 , function );
+
2865 }
+
2866
+
2888 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2889 inline
+
2890 void for_all_real_power_generator_snapshots( FUNCTION function ) const
+
2891 {
+
2892 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2893 ::for_all_real_power_generator_snapshots ( *this
+
2894 , function );
+
2895 }
+
2896
+
2925 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2926 inline
+
2927 void for_all_real_power_generator_snapshots_of ( Types::generatorId generatorId
+
2928 , FUNCTION function )
+
2929 {
+
2930 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2931 ::for_all_real_power_generator_snapshots_of ( *this
+
2932 , generatorId
+
2933 , function );
+
2934 }
+
2935
+
2963 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
2964 inline
+
2965 void for_all_real_power_generator_snapshots_of ( Types::vertexId generatorId
+
2966 , FUNCTION function ) const
+
2967 {
+
2968 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
2969 ::for_all_real_power_generator_snapshots_of ( *this
+
2970 , generatorId
+
2971 , function );
+
2972 }
+
2973
+
3001 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3002 inline
+
3003 void for_all_real_power_generator_snapshots_of ( TGeneratorProperties const & generatorProperties
+
3004 , FUNCTION function )
+
3005 {
+
3006 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3007 ::for_all_real_power_generator_snapshots_of ( *this
+
3008 , generatorProperties
+
3009 , function );
+
3010 }
+
3011
+
3039 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3040 inline
+
3041 void for_all_real_power_generator_snapshots_of ( TGeneratorProperties const & generatorProperties
+
3042 , FUNCTION function ) const
+
3043 {
+
3044 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3045 ::for_all_real_power_generator_snapshots_of ( *this
+
3046 , generatorProperties
+
3047 , function );
+
3048 }
+
3049
+
3078 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3079 inline
+
3080 void for_all_real_power_generator_snapshots_at ( Types::vertexId vertexId
+
3081 , FUNCTION function )
+
3082 {
+
3083 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3084 ::for_all_real_power_generator_snapshots_at ( *this
+
3085 , vertexId
+
3086 , function );
+
3087 }
+
3088
+
3117 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3118 inline
+
3119 void for_all_real_power_generator_snapshots_at ( Types::vertexId vertexId
+
3120 , FUNCTION function ) const
+
3121 {
+
3122 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3123 ::for_all_real_power_generator_snapshots_at ( *this
+
3124 , vertexId
+
3125 , function );
+
3126 }
+
3127
+
3156 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3157 inline
+
3158 void for_all_real_power_generator_snapshots_at ( TVertex const & vertex
+
3159 , FUNCTION function )
+
3160 {
+
3161 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3162 ::for_all_real_power_generator_snapshots_at ( *this
+
3163 , vertex
+
3164 , function );
+
3165 }
+
3166
+
3195 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3196 inline
+
3197 void for_all_real_power_generator_snapshots_at ( TVertex const & vertex
+
3198 , FUNCTION function ) const
+
3199 {
+
3200 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3201 ::for_all_real_power_generator_snapshots_at ( *this
+
3202 , vertex
+
3203 , function );
+
3204 }
+
3205
+
3238 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3239 inline
+
3240 void for_all_real_power_generator_snapshots_at ( Types::vertexId vertexId
+
3241 , Types::index timestampPosition
+
3242 , FUNCTION function )
+
3243 {
+
3244 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3245 ::for_all_real_power_generator_snapshots_at ( *this
+
3246 , vertexId
+
3247 , timestampPosition
+
3248 , function );
+
3249 }
+
3250
+
3283 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3284 inline
+
3285 void for_all_real_power_generator_snapshots_at ( Types::vertexId vertexId
+
3286 , Types::index timestampPosition
+
3287 , FUNCTION function ) const
+
3288 {
+
3289 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3290 ::for_all_real_power_generator_snapshots_at ( *this
+
3291 , vertexId
+
3292 , timestampPosition
+
3293 , function );
+
3294 }
+
3295
+
3326 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3327 inline
+
3328 void for_all_real_power_generator_snapshots_at ( TVertex const & vertex
+
3329 , Types::index timestampPosition
+
3330 , FUNCTION function )
+
3331 {
+
3332 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3333 ::for_all_real_power_generator_snapshots_at ( *this
+
3334 , vertex
+
3335 , timestampPosition
+
3336 , function );
+
3337 }
+
3338
+
3370 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3371 inline
+
3372 void for_all_real_power_generator_snapshots_at ( TVertex const & vertex
+
3373 , Types::index timestampPosition
+
3374 , FUNCTION function ) const
+
3375 {
+
3376 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3377 ::for_all_real_power_generator_snapshots_at ( *this
+
3378 , vertex
+
3379 , timestampPosition
+
3380 , function );
+
3381 }
+
3383
+
3386#pragma mark SERIELL_LOAD_LOOPS
+
3387
+
3408 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3409 inline
+
3410 void for_all_loads ( FUNCTION function )
+
3411 {
+
3412 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3413 ::for_all_loads ( *this
+
3414 , function );
+
3415 }
+
3416
+
3437 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3438 inline
+
3439 void for_all_loads ( FUNCTION function ) const
+
3440 {
+
3441 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3442 ::for_all_loads ( *this
+
3443 , function );
+
3444 }
+
3445
+
3467 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3468 inline
+
3469 void for_all_vertex_identifiers_with_load ( FUNCTION function ) const
+
3470 {
+
3471 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3472 ::for_all_vertex_identifiers_with_load ( *this
+
3473 , function );
+
3474 }
+
3475
+
3498 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3499 inline
+
3500 void for_all_load_identifiers_at ( Types::vertexId vertexId
+
3501 , FUNCTION function ) const
+
3502 {
+
3503 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3504 ::for_all_load_identifiers_at ( vertexId
+
3505 , *this
+
3506 , function );
+
3507 }
+
3508
+
3530 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3531 inline
+
3532 void for_all_load_identifiers_at ( TVertex const & vertex
+
3533 , FUNCTION function ) const
+
3534 {
+
3535 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3536 ::for_all_load_identifiers_at ( vertex
+
3537 , *this
+
3538 , function );
+
3539 }
+
3540
+
3562 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3563 inline
+
3564 void for_all_loads_at ( TVertex const & vertex
+
3565 , FUNCTION function )
+
3566 {
+
3567 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3568 ::for_all_loads_at ( vertex
+
3569 , *this
+
3570 , function );
+
3571 }
+
3572
+
3594 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3595 inline
+
3596 void for_all_loads_at ( TVertex const & vertex
+
3597 , FUNCTION function ) const
+
3598 {
+
3599 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3600 ::for_all_loads_at ( vertex
+
3601 , *this
+
3602 , function );
+
3603 }
+
3604
+
3626 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3627 inline
+
3628 void for_all_loads_at ( Types::vertexId const vertexId
+
3629 , FUNCTION function )
+
3630 {
+
3631 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3632 ::for_all_loads_at ( vertexId
+
3633 , *this
+
3634 , function );
+
3635 }
+
3636
+
3657 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3658 inline
+
3659 void for_all_loads_at ( Types::vertexId vertexId
+
3660 , FUNCTION function ) const
+
3661 {
+
3662 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3663 ::for_all_loads_at ( vertexId
+
3664 , *this
+
3665 , function );
+
3666 }
+
3667
+
3690 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3691 inline
+
3692 void for_all_load_tuples ( FUNCTION function )
+
3693 {
+
3694 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3695 ::for_all_load_tuples ( *this
+
3696 , function );
+
3697 }
+
3698
+
3721 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3722 inline
+
3723 void for_all_load_tuples ( FUNCTION function ) const
+
3724 {
+
3725 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3726 ::for_all_load_tuples ( *this
+
3727 , function );
+
3728 }
+
3729
+
3752 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3753 inline
+
3754 void for_all_loads_tuple ( FUNCTION function )
+
3755 {
+
3756 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3757 ::for_all_loads_tuple ( *this
+
3758 , function );
+
3759 }
+
3760
+
3762
+
3765#pragma mark LOAD_SNAPSHOT_LOOPS
+
3785 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3786 inline
+
3787 void for_all_real_power_load_snapshots( FUNCTION function )
+
3788 {
+
3789 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3790 ::for_all_real_power_load_snapshots ( *this
+
3791 , function );
+
3792 }
+
3793
+
3813 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3814 inline
+
3815 void for_all_real_power_load_snapshots( FUNCTION function ) const
+
3816 {
+
3817 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3818 ::for_all_real_power_load_snapshots ( *this
+
3819 , function );
+
3820 }
+
3821
+
3850 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3851 inline
+
3852 void for_all_real_power_load_snapshots_of ( Types::loadId loadId
+
3853 , FUNCTION function )
+
3854 {
+
3855 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3856 ::for_all_real_power_load_snapshots_of ( *this
+
3857 , loadId
+
3858 , function );
+
3859 }
+
3860
+
3889 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3890 inline
+
3891 void for_all_real_power_load_snapshots_of ( Types::vertexId loadId
+
3892 , FUNCTION function ) const
+
3893 {
+
3894 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3895 ::for_all_real_power_load_snapshots_of ( *this
+
3896 , loadId
+
3897 , function );
+
3898 }
+
3899
+
3927 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3928 inline
+
3929 void for_all_real_power_load_snapshots_of ( TLoadProperties load
+
3930 , FUNCTION function )
+
3931 {
+
3932 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3933 ::for_all_real_power_load_snapshots_of ( *this
+
3934 , load
+
3935 , function );
+
3936 }
+
3937
+
3965 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
3966 inline
+
3967 void for_all_real_power_load_snapshots_of ( TLoadProperties const & load
+
3968 , FUNCTION function ) const
+
3969 {
+
3970 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
3971 ::for_all_real_power_load_snapshots_of ( *this
+
3972 , load
+
3973 , function );
+
3974 }
+
3975
+
4004 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4005 inline
+
4006 void for_all_real_power_load_snapshots_at ( Types::vertexId vertexId
+
4007 , FUNCTION function )
+
4008 {
+
4009 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4010 ::for_all_real_power_load_snapshots_at ( *this
+
4011 , vertexId
+
4012 , function );
+
4013 }
+
4014
+
4043 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4044 inline
+
4045 void for_all_real_power_load_snapshots_at ( Types::vertexId vertexId
+
4046 , FUNCTION function ) const
+
4047 {
+
4048 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4049 ::for_all_real_power_load_snapshots_at ( *this
+
4050 , vertexId
+
4051 , function );
+
4052 }
+
4053
+
4081 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4082 inline
+
4083 void for_all_real_power_load_snapshots_at( TVertex const & vertex
+
4084 , FUNCTION function )
+
4085 {
+
4086 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4087 ::for_all_real_power_load_snapshots_at ( *this
+
4088 , vertex
+
4089 , function );
+
4090 }
+
4091
+
4120 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4121 inline
+
4122 void for_all_real_power_load_snapshots_at ( TVertex const & vertex
+
4123 , FUNCTION function ) const
+
4124 {
+
4125 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4126 ::for_all_real_power_load_snapshots_at ( *this
+
4127 , vertex
+
4128 , function );
+
4129 }
+
4130
+
4162 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4163 inline
+
4164 void for_all_real_power_load_snapshots_at ( Types::vertexId vertexId
+
4165 , Types::index timestampPosition
+
4166 , FUNCTION function )
+
4167 {
+
4168 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4169 ::for_all_real_power_load_snapshots_at ( *this
+
4170 , vertexId
+
4171 , timestampPosition
+
4172 , function );
+
4173 }
+
4174
+
4206 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4207 inline
+
4208 void for_all_real_power_load_snapshots_at ( Types::vertexId vertexId
+
4209 , Types::index timestampPosition
+
4210 , FUNCTION function ) const
+
4211 {
+
4212 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4213 ::for_all_real_power_load_snapshots_at ( *this
+
4214 , vertexId
+
4215 , timestampPosition
+
4216 , function );
+
4217 }
+
4218
+
4248 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4249 inline
+
4250 void for_all_real_power_load_snapshots_at( TVertex const & vertex
+
4251 , Types::index timestampPosition
+
4252 , FUNCTION function )
+
4253 {
+
4254 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4255 ::for_all_real_power_load_snapshots_at ( *this
+
4256 , vertex
+
4257 , timestampPosition
+
4258 , function );
+
4259 }
+
4260
+
4290 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
4291 inline
+
4292 void for_all_real_power_load_snapshots_at ( TVertex const & vertex
+
4293 , Types::index timestampPosition
+
4294 , FUNCTION function ) const
+
4295 {
+
4296 internal::PowerGridLoopDifferentiation<TNetwork, Policy>
+
4297 ::for_all_real_power_load_snapshots_at ( *this
+
4298 , vertex
+
4299 , timestampPosition
+
4300 , function );
+
4301 }
+
4303
+
4304 inline Types::count NumberOfGenerators() const
+
4305 {
+
4306 return numberOfGenerators_;
+
4307 }
+
4308
+
4309 inline Types::count NumberOfLoads() const
+
4310 {
+
4311 return numberOfLoads_;
+
4312 }
+
4313
+
4314 inline Types::count NumberOfTimestamps() const
+
4315 {
+
4316 return timestamps_.size();
+
4317 }
+
4318
+
4319 private:
+
4320#pragma mark FRIENDS
+
4321 friend internal::PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::sequential>;
+
4322 friend internal::PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::breakable>;
+
4323 friend internal::PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::parallel>;
+
4324
+
4325#pragma mark MEMBERS
+
4326 Types::real baseMva_;
+
4327 TBound thetaBound_;
+
4329 Types::count verticesWithGeneratorCount_;
+
4330 Types::count numberOfGenerators_;
+
4331 Types::count numberOfLoads_;
+
4333 std::vector< std::vector<Types::vertexId> > generatorsAtVertex_;
+
4334 std::vector< TGeneratorProperties > generators_;
+
4335 std::vector< bool > generatorExists_;
+
4337 std::vector< std::vector<Types::vertexId> > loadsAtVertex_;
+
4338 std::vector< TLoadProperties > loads_;
+
4339 std::vector< bool > loadExists_;
+
4341 std::vector< std::vector<Types::generatorSnapshot>> generatorRealPowerSnapshots_;
+
4342 std::vector< std::vector<Types::loadSnapshot>> loadSnapshots_;
+
4343 std::vector< Types::timestampSnapshot > timestamps_;
+
4344 std::vector< Types::weightSnapshot > snapshotWeights_;
+
4346 Vertices::BoundType generatorBoundType_;
+
4347 Vertices::BoundType loadBoundType_;
+
4349 TGraph graph_;
+
4350};
+
4351
+
4368template<typename PowerGridType>
+
4369inline void SwitchEdges ( PowerGridType & grid
+
4370 , Subgraph<typename PowerGridType::TGraph> remainingSubgraph)
+
4371{
+
4372 using TEdge = typename PowerGridType::TGraph::TEdge;
+
4373 grid.Graph().template for_all_edges<ExecutionPolicy::sequential>(
+
4374 []( TEdge & edge )
+
4375 {
+
4376 auto & properties = edge.Properties();
+
4377 properties.Status() = false;
+
4378 properties.Type() = Edges::ElectricalEdgeType::switched;
+
4379 }
+
4380 );
+
4381
+
4382 for ( auto edgeId : remainingSubgraph.Edges() )
+
4383 {
+
4384 auto & properties = grid.Graph().EdgeAt(edgeId).Properties();
+
4385 properties.Status() = true;
+
4386 properties.Type() = Edges::ElectricalEdgeType::standard;
+
4387 }
+
4388}
+
4389
+
4390} // namespace egoa
+
4391
+
4392#endif // EGOA__DATA_STRUCTURES__GRAPHS__POWER_GRID_HPP
+
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+ +
egoa::PowerGrid::RemoveGeneratorAt
void RemoveGeneratorAt(Types::vertexId vertexId, Types::generatorId generatorId)
Removes a generator with generatorId at a vertex with identifier vertexId.
Definition PowerGrid.hpp:574
+
egoa::PowerGrid::for_all_vertex_identifiers_with_generator
void for_all_vertex_identifiers_with_generator(FUNCTION function)
Iterate over all vertices that have a generator.
Definition PowerGrid.hpp:2550
+
egoa::PowerGrid::generatorRealPowerSnapshots_
std::vector< std::vector< Types::generatorSnapshot > > generatorRealPowerSnapshots_
Definition PowerGrid.hpp:4335
+
egoa::PowerGrid::RealPowerLoadAt
Types::real RealPowerLoadAt(Types::vertexId vertexId, Types::index snapshotId=0) const
Total real power load for a certain snapshot (timestamp) at a vertex.
Definition PowerGrid.hpp:1544
+
egoa::PowerGrid::generatorExists_
std::vector< bool > generatorExists_
Definition PowerGrid.hpp:4329
+
egoa::PowerGrid::RemoveLoadAt
void RemoveLoadAt(Types::vertexId vertexId, Types::loadId loadId)
Removes a load at a vertex with identifier vertexId.
Definition PowerGrid.hpp:1254
+
egoa::PowerGrid::ThetaBound
TBound & ThetaBound()
Setter for the voltage angle bound.
Definition PowerGrid.hpp:139
+
egoa::PowerGrid::numberOfLoads_
Types::count numberOfLoads_
Definition PowerGrid.hpp:4325
+
egoa::PowerGrid::PowerGrid
PowerGrid()
Constructs the object.
Definition PowerGrid.hpp:67
+
egoa::PowerGrid::UpdateGeneratorSnapshotSize
void UpdateGeneratorSnapshotSize()
Update generator snapshot size.
Definition PowerGrid.hpp:1754
+
egoa::PowerGrid::for_all_real_power_load_snapshots_of
void for_all_real_power_load_snapshots_of(Types::loadId loadId, FUNCTION function)
The for loop over all real power snapshots of a load with loadId.
Definition PowerGrid.hpp:3846
+
egoa::PowerGrid::NetworkType
Types::name NetworkType() const
Get the current network bound type.
Definition PowerGrid.hpp:387
+
egoa::PowerGrid::for_all_real_power_generator_snapshots
void for_all_real_power_generator_snapshots(FUNCTION function)
The for loop over all generator maximum real power p.u. snapshots.
Definition PowerGrid.hpp:2854
+
egoa::PowerGrid::FindGenerator
Types::generatorId FindGenerator(TGeneratorProperties const &generatorProperty, std::vector< TGeneratorProperties > const &generators) const
Find a generator in a vector.
Definition PowerGrid.hpp:942
+
egoa::PowerGrid::LoadSnapshotsAt
void LoadSnapshotsAt(Types::vertexId vertexId, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)
Loads a snapshot at a vertex with vertexId and a timestampPosition.
Definition PowerGrid.hpp:2273
+
egoa::PowerGrid::loadExists_
std::vector< bool > loadExists_
Definition PowerGrid.hpp:4333
+
egoa::PowerGrid::NetworkBoundType
Vertices::BoundType NetworkBoundType() const
Get the current network bound type.
Definition PowerGrid.hpp:373
+
egoa::PowerGrid::for_all_generator_tuple
void for_all_generator_tuple(FUNCTION function)
Iterate over all vertices that have a generator and its generators.
Definition PowerGrid.hpp:2732
+
egoa::PowerGrid::IsPureUnbounded
bool IsPureUnbounded() const
Determines if pure unbounded.
Definition PowerGrid.hpp:348
+
egoa::PowerGrid::HasLoadAt
bool HasLoadAt(Types::vertexId vertexId) const
Determines if there is a load at vertex with vertexId.
Definition PowerGrid.hpp:1359
+
egoa::PowerGrid::for_all_loads_tuple
void for_all_loads_tuple(FUNCTION function)
The for loop over all verticesthat have a load.
Definition PowerGrid.hpp:3748
+
egoa::PowerGrid::for_all_loads_at
void for_all_loads_at(TVertex const &vertex, FUNCTION function)
The for loop over all load objects at a vertex.
Definition PowerGrid.hpp:3558
+
egoa::PowerGrid::PositionOf
Types::index PositionOf(Types::timestampSnapshot timestamp) const
Position of a timestamp.
Definition PowerGrid.hpp:1871
+
egoa::PowerGrid::GeneratorsAt
void GeneratorsAt(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const
All generator identifiers at a vertex with vertexId.
Definition PowerGrid.hpp:814
+
egoa::PowerGrid::HasLoad
bool HasLoad(Types::loadId loadId) const
Determines if the load identifier loadId exists.
Definition PowerGrid.hpp:1328
+
egoa::PowerGrid::MakePureUnbounded
void MakePureUnbounded()
Makes the power grid pure unbounded.
Definition PowerGrid.hpp:285
+
egoa::PowerGrid::AddGeneratorRealPowerSnapshotAt
void AddGeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::generatorSnapshot maximumRealPowerGenerationPu)
Adds a generator snapshot at generator with identifier generatorId.
Definition PowerGrid.hpp:1736
+
egoa::PowerGrid::for_all_vertex_identifiers_with_load
void for_all_vertex_identifiers_with_load(FUNCTION function) const
The for loop over all vertices that have a load.
Definition PowerGrid.hpp:3463
+
egoa::PowerGrid::MakeExact
void MakeExact()
Makes the power grid exact bounded.
Definition PowerGrid.hpp:315
+
egoa::PowerGrid::numberOfGenerators_
Types::count numberOfGenerators_
Definition PowerGrid.hpp:4324
+
egoa::PowerGrid::generatorsAtVertex_
std::vector< std::vector< Types::vertexId > > generatorsAtVertex_
Definition PowerGrid.hpp:4327
+
egoa::PowerGrid::LoadId
Types::loadId LoadId(TLoadProperties const &load) const
The load identifier of a load object.
Definition PowerGrid.hpp:1394
+
egoa::PowerGrid::loadSnapshots_
std::vector< std::vector< Types::loadSnapshot > > loadSnapshots_
Definition PowerGrid.hpp:4336
+
egoa::PowerGrid::TotalRealPowerLoadBoundAt
TBound TotalRealPowerLoadBoundAt(Types::vertexId vertexId, Types::index timestamp=0) const
Total real power load bound at vertex vertexId.
Definition PowerGrid.hpp:1589
+
egoa::PowerGrid::Graph
TGraph const & Graph() const
Getter for the underlying graph.
Definition PowerGrid.hpp:89
+ +
egoa::PowerGrid::generators_
std::vector< TGeneratorProperties > generators_
Definition PowerGrid.hpp:4328
+
egoa::PowerGrid::GeneratorBoundType
Vertices::BoundType & GeneratorBoundType()
Setter for the generator bound type.
Definition PowerGrid.hpp:166
+
egoa::PowerGrid::TimestampAt
Types::timestampSnapshot TimestampAt(Types::index timestampPosition) const
Timestamp at position.
Definition PowerGrid.hpp:1891
+
egoa::PowerGrid::LoadsAt
void LoadsAt(Types::vertexId vertexId, std::vector< TLoadProperties > &loads) const
The loads at a vertex with identifier vertexId.
Definition PowerGrid.hpp:1491
+
egoa::PowerGrid::OutputLoadSnaps
void OutputLoadSnaps()
Output load snapshots.
Definition PowerGrid.hpp:1796
+
egoa::PowerGrid::IsUnbounded
bool IsUnbounded() const
Determines if unbounded.
Definition PowerGrid.hpp:337
+
egoa::PowerGrid::Graph
TGraph & Graph()
Setter for the underlying graph.
Definition PowerGrid.hpp:99
+
egoa::PowerGrid::verticesWithGeneratorCount_
Types::count verticesWithGeneratorCount_
Definition PowerGrid.hpp:4323
+
egoa::PowerGrid::OutputGeneratorSnaps
void OutputGeneratorSnaps()
Output generation snapshots.
Definition PowerGrid.hpp:1771
+
egoa::PowerGrid::for_all_real_power_generator_snapshots_at
void for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.
Definition PowerGrid.hpp:3074
+
egoa::PowerGrid::UpdateLoadSnapshotSize
void UpdateLoadSnapshotSize()
Update load snapshot.
Definition PowerGrid.hpp:1763
+
egoa::PowerGrid::GeneratorAt
TGeneratorProperties & GeneratorAt(Types::generatorId generatorId)
Generator at generator's identifier generatorId.
Definition PowerGrid.hpp:768
+
egoa::PowerGrid::TotalReactivePowerGenerationBoundAt
TBound TotalReactivePowerGenerationBoundAt(Types::vertexId vertexId, Types::index timestampPosition=0) const
The total reactive power generation bound.
Definition PowerGrid.hpp:1095
+
egoa::PowerGrid::LoadSnapshotOf
Types::loadSnapshot LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp)
Load snapshot at a timestamp.
Definition PowerGrid.hpp:2174
+
egoa::PowerGrid::LoadIds
void LoadIds(Types::vertexId vertexId, std::vector< Types::loadId > &loadIds) const
Loads identifiers.
Definition PowerGrid.hpp:1413
+
egoa::PowerGrid::HasGenerator
bool HasGenerator(Types::generatorId generatorId) const
Determines if there is a generator with the given generatorId.
Definition PowerGrid.hpp:651
+
egoa::PowerGrid::AddSnapshotTimestamp
void AddSnapshotTimestamp(Types::timestampSnapshot timestamp)
Adds a timestamp.
Definition PowerGrid.hpp:1856
+
egoa::PowerGrid::TotalRealPowerGenerationBoundAt
TBound TotalRealPowerGenerationBoundAt(Types::vertexId vertexId, Types::index timestampPosition=0) const
The total real power generation bound of all generators at a vertex.
Definition PowerGrid.hpp:995
+
egoa::PowerGrid::loads_
std::vector< TLoadProperties > loads_
Definition PowerGrid.hpp:4332
+
egoa::PowerGrid::MakeBounded
void MakeBounded()
Makes the power grid bounded.
Definition PowerGrid.hpp:219
+
egoa::PowerGrid::GeneratorBoundType
Vertices::BoundType const & GeneratorBoundType() const
Getter for the generator bound type.
Definition PowerGrid.hpp:155
+
egoa::PowerGrid::timestamps_
std::vector< Types::timestampSnapshot > timestamps_
Definition PowerGrid.hpp:4337
+
egoa::PowerGrid::AddLoadSnapshotAt
void AddLoadSnapshotAt(Types::loadId loadId, Types::loadSnapshot snapshot)
Adds a real power load snapshot.
Definition PowerGrid.hpp:1822
+
egoa::PowerGrid::for_all_load_tuples
void for_all_load_tuples(FUNCTION function)
The for loop over all verticesthat have a load and its load objects.
Definition PowerGrid.hpp:3686
+
egoa::PowerGrid::for_all_generators_tuple
void for_all_generators_tuple(FUNCTION function)
Iterate over all vertices that have a generator and its generators.
Definition PowerGrid.hpp:2792
+
egoa::PowerGrid::AddLoadAt
Types::loadId AddLoadAt(Types::vertexId vertexId, TLoadProperties load)
Adds a load at a vertex with identifier vertexId.
Definition PowerGrid.hpp:1184
+
egoa::PowerGrid::ThetaBound
TBound ThetaBound() const
Getter for the voltage angle bound.
Definition PowerGrid.hpp:129
+
egoa::PowerGrid::GeneratorRealPowerSnapshotsAt
void GeneratorRealPowerSnapshotsAt(Types::timestampSnapshot timestamp, std::vector< Types::generatorSnapshot > &snapshotsAtTimestamp) const
Generator snapshots at a timestamp.
Definition PowerGrid.hpp:2023
+
egoa::PowerGrid::TotalRealPowerGenerationAt
Types::real TotalRealPowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) const
The total real power generation at a vertex with vertexId.
Definition PowerGrid.hpp:1054
+
egoa::PowerGrid::GeneratorId
Types::generatorId GeneratorId(TGeneratorProperties const &generatorProperty) const
The generator identifier of a generator .
Definition PowerGrid.hpp:726
+
egoa::PowerGrid::for_all_real_power_generator_snapshots_of
void for_all_real_power_generator_snapshots_of(Types::generatorId generatorId, FUNCTION function)
The for loop over all maximum real power p.u. snapshots of a generator with generatorId.
Definition PowerGrid.hpp:2921
+
egoa::PowerGrid::for_all_loads
void for_all_loads(FUNCTION function)
The for loop over all loads (vertex independent).
Definition PowerGrid.hpp:3404
+
egoa::PowerGrid::loadBoundType_
Vertices::BoundType loadBoundType_
Definition PowerGrid.hpp:4341
+
egoa::PowerGrid::operator<<
friend std::ostream & operator<<(std::ostream &os, PowerGrid< TGraph > const &rhs)
Output.
Definition PowerGrid.hpp:407
+
egoa::PowerGrid::IsExact
bool IsExact() const
Determines if exact.
Definition PowerGrid.hpp:362
+
egoa::PowerGrid::BaseMva
Types::real BaseMva() const
Getter for the base MVA.
Definition PowerGrid.hpp:109
+
egoa::PowerGrid::TotalReactivePowerGenerationAt
Types::real TotalReactivePowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) const
The total reactive power generation of all generator snapshots for one timestamp at vertex with ide...
Definition PowerGrid.hpp:1155
+
egoa::PowerGrid::for_all_real_power_load_snapshots_at
void for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all real power snapshots of a load.
Definition PowerGrid.hpp:4000
+
egoa::PowerGrid::AddSnapshotWeighting
void AddSnapshotWeighting(Types::weightSnapshot weight)
Adds a snapshot weighting.
Definition PowerGrid.hpp:1842
+
egoa::PowerGrid::GeneratorReactivePowerSnapshotAt
Types::generatorSnapshot GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const
Generator snapshot at a given timestamp.
Definition PowerGrid.hpp:2067
+
egoa::PowerGrid::snapshotWeights_
std::vector< Types::weightSnapshot > snapshotWeights_
Definition PowerGrid.hpp:4338
+
egoa::PowerGrid::HasGeneratorAt
bool HasGeneratorAt(Types::vertexId vertexId) const
Determines if it has a generator at vertex with identifier vertexId.
Definition PowerGrid.hpp:684
+
egoa::PowerGrid::IsBounded
bool IsBounded() const
Determines if bounded.
Definition PowerGrid.hpp:326
+
egoa::PowerGrid::GeneratorIds
void GeneratorIds(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const
Identifiers of all generators at a vertex with vertexId.
Definition PowerGrid.hpp:739
+ +
egoa::PowerGrid::GeneratorRealPowerSnapshotAt
Types::generatorSnapshot GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const
Generator real power snapshot at a given timestamp.
Definition PowerGrid.hpp:1917
+
egoa::PowerGrid::BaseMva
Types::real & BaseMva()
Setter for the base MVA.
Definition PowerGrid.hpp:119
+
egoa::PowerGrid::for_all_real_power_load_snapshots
void for_all_real_power_load_snapshots(FUNCTION function)
The for loop over all load real power snapshots.
Definition PowerGrid.hpp:3781
+
egoa::PowerGrid::for_all_generators_at
void for_all_generators_at(TVertex const &vertex, FUNCTION function)
The for loop over all generators at a vertex with vertexId.
Definition PowerGrid.hpp:2427
+
egoa::PowerGrid::LoadBoundType
Vertices::BoundType & LoadBoundType()
Setter for the load bound type.
Definition PowerGrid.hpp:188
+
egoa::PowerGrid::LoadBoundType
Vertices::BoundType const & LoadBoundType() const
Getter for the load bound type.
Definition PowerGrid.hpp:177
+
egoa::PowerGrid::baseMva_
Types::real baseMva_
Definition PowerGrid.hpp:4320
+
egoa::PowerGrid::TotalRealPowerLoadAt
Types::real TotalRealPowerLoadAt(Types::vertexId vertexId, Types::index timestampPosition) const
The total real power load at a vertex with id vertexId.
Definition PowerGrid.hpp:1659
+
egoa::PowerGrid::LoadAt
TLoadProperties & LoadAt(Types::loadId loadId)
Load at load's identifier loadId.
Definition PowerGrid.hpp:1466
+
egoa::PowerGrid::generatorBoundType_
Vertices::BoundType generatorBoundType_
Definition PowerGrid.hpp:4340
+
egoa::PowerGrid::TotalReactivePowerLoadBoundAt
TBound TotalReactivePowerLoadBoundAt(Types::vertexId vertexId) const
Total reactive power load bound at a vertex.
Definition PowerGrid.hpp:1690
+
egoa::PowerGrid::AddGeneratorAt
Types::generatorId AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties const &generatorProperty)
Adds a generator at a vertex with vertex identifier vertexId.
Definition PowerGrid.hpp:457
+
egoa::PowerGrid::for_all_load_identifiers_at
void for_all_load_identifiers_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all load identifiers at a vertex identifier vertexId.
Definition PowerGrid.hpp:3494
+
egoa::PowerGrid::MakeUnbounded
void MakeUnbounded()
Makes the power grid unbounded.
Definition PowerGrid.hpp:247
+
egoa::PowerGrid::for_all_generator_identifiers_at
void for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function)
Iterate over all generator identifiers at a vertex.
Definition PowerGrid.hpp:2607
+
egoa::PowerGrid::for_all_generators
void for_all_generators(FUNCTION function)
Iterate over all generators (vertex independent).
Definition PowerGrid.hpp:2370
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
egoa::internal::PowerGridLoopDifferentiation
The base class for for loops for power grid.
Definition PowerGridIterators.hpp:33
+
egoa
Definition Color.cpp:15
+
egoa::SwitchEdges
void SwitchEdges(PowerGridType &grid, Subgraph< typename PowerGridType::TGraph > remainingSubgraph)
Switches all edges that do not belong to the subgraph.
Definition PowerGrid.hpp:4363
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_power_grid_i_o_8cpp_source.html b/_power_grid_i_o_8cpp_source.html new file mode 100644 index 00000000..dbca6123 --- /dev/null +++ b/_power_grid_i_o_8cpp_source.html @@ -0,0 +1,145 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/IO/PowerGridIO.cpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PowerGridIO.cpp
+
+
+
1/*
+
2 * PowerGridIO.cpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#include "IO/PowerGridIO.hpp"
+
9#include "IO/Parser/IeeeCdfMatlabParser.hpp"
+
10#include "IO/Parser/PyPsaParser.hpp"
+
11
+
12namespace egoa {
+
13
+
14template<typename GraphType>
+
15const std::vector<typename PowerGridIO<GraphType>::ReaderFunctionStreamBased> PowerGridIO<GraphType>::streamReaders = {
+
16 PowerGridIO<GraphType>::readIeeeCdfMatlab
+
17 //@todo PowerGridIO::readIeeePti
+
18};
+
19
+
20template<typename GraphType>
+
21const std::vector<typename PowerGridIO<GraphType>::ReaderFunctionStringBased> PowerGridIO<GraphType>::fileReaders = {
+
22 PowerGridIO<GraphType>::ReadPyPsa
+
23 //@todo PowerGridIO::readIeeePti
+
24};
+
25//
+
26template<typename GraphType>
+
27const std::vector<typename PowerGridIO<GraphType>::ReaderFunctionStreamBasedPowerGridAndCandidateNetwork> PowerGridIO<GraphType>::streamReadersPowerGridAndCandidateNetwork = {
+
28 PowerGridIO<GraphType>::ReadPyPsa
+
29 //@todo PowerGridIO::readIeeePti
+
30};
+
31
+
32template<typename GraphType>
+
33const std::vector<typename PowerGridIO<GraphType>::WriterFunctionStreamBased> PowerGridIO<GraphType>::streamWriters = {
+
34 PowerGridIO<GraphType>::writeIeeeCdfMatlab
+
35 , PowerGridIO<GraphType>::WriteGraphDot
+
36 , PowerGridIO<GraphType>::WriteGeoJson
+
37 //@todo PowerGridIO::readIeeePti
+
38};
+
39
+
40template<typename GraphType>
+
41const std::vector<typename PowerGridIO<GraphType>::WriterFunctionStreamBasedtionStringBased> PowerGridIO<GraphType>::fileWriters = {
+
42 PowerGridIO<GraphType>::WriteGraphGml
+
43 , PowerGridIO<GraphType>::WriteGraphDot
+
44 , PowerGridIO<GraphType>::WriteGeoJson
+
45 //@todo PowerGridIO::readIeeePti
+
46};
+
47
+
48} // namespace egoa
+
egoa::PowerGridIO::readIeeeCdfMatlab
static bool readIeeeCdfMatlab(PowerGrid< GraphType > &network, std::istream &input_stream)
Reads an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:252
+
egoa::PowerGridIO::writeIeeeCdfMatlab
static bool writeIeeeCdfMatlab(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:271
+
egoa::PowerGridIO::WriteGraphDot
static bool WriteGraphDot(PowerGrid< GraphType > const &network, std::ostream &outputStream)
Writes a graph dot.
Definition PowerGridIO.hpp:631
+
egoa::PowerGridIO::WriteGraphGml
static bool WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes a graph into a gml file.
Definition PowerGridIO.hpp:402
+
egoa::PowerGridIO::ReadPyPsa
static bool ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)
Reads a PyPsa file.
Definition PowerGridIO.hpp:294
+
egoa::PowerGridIO::WriteGeoJson
static bool WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)
Write the network into a GeoJson format.
Definition PowerGridIO.hpp:340
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_power_grid_i_o_8hpp_source.html b/_power_grid_i_o_8hpp_source.html new file mode 100644 index 00000000..e6f262a0 --- /dev/null +++ b/_power_grid_i_o_8hpp_source.html @@ -0,0 +1,612 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/PowerGridIO.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PowerGridIO.hpp
+
+
+
1/*
+
2 * PowerGridIO.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 *
+
7 * Check definitions under https://graphviz.gitlab.io/_pages/doc/info/output.html
+
8 */
+
9
+
10#ifndef EGOA__IO__POWER_GRID_IO_HPP
+
11#define EGOA__IO__POWER_GRID_IO_HPP
+
12
+
13#include <fstream>
+
14#include <sstream>
+
15
+
16#ifdef OGDF_AVAILABLE
+
17 #include <ogdf/fileformats/GraphIO.h>
+
18#endif // OGDF_AVAILABLE
+
19
+
20#include "DataStructures/Networks/PowerGrid.hpp"
+
21#include "IO/Parser/IeeeCdfMatlabParser.hpp"
+
22#include "IO/Parser/PyPsaParser.hpp"
+
23#include "IO/Writer/GeojsonWriter.hpp"
+
24
+
25namespace egoa {
+
26
+
32template<typename GraphType>
+
+
33class PowerGridIO {
+
34
+
35 // Template type aliasing
+
36 using TGraph = GraphType;
+
37 using TElectricalVertex = typename TGraph::TVertex;
+
38 using TElectricalEdge = typename TGraph::TEdge;
+
39
+
40 public:
+
41
+
42#pragma mark FUNCTION POINTER
+
43
+
46 using ReaderFunctionStreamBased = bool (*)( PowerGrid< GraphType> &
+
47 , std::istream & );
+
48 using ReaderFunctionStringBased = bool (*)( PowerGrid< GraphType> &
+
49 , std::string const & );
+
50 using ReaderFunctionStreamBasedPowerGridAndCandidateNetwork
+
51 = bool (*)( PowerGrid< GraphType> &
+
52 , GraphType &
+
53 , std::string const & );
+
55
+
58 using WriterFunctionStreamBased = bool (*)( PowerGrid<GraphType> const &
+
59 , std::ostream & );
+
60 using WriterFunctionStreamBasedtionStringBased
+
61 = bool (*)( PowerGrid<GraphType> const &
+
62 , std::string const & );
+
64
+
67 static std::vector<ReaderFunctionStreamBased> const streamReaders;
+
68 static std::vector<ReaderFunctionStringBased> const fileReaders;
+
69 static std::vector<ReaderFunctionStreamBasedPowerGridAndCandidateNetwork> const streamReadersPowerGridAndCandidateNetwork;
+
71
+
74 static std::vector<WriterFunctionStreamBased> const streamWriters;
+
75 static std::vector<WriterFunctionStreamBasedtionStringBased> const fileWriters;
+
77
+
80#pragma mark GENERAL_READER
+
81
+
92 static
+
+
93 inline bool read ( PowerGrid<GraphType> & network
+
94 , std::istream & input_stream )
+
95 {
+
96 for ( auto & reader : streamReaders )
+
97 {
+
98 if ( reader ( network, input_stream ) )
+
99 {
+
100 return true;
+
101 } else {
+
102 input_stream.clear();
+
103 input_stream.seekg(0, std::ios::beg);
+
104 }
+
105 }
+
106 return false;
+
107 }
+
+
108
+
118 static
+
+
119 inline bool read ( PowerGrid<GraphType> & network
+
120 , GraphType & candidateNetwork
+
121 , std::string const & filename )
+
122 {
+
123 for ( auto & reader : streamReadersPowerGridAndCandidateNetwork )
+
124 {
+
125 if ( reader ( network, candidateNetwork, filename ) )
+
126 {
+
127 return true;
+
128 }
+
129 }
+
130 return false;
+
131 }
+
+
132
+
144 static
+
+
145 inline bool read ( PowerGrid<GraphType> & network
+
146 , std::string const & filename
+
147 , ReaderFunctionStreamBased reader = PowerGridIO<GraphType>::read )
+
148 {
+
149 std::ifstream input_stream( filename );
+
150 return input_stream.good() && reader ( network, input_stream );
+
151 }
+
+
152
+
164 static
+
+
165 inline bool read ( PowerGrid<GraphType> & network
+
166 , std::string const & filename
+
167 , ReaderFunctionStringBased reader = PowerGridIO<GraphType>::read )
+
168 {
+
169 return reader ( network, filename );
+
170 }
+
+
171
+
184 static
+
+
185 inline bool read ( PowerGrid<GraphType> & network
+
186 , GraphType & candidateNetwork
+
187 , std::string const & filename
+
188 , ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader = PowerGridIO<GraphType>::read )
+
189 {
+
190 return reader ( network, candidateNetwork, filename );
+
191 }
+
+
193
+
196#pragma mark GENERAL_WRITER
+
197
+
209 static
+
+
210 inline bool write ( PowerGrid<GraphType> const & network
+
211 , std::ostream & outputStream
+
212 , WriterFunctionStreamBased writer = PowerGridIO<GraphType>::write )
+
213 {
+
214 return writer ( network, outputStream );
+
215 }
+
+
216
+
228 static
+
+
229 inline bool write ( PowerGrid<GraphType> const & network
+
230 , std::string const & filename
+
231 , WriterFunctionStreamBasedtionStringBased writer = PowerGridIO<GraphType>::write )
+
232 {
+
233 return writer ( network, filename );
+
234 }
+
+
236
+
239#pragma mark IEEE CDF MATLAB DATA
+
251 static
+
+
252 inline bool readIeeeCdfMatlab ( PowerGrid<GraphType> & network
+
253 , std::istream & input_stream )
+
254 {
+
255 if ( !input_stream.good() ) return false;
+
256 IeeeCdfMatlabParser<GraphType> parser(input_stream);
+
257 return parser.read(network);
+
258 }
+
+
259
+
270 static
+
+
271 inline bool writeIeeeCdfMatlab ( PowerGrid<GraphType> const & network
+
272 , std::ostream & output_stream )
+
273 {
+
274 if (!output_stream.good()) return false;
+
275 IeeeCdfMatlabParser<GraphType> parser(output_stream);
+
276 return parser.write(network);
+
277 }
+
+
279
+
282#pragma mark PYPSA DATA
+
293 static
+
+
294 inline bool ReadPyPsa ( PowerGrid<GraphType> & network
+
295 , std::string const & filename )
+
296 {
+
297 PyPsaParser<GraphType> parser(filename);
+
298 return parser.read(network, filename);
+
299 }
+
+
300
+
312 static
+
+
313 inline bool ReadPyPsa ( PowerGrid<GraphType> & network
+
314 , GraphType & candidateNetwork
+
315 , std::string const & filename )
+
316 {
+
317 PyPsaParser<GraphType> parser(filename);
+
318 return parser.read(network, candidateNetwork, filename);
+
319 }
+
+
321
+
327#pragma mark GEOJSON
+
328
+
339 static
+
+
340 inline bool WriteGeoJson ( PowerGrid<GraphType> const & network
+
341 , std::string const & filename )
+
342 {
+
343 IO::GeoJsonWriter<GraphType> writer;//
+
344 return writer.write ( network, filename );
+
345 }
+
+
346
+
357 static
+
+
358 inline bool WriteGeoJson ( PowerGrid<GraphType> const & network
+
359 , std::ostream & outputStream )
+
360 {
+
361 IO::GeoJsonWriter<GraphType> writer;//
+
362 return writer.write ( network, outputStream );
+
363 }
+
+
365
+
370#pragma mark GRAPH_GML
+
371
+
382 static
+
+
383 inline bool ReadGraphGml ( PowerGrid<GraphType> & network
+
384 , std::istream & input_stream )
+
385 {
+
386 throw std::runtime_error("ReadGraphGml is not implemented yet");
+
387 }
+
+
388
+
389#ifndef OGDF_AVAILABLE
+
390
+
401 static
+
+
402 inline bool WriteGraphGml ( PowerGrid<GraphType> const & network
+
403 , std::ostream & output_stream )
+
404 {
+
405 throw std::runtime_error("WriteGraphGml is not implemented yet");
+
406 }
+
+
407
+
418 static
+
+
419 inline bool WriteGraphGml ( PowerGrid<GraphType> const & network
+
420 , std::string const & filename )
+
421 {
+
422 throw std::runtime_error("WriteGraphGml is not implemented yet");
+
423 }
+
+
425
+
426#else // IF OGDF AVAILABLE
+
427
+
437 static
+
438 inline bool WriteGraphGml ( PowerGrid<GraphType> const & network
+
439 , std::string const & filename )
+
440 {
+
441 ogdf::Graph graph;
+
442 ogdf::GraphAttributes ga( graph,
+
443 ogdf::GraphAttributes::nodeGraphics |
+
444 ogdf::GraphAttributes::nodeLabel |
+
445 ogdf::GraphAttributes::nodeWeight |
+
446 ogdf::GraphAttributes::nodeId |
+
447 // ogdf::GraphAttributes::nodeStyle | //does not work yet
+
448 ogdf::GraphAttributes::edgeGraphics |
+
449 ogdf::GraphAttributes::edgeStyle |
+
450 ogdf::GraphAttributes::edgeLabel |
+
451 ogdf::GraphAttributes::edgeIntWeight |
+
452 ogdf::GraphAttributes::edgeDoubleWeight |
+
453 ogdf::GraphAttributes::nodeTemplate
+
454 );
+
455 PowerGrid2OgdfGraph(network, graph, ga );
+
456 return WriteGml ( ga, filename );
+
457 }
+
458
+
467 static
+
468 inline bool WriteGml ( ogdf::GraphAttributes const & ga
+
469 , std::string const & filename )
+
470 {
+
471 return ogdf::GraphIO::write( ga, filename, ogdf::GraphIO::writeGML );
+
472 // return ogdf::GraphIO::write( ga, filename, ogdf::GraphIO::writeGraphML );
+
473 }
+
474
+
481 static
+
482 inline void Shape2VertexType ( ogdf::Shape const & shape
+
483 , Vertex::BasicVertexType & type )
+
484 {
+
485 switch (shape)
+
486 {
+
487 case ogdf::Shape::Ellipse: type = Vertex::BasicVertexType::source; break;
+
488 case ogdf::Shape::Triangle: type = Vertex::BasicVertexType::sink; break;
+
489 case ogdf::Shape::Rect: type = Vertex::BasicVertexType::intermediate; break;
+
490 default: type = Vertex::BasicVertexType::unknown;
+
491 }
+
492 }
+
493
+
500 static
+
501 inline void Shape2VertexType ( ogdf::Shape shape
+
502 , Vertex::CdfBusType & type)
+
503 {
+
504 switch (shape)
+
505 {
+
506 case ogdf::Shape::Ellipse: type = Vertex::CdfBusType::slack; break;
+
507 case ogdf::Shape::Triangle: type = Vertex::CdfBusType::load; break;
+
508 case ogdf::Shape::RoundedRect: type = Vertex::CdfBusType::mvar; break;
+
509 case ogdf::Shape::Octagon: type = Vertex::CdfBusType::voltage; break;
+
510 default: type = Vertex::CdfBusType::unknown;
+
511 }
+
512 }
+
513
+
520 static
+
521 inline void Shape2VertexType ( ogdf::Shape const & shape
+
522 , Vertex::IeeeBusType & type)
+
523 {
+
524 switch (shape)
+
525 {
+
526 case ogdf::Shape::Ellipse: type = Vertex::IeeeBusType::slack; break;
+
527 case ogdf::Shape::Triangle: type = Vertex::IeeeBusType::load; break;
+
528 case ogdf::Shape::RoundedRect: type = Vertex::IeeeBusType::generator; break;
+
529 default: type = Vertex::IeeeBusType::unknown;
+
530 }
+
531 }
+
532
+
539 static
+
540 inline void VertexType2Shape ( Vertex::BasicVertexType type
+
541 , ogdf::Shape & shape )
+
542 {
+
543 switch (type)
+
544 {
+
545 case Vertex::BasicVertexType::source: shape = ogdf::Shape::Ellipse; break;
+
546 case Vertex::BasicVertexType::sink: shape = ogdf::Shape::Triangle; break;
+
547 case Vertex::BasicVertexType::intermediate: shape = ogdf::Shape::Rect; break;
+
548 default: shape = ogdf::Shape::Hexagon;
+
549 }
+
550 }
+
551
+
558 static
+
559 inline void VertexType2Shape ( Vertex::CdfBusType type
+
560 , ogdf::Shape & shape )
+
561 {
+
562 switch (type)
+
563 {
+
564 case Vertex::CdfBusType::slack: shape = ogdf::Shape::Ellipse; break;
+
565 case Vertex::CdfBusType::mvar: shape = ogdf::Shape::RoundedRect; break;
+
566 case Vertex::CdfBusType::voltage: shape = ogdf::Shape::Octagon; break;
+
567 case Vertex::CdfBusType::load: shape = ogdf::Shape::Triangle; break;
+
568 default: shape = ogdf::Shape::Hexagon;
+
569 }
+
570 }
+
571
+
578 static
+
579 inline void VertexType2Shape ( Vertex::IeeeBusType type
+
580 , ogdf::Shape & shape )
+
581 {
+
582 switch (type)
+
583 {
+
584 case Vertex::IeeeBusType::generator: shape = ogdf::Shape::RoundedRect; break;
+
585 case Vertex::IeeeBusType::slack: shape = ogdf::Shape::Ellipse; break;
+
586 case Vertex::IeeeBusType::load: shape = ogdf::Shape::Triangle; break;
+
587 default: shape = ogdf::Shape::Hexagon;
+
588 }
+
589 }
+
590
+
598 static
+
599 inline ogdf::StrokeType Stroke2OgdfStroke ( Stroke::Name const & stroke )
+
600 {
+
601 switch ( stroke )
+
602 {
+
603 case Stroke::Name::solid: return ogdf::StrokeType::Solid;
+
604 case Stroke::Name::dashed: return ogdf::StrokeType::Dash;
+
605 case Stroke::Name::dotted: return ogdf::StrokeType::Dot;
+
606 case Stroke::Name::dasheddotted: return ogdf::StrokeType::Dashdot;
+
607 case Stroke::Name::bold: return ogdf::StrokeType::Solid;
+
608 default: return ogdf::StrokeType::None;
+
609 }
+
610 }
+
611
+
612#endif // not OGDF_AVAILABLE ?
+
613
+
616#pragma mark GRAPH_DOT
+
617 // see https://en.wikipedia.org/wiki/DOT_(graph_description_language)
+
618 // see spec http://www.graphviz.org/doc/info/attrs.html#k:color
+
619
+
630 static
+
+
631 bool WriteGraphDot ( PowerGrid<GraphType> const & network
+
632 , std::ostream & outputStream )
+
633 {
+
634 outputStream << "graph " << network.Graph().Name() << " {\n";
+
635
+
636 outputStream << "rankdir=LR" << "\n";
+
637 outputStream << "size=" << "\"" << "3,3" << "\"" << "\n";
+
638 outputStream << "ratio=" << "\"" << "filled" << "\"" << "\n";
+
639
+
640 // edge style
+
641 outputStream << "edge[";
+
642 outputStream << "size=" << "\"" << "3,3" << "\"" << "";
+
643 outputStream << "]\n";
+
644
+
645 // vertex style
+
646 outputStream << "node[";
+
647 outputStream << "size=" << "\"" << "3,3" << "\"" << "\n";
+
648 outputStream << "]";
+
649
+
650 // edges
+
651 network.Graph().template for_all_edges<ExecutionPolicy::sequential>(
+
652 [&outputStream, network](TElectricalEdge edge){
+
653 outputStream << network.Graph().VertexAt(edge.Source()).Properties().Name()
+
654 << " -- "
+
655 << network.Graph().VertexAt(edge.Target()).Properties().Name();
+
656 Color color;
+
657 Stroke::Name stroke;
+
658 Edges::ElectricalEdge2Color( edge.Properties().Type(), color );
+
659 Edges::ElectricalEdge2Stroke( edge.Properties().Type(), stroke );
+
660 outputStream << "[color=\"" << color.Hexadecimal() << "\", ";
+
661 outputStream << "fontcolor=\"" << color.Hexadecimal() << "\", ";
+
662 outputStream << "style=\"" << Stroke2DotStyle(stroke) << "\", ";
+
663 outputStream << "label=\"" << edge.Properties().ThermalLimit() * network.BaseMva() << "\"];\n";
+
664 }
+
665 );
+
666
+
667 outputStream << "}";
+
668 return true;
+
669 }
+
+
670
+
671 static
+
672 bool WriteGraphDot ( PowerGrid<GraphType> const & network
+
673 , std::string const & filename )
+
674 {
+
675 std::ofstream outputStream(filename);
+
676 outputStream << "graph " << network.Graph().Name() << " {\n";
+
677
+
678 outputStream << "rankdir=LR" << "\n";
+
679 outputStream << "size=" << "\"" << "3,3" << "\"" << "\n";
+
680 outputStream << "ratio=" << "\"" << "filled" << "\"" << "\n";
+
681
+
682 // edge style
+
683 outputStream << "edge[";
+
684 outputStream << "size=" << "\"" << "3,3" << "\"" << "";
+
685 outputStream << "]\n";
+
686
+
687 // vertex style
+
688 outputStream << "node[";
+
689 outputStream << "size=" << "\"" << "3,3" << "\"" << "\n";
+
690 outputStream << "]";
+
691
+
692 // edges
+
693 network.Graph().template for_all_edges<ExecutionPolicy::sequential>(
+
694 [&outputStream, network](TElectricalEdge edge){
+
695 outputStream << network.Graph().VertexAt(edge.Source()).Properties().Name()
+
696 << " -- "
+
697 << network.Graph().VertexAt(edge.Target()).Properties().Name();
+
698 Color color;
+
699 Stroke::Name stroke;
+
700 Edges::ElectricalEdge2Color( edge.Properties().Type(), color );
+
701 Edges::ElectricalEdge2Stroke( edge.Properties().Type(), stroke );
+
702 outputStream << "[color=\"" << color.Hexadecimal() << "\", ";
+
703 outputStream << "fontcolor=\"" << color.Hexadecimal() << "\", ";
+
704 outputStream << "style=\"" << Stroke2DotStyle(stroke) << "\", ";
+
705 outputStream << "label=\"" << edge.Properties().ThermalLimit() * network.BaseMva() << "\"];\n";
+
706 }
+
707 );
+
708
+
709 outputStream << "}";
+
710 return outputStream.good() && true;
+
711 }
+
712
+
720 static
+
+
721 inline std::string Stroke2DotStyle ( Stroke::Name const & stroke )
+
722 {
+
723 switch ( stroke )
+
724 {
+
725 case Stroke::Name::solid: return "solid";
+
726 case Stroke::Name::dashed: return "dashed";
+
727 case Stroke::Name::dotted: return "dotted";
+
728 case Stroke::Name::dasheddotted: return "tapered";
+
729 case Stroke::Name::bold: return "bold";
+
730 default: return "invis";
+
731 }
+
732 }
+
+
734
+
735 private:
+
736 static char indentChar_;
+
737 static int indentWidth_;
+
738};
+
+
739
+
740} // namespace egoa
+
741
+
742#endif // EGOA__IO__POWER_GRID_IO_HPP
+ + +
egoa::IO::GeoJsonWriter::write
bool write(TNetwork const &network, std::string const &filename)
Write GeoJSON using the filename.
Definition GeojsonWriter.hpp:706
+ + +
egoa::PowerGridIO
Class for power grid io.
Definition PowerGridIO.hpp:33
+
egoa::PowerGridIO::write
static bool write(PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)
Function to write a power grid.
Definition PowerGridIO.hpp:210
+
egoa::PowerGridIO::read
static bool read(PowerGrid< GraphType > &network, std::istream &input_stream)
Function to read a power grid.
Definition PowerGridIO.hpp:93
+
egoa::PowerGridIO::read
static bool read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStringBased reader=PowerGridIO< GraphType >::read)
Function to read a power grid.
Definition PowerGridIO.hpp:165
+
egoa::PowerGridIO::ReadGraphGml
static bool ReadGraphGml(PowerGrid< GraphType > &network, std::istream &input_stream)
Reads a graph from a gml file.
Definition PowerGridIO.hpp:383
+
egoa::PowerGridIO::read
static bool read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStreamBased reader=PowerGridIO< GraphType >::read)
Function to read a power grid.
Definition PowerGridIO.hpp:145
+
egoa::PowerGridIO::Stroke2DotStyle
static std::string Stroke2DotStyle(Stroke::Name const &stroke)
Convert a stroke into a dot style stroke.
Definition PowerGridIO.hpp:721
+
egoa::PowerGridIO::readIeeeCdfMatlab
static bool readIeeeCdfMatlab(PowerGrid< GraphType > &network, std::istream &input_stream)
Reads an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:252
+
egoa::PowerGridIO::WriteGraphGml
static bool WriteGraphGml(PowerGrid< GraphType > const &network, std::string const &filename)
Writes a graph into a gml file.
Definition PowerGridIO.hpp:419
+
egoa::PowerGridIO::indentChar_
static char indentChar_
Definition PowerGridIO.hpp:736
+
egoa::PowerGridIO::writeIeeeCdfMatlab
static bool writeIeeeCdfMatlab(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:271
+
egoa::PowerGridIO::WriteGraphDot
static bool WriteGraphDot(PowerGrid< GraphType > const &network, std::ostream &outputStream)
Writes a graph dot.
Definition PowerGridIO.hpp:631
+
egoa::PowerGridIO::read
static bool read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)
Function to read a power grid.
Definition PowerGridIO.hpp:119
+
egoa::PowerGridIO::WriteGeoJson
static bool WriteGeoJson(PowerGrid< GraphType > const &network, std::ostream &outputStream)
Write the network into a GeoJson format.
Definition PowerGridIO.hpp:358
+
egoa::PowerGridIO::indentWidth_
static int indentWidth_
Definition PowerGridIO.hpp:737
+
egoa::PowerGridIO::write
static bool write(PowerGrid< GraphType > const &network, std::string const &filename, WriterFunctionStreamBasedtionStringBased writer=PowerGridIO< GraphType >::write)
Function to write a power grid.
Definition PowerGridIO.hpp:229
+
egoa::PowerGridIO::read
static bool read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename, ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader=PowerGridIO< GraphType >::read)
Function to read a power grid.
Definition PowerGridIO.hpp:185
+
egoa::PowerGridIO::WriteGraphGml
static bool WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes a graph into a gml file.
Definition PowerGridIO.hpp:402
+
egoa::PowerGridIO::ReadPyPsa
static bool ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)
Reads a PyPsa file.
Definition PowerGridIO.hpp:294
+
egoa::PowerGridIO::ReadPyPsa
static bool ReadPyPsa(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)
Reads a PyPsa file.
Definition PowerGridIO.hpp:313
+
egoa::PowerGridIO::WriteGeoJson
static bool WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)
Write the network into a GeoJson format.
Definition PowerGridIO.hpp:340
+ +
egoa::PyPsaParser::read
bool read(TNetwork &network, std::string const &filename)
Read network from file.
Definition PyPsaParser.hpp:640
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_power_grid_iterators_8hpp_source.html b/_power_grid_iterators_8hpp_source.html new file mode 100644 index 00000000..4ab78f48 --- /dev/null +++ b/_power_grid_iterators_8hpp_source.html @@ -0,0 +1,2022 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators/PowerGridIterators.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PowerGridIterators.hpp
+
+
+
1/*
+
2 * PowerGridIterators.hpp
+
3 *
+
4 * Created on: Dec 05, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__POWER_GRID_ITERATORS_HPP
+
9#define EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__POWER_GRID_ITERATORS_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif
+
14
+
15#include "Exceptions/Assertions.hpp"
+
16#include "Auxiliary/ExecutionPolicy.hpp"
+
17
+
18namespace egoa::internal {
+
19
+
20#pragma mark SEQUENTIAL
+
21
+
32template<typename PowerGridType, ExecutionPolicy Policy >
+
33class PowerGridLoopDifferentiation;
+
34
+
35template<typename PowerGridType >
+
+
36class PowerGridLoopDifferentiation<PowerGridType, ExecutionPolicy::sequential> {
+
37
+
38 using TNetwork = PowerGridType;
+
39 using TVertex = typename TNetwork::TVertex;
+
40 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
41 using TLoadProperties = typename TNetwork::TLoadProperties;
+
42 using TLoopDifferentiation = PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::sequential>;
+
43
+
44 public:
+
45
+
48#pragma mark SEQUENTIAL_GENERATOR_LOOPS
+
49
+
70 template<typename FUNCTION>
+
71 inline static
+
+
72 void for_all_generators ( TNetwork & network
+
73 , FUNCTION function )
+
74 {
+
75 for ( TGeneratorProperties & generator : network.generators_ )
+
76 {
+
77 function( generator );
+
78 }
+
79 }
+
+
80
+
101 template<typename FUNCTION>
+
102 inline static
+
+
103 void for_all_generators ( TNetwork const & network
+
104 , FUNCTION function )
+
105 {
+
106 for ( TGeneratorProperties const & generator : network.generators_ )
+
107 {
+
108 function( generator );
+
109 }
+
110 }
+
+
111
+
132 template<typename FUNCTION>
+
133 inline static
+
+
134 void for_all_vertex_identifiers_with_generator ( TNetwork const & network
+
135 , FUNCTION function )
+
136 {
+
137 Types::vertexId vertexIdSafeguard = 0;
+
138 for ( Types::vertexId vertexId = 0
+
139 ; vertexId < network.Graph().Vertices().size()
+
140 ; ++vertexId )
+
141 {
+
142 if ( network.HasGeneratorAt(vertexId)
+
143 && network.Graph().VertexExists(vertexId) ) {
+
144 vertexIdSafeguard = vertexId;
+
145 function( vertexIdSafeguard );
+
146 }
+
147 }
+
148 }
+
+
149
+
172 template<typename FUNCTION>
+
173 inline static
+
+
174 void for_all_generator_identifiers_at ( Types::vertexId vertexId
+
175 , TNetwork const & network
+
176 , FUNCTION function )
+
177 {
+
178 Types::loadId generatorIdSafeguard = 0;
+
179 if ( network.HasGeneratorAt ( vertexId )
+
180 && network.Graph().VertexExists ( vertexId ) )
+
181 {
+
182 for ( Types::generatorId generatorId : network.generatorsAtVertex_[vertexId] )
+
183 {
+
184 generatorIdSafeguard = generatorId;
+
185 function ( generatorIdSafeguard );
+
186 }
+
187 }
+
188 }
+
+
189
+
212 template<typename FUNCTION>
+
213 inline static
+
+
214 void for_all_generator_identifiers_at ( TVertex const & vertex
+
215 , TNetwork const & network
+
216 , FUNCTION function )
+
217 {
+
218 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
219 for_all_generator_identifiers_at ( vertexId, network, function );
+
220 }
+
+
221
+
222
+
244 template<typename FUNCTION>
+
245 inline static
+
+
246 void for_all_generators_at ( TVertex const & vertex
+
247 , TNetwork & network
+
248 , FUNCTION function )
+
249 {
+
250 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
251 for_all_generators_at ( vertexId, network, function );
+
252 }
+
+
253
+
275 template<typename FUNCTION>
+
276 inline static
+
+
277 void for_all_generators_at ( TVertex const & vertex
+
278 , TNetwork const & network
+
279 , FUNCTION function )
+
280 {
+
281 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
282 for_all_generators_at ( vertexId, network, function );
+
283 }
+
+
284
+
306 template<typename FUNCTION>
+
307 inline static
+
+
308 void for_all_generators_at ( Types::vertexId const vertexId
+
309 , TNetwork & network
+
310 , FUNCTION function )
+
311 {
+
312 for_all_generator_identifiers_at ( vertexId, network,
+
313 [ &network, &function ]( Types::generatorId generatorId )
+
314 {
+
315 function ( network.generators_[generatorId] );
+
316 }
+
317 );
+
318 }
+
+
319
+
341 template<typename FUNCTION>
+
342 inline static
+
+
343 void for_all_generators_at ( Types::vertexId const vertexId
+
344 , TNetwork const & network
+
345 , FUNCTION function )
+
346 {
+
347 for_all_generator_identifiers_at ( vertexId, network,
+
348 [ &network, &function ]( Types::generatorId generatorId )
+
349 {
+
350 function ( network.generators_[generatorId] );
+
351 }
+
352 );
+
353 }
+
+
354
+
376 template<typename FUNCTION>
+
377 inline static
+
+
378 void for_all_generator_tuple ( TNetwork & network
+
379 , FUNCTION function )
+
380 {
+
381 Types::vertexId vertexIdSafeguard = 0;
+
382 for ( Types::vertexId vertexId = 0
+
383 ; vertexId < network.Graph().Vertices().size()
+
384 ; ++vertexId )
+
385 {
+
386 if ( network.HasGeneratorAt(vertexId) )
+
387 {
+
388 for ( Types::generatorId generatorId : network.generatorsAtVertex_[vertexId] )
+
389 {
+
390 vertexIdSafeguard = vertexId;
+
391 function( vertexIdSafeguard, network.generators_[generatorId]);
+
392 }
+
393 }
+
394 }
+
395 }
+
+
396
+
418 template<typename FUNCTION>
+
419 inline static
+
+
420 void for_all_generator_tuple ( TNetwork const & network
+
421 , FUNCTION function )
+
422 {
+
423 Types::vertexId vertexIdSafeguard = 0;
+
424 for ( Types::vertexId vertexId = 0
+
425 ; vertexId < network.Graph().Vertices().size()
+
426 ; ++vertexId )
+
427 {
+
428 if ( network.HasGeneratorAt(vertexId) )
+
429 {
+
430 for ( Types::generatorId generatorId : network.generatorsAtVertex_[vertexId] )
+
431 {
+
432 vertexIdSafeguard = vertexId;
+
433 function( vertexIdSafeguard, network.generators_[generatorId]);
+
434 }
+
435 }
+
436 }
+
437 }
+
+
438
+
461 template<typename FUNCTION>
+
462 inline static
+
+
463 void for_all_generators_tuple ( TNetwork & network
+
464 , FUNCTION function )
+
465 {
+
466 Types::vertexId vertexIdSafeguard = 0;
+
467 for ( Types::vertexId vertexId = 0
+
468 ; vertexId < network.Graph().Vertices().size()
+
469 ; ++vertexId )
+
470 {
+
471 if ( network.HasGeneratorAt(vertexId) )
+
472 {
+
473 std::vector<TGeneratorProperties> generators;
+
474 network.GeneratorsAt(vertexId, generators);
+
475 vertexIdSafeguard = vertexId;
+
476 function( vertexIdSafeguard, generators);
+
477 }
+
478 }
+
479 }
+
+
480
+
503 template<typename FUNCTION>
+
504 inline static
+
+
505 void for_all_generators_tuple ( TNetwork const & network
+
506 , FUNCTION function )
+
507 {
+
508 Types::vertexId vertexIdSafeguard = 0;
+
509 for ( Types::vertexId vertexId = 0
+
510 ; vertexId < network.Graph().Vertices().size()
+
511 ; ++vertexId )
+
512 {
+
513 if ( network.HasGeneratorAt ( vertexId ) )
+
514 {
+
515 std::vector<TGeneratorProperties> generators;
+
516 network.GeneratorsAt(vertexId, generators);
+
517 vertexIdSafeguard = vertexId;
+
518 function( vertexIdSafeguard, generators);
+
519 }
+
520 }
+
521 }
+
+
523
+
524#pragma mark SEQUENTIAL_GENERATOR_SNAPSHOT_LOOP
+
548 template<typename FUNCTION>
+
549 inline static
+
+
550 void for_all_real_power_generator_snapshots ( TNetwork & network
+
551 , FUNCTION function )
+
552 {
+
553 for ( Types::index generatorId = 0
+
554 ; generatorId < network.generatorRealPowerSnapshots_.size()
+
555 ; ++generatorId )
+
556 {
+
557 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
558 }
+
559 }
+
+
560
+
561 template<typename FUNCTION>
+
562 inline static
+
563 void for_all_real_power_generator_snapshots ( TNetwork const & network
+
564 , FUNCTION function )
+
565 {
+
566 for ( Types::index generatorId = 0
+
567 ; generatorId < network.generatorRealPowerSnapshots_.size()
+
568 ; ++generatorId )
+
569 {
+
570 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
571 }
+
572 }
+
574
+
606 template<typename FUNCTION>
+
607 inline static
+
+
608 void for_all_real_power_generator_snapshots_of ( TNetwork & network
+
609 , Types::generatorId generatorId
+
610 , FUNCTION function )
+
611 {
+
612 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
613
+
614 for ( Types::index snapshotId = 0
+
615 ; snapshotId < network.generatorRealPowerSnapshots_[generatorId].size()
+
616 ; ++snapshotId )
+
617 {
+
618 function( snapshotId, network.generatorRealPowerSnapshots_[generatorId][snapshotId] );
+
619 }
+
620 }
+
+
621
+
622 template<typename FUNCTION>
+
623 inline static
+
624 void for_all_real_power_generator_snapshots_of ( TNetwork const & network
+
625 , Types::generatorId generatorId
+
626 , FUNCTION function )
+
627 {
+
628 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
629
+
630 for ( Types::index snapshotId = 0
+
631 ; snapshotId < network.generatorRealPowerSnapshots_[generatorId].size()
+
632 ; ++snapshotId )
+
633 {
+
634 function( snapshotId, network.generatorRealPowerSnapshots_[generatorId][snapshotId] );
+
635 }
+
636 }
+
638
+
669 template<typename FUNCTION>
+
670 inline static
+
+
671 void for_all_real_power_generator_snapshots_of ( TNetwork & network
+
672 , TGeneratorProperties generatorProperties
+
673 , FUNCTION function )
+
674 {
+
675 Types::generatorId generatorId = network.GeneratorId( generatorProperties );
+
676
+
677 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
678
+
679 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
680 }
+
+
681
+
682 template<typename FUNCTION>
+
683 inline static
+
684 void for_all_real_power_generator_snapshots_of ( TNetwork const & network
+
685 , TGeneratorProperties generatorProperties
+
686 , FUNCTION function )
+
687 {
+
688 Types::generatorId generatorId = network.GeneratorId( generatorProperties );
+
689
+
690 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
691
+
692 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
693 }
+
695
+
727 template<typename FUNCTION>
+
728 inline static
+
+
729 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
730 , Types::vertexId vertexId
+
731 , FUNCTION function )
+
732 {
+
733 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
734
+
735 std::vector<Types::generatorId> generatorIds;
+
736 network.GeneratorsAt( vertexId, generatorIds );
+
737
+
738 for ( Types::generatorId generatorId : generatorIds )
+
739 {
+
740 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
741 }
+
742 }
+
+
743
+
744 template<typename FUNCTION>
+
745 inline static
+
746 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
747 , Types::vertexId vertexId
+
748 , FUNCTION function )
+
749 {
+
750 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
751
+
752 std::vector<Types::generatorId> generatorIds;
+
753 network.GeneratorsAt( vertexId, generatorIds );
+
754
+
755
+
756 for ( Types::generatorId generatorId : generatorIds )
+
757 {
+
758 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
759 }
+
760 }
+
762
+
794 template<typename FUNCTION>
+
795 inline static
+
+
796 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
797 , TVertex const & vertex
+
798 , FUNCTION function )
+
799 {
+
800 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
801
+
802 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
803
+
804 std::vector<Types::generatorId> generatorIds;
+
805 network.GeneratorAt( vertexId, generatorIds );
+
806
+
807 for_all_real_power_generator_snapshots_at ( network, vertexId, function );
+
808 }
+
+
809
+
810 template<typename FUNCTION>
+
811 inline static
+
812 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
813 , TVertex const & vertex
+
814 , FUNCTION function )
+
815 {
+
816 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
817
+
818 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
819
+
820 std::vector<Types::generatorId> generatorIds;
+
821 network.GeneratorAt( vertexId, generatorIds );
+
822
+
823 for_all_real_power_generator_snapshots_at ( network, vertexId, function );
+
824 }
+
826
+
862 template<typename FUNCTION>
+
863 inline static
+
+
864 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
865 , Types::vertexId vertexId
+
866 , Types::index timestampPosition
+
867 , FUNCTION function )
+
868 {
+
869 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
870
+
871 std::vector<Types::generatorId> generatorIds;
+
872 network.GeneratorIds ( vertexId, generatorIds );
+
873
+
874 for ( Types::generatorId generatorId : generatorIds )
+
875 {
+
876 function ( network.GeneratorSnapshotOf( generatorId, timestampPosition ) );
+
877 }
+
878 }
+
+
879
+
880 template<typename FUNCTION>
+
881 inline static
+
882 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
883 , Types::vertexId vertexId
+
884 , Types::index timestampPosition
+
885 , FUNCTION function )
+
886 {
+
887 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
888
+
889 std::vector<Types::generatorId> generatorIds;
+
890 network.GeneratorIds ( vertexId, generatorIds );
+
891
+
892 for ( Types::generatorId generatorId : generatorIds )
+
893 {
+
894 function ( network.GeneratorSnapshotOf( generatorId, timestampPosition ) );
+
895 }
+
896 }
+
898
+
932 template<typename FUNCTION>
+
933 inline static
+
+
934 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
935 , TVertex const & vertex
+
936 , Types::index timestampPosition
+
937 , FUNCTION function )
+
938 {
+
939 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
940
+
941 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
942
+
943 for_all_real_power_generator_snapshots_at ( network, vertexId, timestampPosition, function );
+
944 }
+
+
945
+
946 template<typename FUNCTION>
+
947 inline static
+
948 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
949 , TVertex const & vertex
+
950 , Types::index timestampPosition
+
951 , FUNCTION function )
+
952 {
+
953 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
954
+
955 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
956
+
957 for_all_real_power_generator_snapshots_at ( network, vertexId, timestampPosition, function );
+
958 }
+
960
+
961
+
964#pragma mark SEQUENTIAL_LOAD_LOOPS
+
965
+
986 template<typename FUNCTION>
+
987 inline static
+
+
988 void for_all_loads ( TNetwork & network
+
989 , FUNCTION function )
+
990 {
+
991 for ( TLoadProperties & load : network.loads_ )
+
992 {
+
993 function ( load );
+
994 }
+
995 }
+
+
996
+
1017 template<typename FUNCTION>
+
1018 inline static
+
+
1019 void for_all_loads ( TNetwork const & network
+
1020 , FUNCTION function )
+
1021 {
+
1022 for ( TLoadProperties const & load : network.loads_ )
+
1023 {
+
1024 function ( load );
+
1025 }
+
1026 }
+
+
1027
+
1049 template<typename FUNCTION>
+
1050 inline static
+
+
1051 void for_all_vertex_identifiers_with_load ( TNetwork const & network
+
1052 , FUNCTION function )
+
1053 {
+
1054 Types::vertexId vertexIdSafeguard = 0;
+
1055 for ( Types::vertexId vertexId = 0
+
1056 ; vertexId < network.Graph().Vertices().size()
+
1057 ; ++vertexId )
+
1058 {
+
1059 if ( network.HasLoadAt(vertexId)
+
1060 && network.Graph().VertexExists(vertexId) )
+
1061 {
+
1062 vertexIdSafeguard = vertexId;
+
1063 function ( vertexIdSafeguard );
+
1064 }
+
1065 }
+
1066 }
+
+
1067
+
1090 template<typename FUNCTION>
+
1091 inline static
+
+
1092 void for_all_load_identifiers_at ( Types::vertexId vertexId
+
1093 , TNetwork const & network
+
1094 , FUNCTION function )
+
1095 {
+
1096 Types::loadId loadIdSafeguard = 0;
+
1097 if ( network.HasLoadAt ( vertexId )
+
1098 && network.Graph().VertexExists ( vertexId ) ) {
+
1099 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1100 {
+
1101 loadIdSafeguard = loadId;
+
1102 function ( loadIdSafeguard );
+
1103 }
+
1104 }
+
1105 }
+
+
1106
+
1128 template<typename FUNCTION>
+
1129 inline static
+
+
1130 void for_all_load_identifiers_at ( TVertex const & vertex
+
1131 , TNetwork const & network
+
1132 , FUNCTION function )
+
1133 {
+
1134 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1135 for_all_load_identifiers_at ( vertexId, network, function );
+
1136 }
+
+
1137
+
1159 template<typename FUNCTION>
+
1160 inline static
+
+
1161 void for_all_loads_at ( TVertex const & vertex
+
1162 , TNetwork & network
+
1163 , FUNCTION function )
+
1164 {
+
1165 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1166 for_all_loads_at ( vertexId, network, function );
+
1167 }
+
+
1168
+
1190 template<typename FUNCTION>
+
1191 inline static
+
+
1192 void for_all_loads_at ( TVertex const & vertex
+
1193 , TNetwork const & network
+
1194 , FUNCTION function )
+
1195 {
+
1196 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1197 for_all_loads_at ( vertexId, network, function );
+
1198 }
+
+
1199
+
1221 template<typename FUNCTION>
+
1222 inline static
+
+
1223 void for_all_loads_at ( Types::vertexId const vertexId
+
1224 , TNetwork & network
+
1225 , FUNCTION function )
+
1226 {
+
1227 for_all_load_identifiers_at ( vertexId, network,
+
1228 [ &network, &function ]( Types::loadId loadId )
+
1229 {
+
1230 function ( network.loads_[loadId] );
+
1231 }
+
1232 );
+
1233 }
+
+
1234
+
1256 template<typename FUNCTION>
+
1257 inline static
+
+
1258 void for_all_loads_at ( Types::vertexId const vertexId
+
1259 , TNetwork const & network
+
1260 , FUNCTION function )
+
1261 {
+
1262 for_all_load_identifiers_at ( vertexId, network,
+
1263 [ &network, &function ]( Types::loadId loadId )
+
1264 {
+
1265 function ( network.loads_[loadId] );
+
1266 }
+
1267 );
+
1268 }
+
+
1269
+
1291 template<typename FUNCTION>
+
1292 inline static
+
+
1293 void for_all_load_tuples ( TNetwork & network
+
1294 , FUNCTION function )
+
1295 {
+
1296 Types::vertexId vertexIdSafeguard = 0;
+
1297 for ( Types::vertexId vertexId = 0
+
1298 ; vertexId < network.Graph().Vertices().size()
+
1299 ; ++vertexId )
+
1300 {
+
1301 if ( network.HasLoadAt(vertexId) )
+
1302 {
+
1303 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1304 {
+
1305 vertexIdSafeguard = vertexId;
+
1306 function( vertexIdSafeguard, network.loads_[loadId] );
+
1307 }
+
1308 }
+
1309 }
+
1310 }
+
+
1311
+
1333 template<typename FUNCTION>
+
1334 inline static
+
+
1335 void for_all_load_tuples ( TNetwork const & network
+
1336 , FUNCTION function )
+
1337 {
+
1338 Types::vertexId vertexIdSafeguard = 0;
+
1339 for ( Types::vertexId vertexId = 0
+
1340 ; vertexId < network.Graph().Vertices().size()
+
1341 ; ++vertexId )
+
1342 {
+
1343 if ( network.HasLoadAt(vertexId) )
+
1344 {
+
1345 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1346 {
+
1347 vertexIdSafeguard = vertexId;
+
1348 function( vertexIdSafeguard, network.loads_[loadId] );
+
1349 }
+
1350 }
+
1351 }
+
1352 }
+
+
1353
+
1376 template<typename FUNCTION>
+
1377 inline static
+
+
1378 void for_all_loads_tuple ( TNetwork const & network
+
1379 , FUNCTION function )
+
1380 {
+
1381 Types::vertexId vertexIdSafeguard = 0;
+
1382 for ( Types::vertexId vertexId = 0
+
1383 ; vertexId < network.Graph().Vertices().size()
+
1384 ; ++vertexId )
+
1385 {
+
1386 if ( network.HasLoadAt(vertexId) )
+
1387 {
+
1388 std::vector<TLoadProperties> loads;
+
1389 network.LoadsAt ( vertexId, loads );
+
1390 vertexIdSafeguard = vertexId;
+
1391 function( vertexIdSafeguard, loads );
+
1392 }
+
1393 }
+
1394 }
+
+
1396
+
1397
+
1398#pragma mark SEQUENTIAL_LOAD_SNAPSHOT_LOOPS
+
1399
+
1422 template<typename FUNCTION>
+
1423 inline static
+
+
1424 void for_all_real_power_load_snapshots ( TNetwork & network
+
1425 , FUNCTION function )
+
1426 {
+
1427 for ( Types::loadId loadId = 0
+
1428 ; loadId < network.loadSnapshots_.size()
+
1429 ; ++loadId )
+
1430 {
+
1431 for_all_real_power_load_snapshots_of ( network
+
1432 , loadId
+
1433 , function );
+
1434 }
+
1435 }
+
+
1436
+
1437 template<typename FUNCTION>
+
1438 inline static
+
1439 void for_all_real_power_load_snapshots ( TNetwork const & network
+
1440 , FUNCTION function )
+
1441 {
+
1442 for ( Types::loadId loadId = 0
+
1443 ; loadId < network.loadSnapshots_.size()
+
1444 ; ++loadId )
+
1445 {
+
1446 for_all_real_power_load_snapshots_of ( network
+
1447 , loadId
+
1448 , function );
+
1449 }
+
1450 }
+
1452
+
1483 template<typename FUNCTION>
+
1484 inline static
+
+
1485 void for_all_real_power_load_snapshots_of ( TNetwork & network
+
1486 , Types::loadId loadId
+
1487 , FUNCTION function )
+
1488 {
+
1489 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
1490
+
1491 for ( Types::index timestampPosition = 0
+
1492 ; timestampPosition < network.loadSnapshots_.size()
+
1493 ; ++timestampPosition )
+
1494 {
+
1495 function ( timestampPosition
+
1496 , network.LoadSnapshotOf( loadId, timestampPosition ) );
+
1497 }
+
1498 }
+
+
1499
+
1500 template<typename FUNCTION>
+
1501 inline static
+
1502 void for_all_real_power_load_snapshots_of ( TNetwork const & network
+
1503 , Types::loadId loadId
+
1504 , FUNCTION function )
+
1505 {
+
1506 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
1507
+
1508 for ( Types::index timestampPosition = 0
+
1509 ; timestampPosition < network.loadSnapshots_.size()
+
1510 ; ++timestampPosition )
+
1511 {
+
1512 function ( timestampPosition
+
1513 , network.LoadSnapshotOf( loadId, timestampPosition ) );
+
1514 }
+
1515 }
+
1517
+
1518
+
1548 template<typename FUNCTION>
+
1549 inline static
+
+
1550 void for_all_real_power_load_snapshots_of ( TNetwork & network
+
1551 , TLoadProperties const & loadProperties
+
1552 , FUNCTION function )
+
1553 {
+
1554 Types::loadId loadId = network.LoadId ( loadProperties );
+
1555
+
1556 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
1557
+
1558 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
1559 }
+
+
1560
+
1561 template<typename FUNCTION>
+
1562 inline static
+
1563 void for_all_real_power_load_snapshots_of ( TNetwork const & network
+
1564 , TLoadProperties const & loadProperties
+
1565 , FUNCTION function )
+
1566 {
+
1567 Types::loadId loadId = network.LoadId ( loadProperties );
+
1568
+
1569 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
1570
+
1571 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
1572 }
+
1574
+
1605 template<typename FUNCTION>
+
1606 inline static
+
+
1607 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
1608 , Types::vertexId vertexId
+
1609 , FUNCTION function )
+
1610 {
+
1611 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
1612
+
1613 std::vector<Types::loadId> loadIds;
+
1614 network.LoadIds ( vertexId, loadIds );
+
1615
+
1616 for ( Types::loadId loadId : loadIds )
+
1617 {
+
1618 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
1619 }
+
1620 }
+
+
1621
+
1622 template<typename FUNCTION>
+
1623 inline static
+
1624 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
1625 , Types::vertexId vertexId
+
1626 , FUNCTION function )
+
1627 {
+
1628 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
1629
+
1630 std::vector<Types::loadId> loadIds;
+
1631 network.LoadIds ( vertexId, loadIds );
+
1632
+
1633 for ( Types::loadId loadId : loadIds )
+
1634 {
+
1635 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
1636 }
+
1637 }
+
1639
+
1669 template<typename FUNCTION>
+
1670 inline static
+
+
1671 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
1672 , TVertex const & vertex
+
1673 , FUNCTION function )
+
1674 {
+
1675 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1676
+
1677 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
1678
+
1679 for_all_real_power_load_snapshots_at ( network, vertexId, function );
+
1680 }
+
+
1681
+
1682 template<typename FUNCTION>
+
1683 inline static
+
1684 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
1685 , TVertex const & vertex
+
1686 , FUNCTION function )
+
1687 {
+
1688 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1689
+
1690 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
1691
+
1692 for_all_real_power_load_snapshots_at ( network, vertexId, function );
+
1693 }
+
1695
+
1730 template<typename FUNCTION>
+
1731 inline static
+
+
1732 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
1733 , Types::vertexId vertexId
+
1734 , Types::index timestampPosition
+
1735 , FUNCTION function )
+
1736 {
+
1737 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
1738
+
1739 std::vector<Types::loadId> loadIds;
+
1740 network.LoadIds ( vertexId, loadIds );
+
1741
+
1742 for ( Types::loadId loadId : loadIds )
+
1743 {
+
1744 function ( network.LoadSnapshotOf( loadId, timestampPosition ) );
+
1745 }
+
1746 }
+
+
1747
+
1748 template<typename FUNCTION>
+
1749 inline static
+
1750 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
1751 , Types::vertexId vertexId
+
1752 , Types::index timestampPosition
+
1753 , FUNCTION function )
+
1754 {
+
1755 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
1756
+
1757 std::vector<Types::loadId> loadIds;
+
1758 network.LoadIds ( vertexId, loadIds );
+
1759
+
1760 for ( Types::loadId loadId : loadIds )
+
1761 {
+
1762 function ( network.LoadSnapshotOf( loadId, timestampPosition ) );
+
1763 }
+
1764 }
+
1766
+
1798 template<typename FUNCTION>
+
1799 inline static
+
+
1800 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
1801 , TVertex const & vertex
+
1802 , Types::index timestampPosition
+
1803 , FUNCTION function )
+
1804 {
+
1805 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1806
+
1807 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
1808
+
1809 for_all_real_power_load_snapshots_at ( network, vertexId, timestampPosition, function );
+
1810 }
+
+
1811
+
1812 template<typename FUNCTION>
+
1813 inline static
+
1814 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
1815 , TVertex const & vertex
+
1816 , Types::index timestampPosition
+
1817 , FUNCTION function )
+
1818 {
+
1819 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
1820
+
1821 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
1822
+
1823 for_all_real_power_load_snapshots_at ( network, vertexId, timestampPosition, function );
+
1824 }
+
1826};
+
+
1827
+
1828#pragma mark BREAKABLE
+
1829
+
1836template<typename PowerGridType >
+
+
1837class PowerGridLoopDifferentiation<PowerGridType, ExecutionPolicy::breakable> {
+
1838 // Template type aliasing
+
1839 using TNetwork = PowerGridType;
+
1840 using TVertex = typename TNetwork::TVertex;
+
1841 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
1842 using TLoadProperties = typename TNetwork::TLoadProperties;
+
1843 using TLoopDifferentiation = PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::sequential>;
+
1844
+
1845 public:
+
1848#pragma mark BREAKABLE_GENERATOR_LOOPS
+
1849 //@todo Implement
+
1851
+
1852#pragma mark BREAKABLE_GENERATOR_SNAPSHOT_LOOP
+
1853 //@todo Implement
+
1854#pragma mark BREAKABLE_LOAD_LOOPS
+
1855
+
1856 template<typename FUNCTION>
+
1857 inline static
+
1858 void for_all_load_identifiers_at ( Types::vertexId vertexId
+
1859 , TNetwork const & network
+
1860 , FUNCTION function )
+
1861 {
+
1862 if ( !network.HasLoadAt( vertexId ) ) return;
+
1863
+
1864 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1865 {
+
1866 bool toContinue = function ( loadId );
+
1867 if (!toContinue) return;
+
1868 }
+
1869 }
+
1870
+
1871 template<typename FUNCTION>
+
1872 inline static
+
1873 void for_all_load_identifiers_at ( TVertex const & vertex
+
1874 , TNetwork const & network
+
1875 , FUNCTION function )
+
1876 {
+
1877 Types::vertexId vertexId = vertex.Identifier();
+
1878 for_all_load_identifiers_at ( vertexId, network, function );
+
1879 }
+
1880
+
1881
+
1882 template<typename FUNCTION>
+
1883 inline static
+
1884 void for_all_loads_at( Types::vertexId vertexId,
+
1885 TNetwork & network,
+
1886 FUNCTION function )
+
1887 {
+
1888 USAGE_ASSERT( network.Graph().VertexExists(vertexId) );
+
1889
+
1890 if ( !network.HasLoadAt(vertexId) ) return;
+
1891
+
1892 for (Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1893 {
+
1894 bool toContinue = function(network.loads_[loadId]);
+
1895 if (!toContinue) return;
+
1896 }
+
1897
+
1898 }
+
1899
+
1900 template<typename FUNCTION>
+
1901 inline static
+
1902 void for_all_loads_at( Types::vertexId vertexId,
+
1903 TNetwork const & network,
+
1904 FUNCTION function )
+
1905 {
+
1906 USAGE_ASSERT( network.Graph().VertexExists(vertexId) );
+
1907
+
1908 if ( !network.HasLoadAt(vertexId) ) return;
+
1909
+
1910 for (Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
1911 {
+
1912 bool toContinue = function(network.loads_[loadId]);
+
1913 if (!toContinue) return;
+
1914 }
+
1915
+
1916 }
+
1917 //@todo Implement
+
1918#pragma mark BREAKABLE_LOAD_SNAPSHOT_LOOPS
+
1919 //@todo Implement
+
1920};
+
+
1921
+
1922#pragma mark PARALLEL
+
1923
+
1924#ifdef OPENMP_AVAILABLE
+
1925
+
1931template<typename PowerGridType >
+
1932class PowerGridLoopDifferentiation<PowerGridType, ExecutionPolicy::parallel> {
+
1933
+
1934 // Template type aliasing
+
1935 using TNetwork = PowerGridType;
+
1936 using TVertex = typename TNetwork::TVertex;
+
1937 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
1938 using TLoadProperties = typename TNetwork::TLoadProperties;
+
1939 using TLoopDifferentiation = PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::parallel>;
+
1940
+
1941 public:
+
1944#pragma mark PARALLEL_GENERATOR_LOOPS
+
1945
+
1966 template<typename FUNCTION>
+
1967 inline static
+
1968 void for_all_generators ( TNetwork & network
+
1969 , FUNCTION function )
+
1970 {
+
1971 #pragma omp parallel for
+
1972 for ( Types::index generatorId = 0
+
1973 ; generatorId < network.generators_.size()
+
1974 ; ++generatorId )
+
1975 {
+
1976 function( network.generators_[generatorId] );
+
1977 }
+
1978 }
+
1979
+
2000 template<typename FUNCTION>
+
2001 inline static
+
2002 void for_all_generators ( TNetwork const & network
+
2003 , FUNCTION function )
+
2004 {
+
2005 #pragma omp parallel for
+
2006 for ( Types::index generatorId = 0
+
2007 ; generatorId < network.generators_.size()
+
2008 ; ++generatorId )
+
2009 {
+
2010 function( network.generators_[generatorId] );
+
2011 }
+
2012 }
+
2013
+
2033 template<typename FUNCTION>
+
2034 inline static
+
2035 void for_all_vertex_identifiers_with_generator ( TNetwork const & network
+
2036 , FUNCTION function )
+
2037 {
+
2038 #pragma omp parallel for
+
2039 for ( Types::vertexId index = 0
+
2040 ; index < network.Graph().Vertices().size()
+
2041 ; ++index )
+
2042 {
+
2043 if ( network.HasGeneratorAt(index)
+
2044 && network.Graph().VertexExists(index) )
+
2045 {
+
2046 function( index );
+
2047 }
+
2048 }
+
2049 }
+
2050
+
2073 template<typename FUNCTION>
+
2074 inline static
+
2075 void for_all_generator_identifiers_at ( Types::vertexId vertexId
+
2076 , TNetwork const & network
+
2077 , FUNCTION function )
+
2078 {
+
2079 if ( network.HasGeneratorAt ( vertexId )
+
2080 && network.Graph().VertexExists ( vertexId ) ) {
+
2081 #pragma omp parallel for
+
2082 for ( Types::count counter = 0
+
2083 ; counter < network.generatorsAtVertex_[vertexId].size()
+
2084 ; ++counter )
+
2085 {
+
2086 function( network.generatorsAtVertex_[vertexId][counter] );
+
2087 }
+
2088 }
+
2089 }
+
2090
+
2113 template<typename FUNCTION>
+
2114 inline static
+
2115 void for_all_generator_identifiers_at ( TVertex const & vertex
+
2116 , TNetwork const & network
+
2117 , FUNCTION function )
+
2118 {
+
2119 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2120 for_all_generator_identifiers_at ( vertexId, network, function );
+
2121 }
+
2122
+
2144 template<typename FUNCTION>
+
2145 inline static
+
2146 void for_all_generators_at ( Types::vertexId const vertexId
+
2147 , TNetwork & network
+
2148 , FUNCTION function )
+
2149 {
+
2150 for_all_generator_identifiers_at ( vertexId,
+
2151 [ &network, &function ]( Types::generatorId generatorId )
+
2152 {
+
2153 function ( network.generators_[generatorId] );
+
2154 }
+
2155 );
+
2156 }
+
2157
+
2179 template<typename FUNCTION>
+
2180 inline static
+
2181 void for_all_generators_at ( Types::vertexId const vertexId
+
2182 , TNetwork const & network
+
2183 , FUNCTION function )
+
2184 {
+
2185 for_all_generator_identifiers_at ( vertexId,
+
2186 [ &network, &function ]( Types::generatorId generatorId )
+
2187 {
+
2188 function ( network.generators_[generatorId] );
+
2189 }
+
2190 );
+
2191 }
+
2192
+
2214 template<typename FUNCTION>
+
2215 inline static
+
2216 void for_all_generators_at ( TVertex const & vertex
+
2217 , TNetwork & network
+
2218 , FUNCTION function )
+
2219 {
+
2220 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2221 for_all_generators_at ( vertexId, network, function );
+
2222 }
+
2223
+
2244 template<typename FUNCTION>
+
2245 inline static
+
2246 void for_all_generators_at ( TVertex const & vertex
+
2247 , TNetwork const & network
+
2248 , FUNCTION function )
+
2249 {
+
2250 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2251 for_all_generators_at ( vertexId, network, function );
+
2252 }
+
2253
+
2276 template<typename FUNCTION>
+
2277 inline static
+
2278 void for_all_generator_tuple ( TNetwork & network
+
2279 , FUNCTION function )
+
2280 {
+
2281 #pragma omp parallel for
+
2282 for ( Types::vertexId index = 0
+
2283 ; index < network.Graph().Vertices().size()
+
2284 ; ++index )
+
2285 {
+
2286 if ( network.HasGeneratorAt(index) )
+
2287 {
+
2288 std::vector<TGeneratorProperties> generators;
+
2289 network.GeneratorsAt(index, generators);
+
2290 for ( TGeneratorProperties & generator : generators )
+
2291 {
+
2292 function( index, generator);
+
2293 }
+
2294 }
+
2295 }
+
2296 }
+
2297
+
2319 template<typename FUNCTION>
+
2320 inline static
+
2321 void for_all_generator_tuple ( TNetwork const & network
+
2322 , FUNCTION function )
+
2323 {
+
2324 #pragma omp parallel for
+
2325 for ( Types::vertexId index = 0
+
2326 ; index < network.Graph().Vertices().size()
+
2327 ; ++index )
+
2328 {
+
2329 if ( network.HasGeneratorAt(index) )
+
2330 {
+
2331 std::vector<TGeneratorProperties> generators;
+
2332 network.GeneratorsAt(index, generators);
+
2333 for ( TGeneratorProperties & generator : generators ) {
+
2334 function( index, generator);
+
2335 }
+
2336 }
+
2337 }
+
2338 }
+
2339
+
2363 template<typename FUNCTION>
+
2364 inline static
+
2365 void for_all_generators_tuple ( TNetwork const & network
+
2366 , FUNCTION function )
+
2367 {
+
2368 #pragma omp parallel for
+
2369 for ( Types::vertexId index = 0
+
2370 ; index < network.Graph().Vertices().size()
+
2371 ; ++index )
+
2372 {
+
2373 if ( network.HasGeneratorAt(index) )
+
2374 {
+
2375 std::vector<TGeneratorProperties> generators;
+
2376 network.GeneratorsAt(index, generators);
+
2377 function( index, generators);
+
2378 }
+
2379 }
+
2380 }
+
2382
+
2383#pragma mark PARALLEL_GENERATOR_SNAPSHOT_LOOP
+
2407 template<typename FUNCTION>
+
2408 inline
+
2409 void for_all_real_power_generator_snapshots ( TNetwork & network
+
2410 , FUNCTION function )
+
2411 {
+
2412 #pragma omp parallel for
+
2413 for ( Types::index generatorId = 0
+
2414 ; generatorId < network.generatorRealPowerSnapshots_.size()
+
2415 ; ++generatorId )
+
2416 {
+
2417 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
2418 }
+
2419 }
+
2420
+
2421 template<typename FUNCTION>
+
2422 inline
+
2423 void for_all_real_power_generator_snapshots ( TNetwork const & network
+
2424 , FUNCTION function ) const
+
2425 {
+
2426 #pragma omp parallel for
+
2427 for ( Types::index generatorId = 0
+
2428 ; generatorId < network.generatorRealPowerSnapshots_.size()
+
2429 ; ++generatorId )
+
2430 {
+
2431 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
2432 }
+
2433 }
+
2435
+
2467 template<typename FUNCTION>
+
2468 inline static
+
2469 void for_all_real_power_generator_snapshots_of ( TNetwork & network
+
2470 , Types::generatorId generatorId
+
2471 , FUNCTION function )
+
2472 {
+
2473 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
2474
+
2475 #pragma omp parallel for
+
2476 for ( Types::index snapshotId = 0
+
2477 ; snapshotId < network.generatorRealPowerSnapshots_[generatorId].size()
+
2478 ; ++snapshotId )
+
2479 { // snapshotId corresponds to row
+
2480 function( snapshotId, network.generatorRealPowerSnapshots_[generatorId][snapshotId] );
+
2481 }
+
2482 }
+
2483
+
2484 template<typename FUNCTION>
+
2485 inline static
+
2486 void for_all_real_power_generator_snapshots_of ( TNetwork const & network
+
2487 , Types::generatorId generatorId
+
2488 , FUNCTION function )
+
2489 {
+
2490 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
2491
+
2492 #pragma omp parallel for
+
2493 for ( Types::index snapshotId = 0
+
2494 ; snapshotId < network.generatorRealPowerSnapshots_[generatorId].size()
+
2495 ; ++snapshotId )
+
2496 { // snapshotId corresponds to row
+
2497 function( snapshotId, network.generatorRealPowerSnapshots_[generatorId][snapshotId] );
+
2498 }
+
2499 }
+
2501
+
2532 template<typename FUNCTION>
+
2533 inline static
+
2534 void for_all_real_power_generator_snapshots_of ( TNetwork & network
+
2535 , TGeneratorProperties const & generatorProperties
+
2536 , FUNCTION function )
+
2537 {
+
2538 Types::generatorId generatorId = network.GeneratorId( generatorProperties );
+
2539
+
2540 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
2541
+
2542 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
2543 }
+
2544
+
2545 template<typename FUNCTION>
+
2546 inline static
+
2547 void for_all_real_power_generator_snapshots_of ( TNetwork const & network
+
2548 , TGeneratorProperties const & generatorProperties
+
2549 , FUNCTION function )
+
2550 {
+
2551 Types::generatorId generatorId = network.GeneratorId( generatorProperties );
+
2552
+
2553 USAGE_ASSERT ( network.HasGenerator ( generatorId ) );
+
2554
+
2555 for_all_real_power_generator_snapshots_of ( network, generatorId, function );
+
2556 }
+
2558
+
2590 template<typename FUNCTION>
+
2591 inline static
+
2592 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
2593 , Types::vertexId vertexId
+
2594 , FUNCTION function )
+
2595 {
+
2596 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
2597
+
2598 std::vector<Types::generatorId> generatorIds;
+
2599 network.GeneratorAt( vertexId, generatorIds );
+
2600
+
2601 #pragma omp parallel for
+
2602 for ( Types::index index = 0
+
2603 ; index < generatorIds.size()
+
2604 ; ++index )
+
2605 {
+
2606 for_all_real_power_generator_snapshots_of ( network, generatorIds[index], function );
+
2607 }
+
2608 }
+
2609
+
2610 template<typename FUNCTION>
+
2611 inline static
+
2612 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
2613 , Types::vertexId vertexId
+
2614 , FUNCTION function )
+
2615 {
+
2616 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
2617
+
2618 std::vector<Types::generatorId> generatorIds;
+
2619 network.GeneratorAt( vertexId, generatorIds );
+
2620
+
2621 #pragma omp parallel for
+
2622 for ( Types::index index = 0
+
2623 ; index < generatorIds.size()
+
2624 ; ++index )
+
2625 {
+
2626 for_all_real_power_generator_snapshots_of ( network, generatorIds[index], function );
+
2627 }
+
2628 }
+
2630
+
2662 template<typename FUNCTION>
+
2663 inline static
+
2664 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
2665 , TVertex vertex
+
2666 , FUNCTION function )
+
2667 {
+
2668 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2669
+
2670 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
2671
+
2672 std::vector<Types::generatorId> generatorIds;
+
2673 network.GeneratorAt( vertexId, generatorIds );
+
2674
+
2675 for_all_real_power_generator_snapshots_at ( network, vertexId, function );
+
2676 }
+
2677
+
2678 template<typename FUNCTION>
+
2679 inline static
+
2680 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
2681 , TVertex vertex
+
2682 , FUNCTION function )
+
2683 {
+
2684 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2685
+
2686 USAGE_ASSERT ( network.Graph().VertexExists( vertexId ) );
+
2687
+
2688 std::vector<Types::generatorId> generatorIds;
+
2689 network.GeneratorAt( vertexId, generatorIds );
+
2690
+
2691 for_all_real_power_generator_snapshots_at ( network, vertexId, function );
+
2692 }
+
2694
+
2729 template<typename FUNCTION>
+
2730 inline static
+
2731 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
2732 , Types::vertexId vertexId
+
2733 , Types::index timestampPosition
+
2734 , FUNCTION function )
+
2735 {
+
2736 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
2737
+
2738 std::vector<Types::generatorId> generatorIds;
+
2739 network.GeneratorIds ( vertexId, generatorIds );
+
2740
+
2741 #pragma omp parallel for
+
2742 for ( Types::index generatorId = 0
+
2743 ; generatorId < generatorIds.size()
+
2744 ; ++generatorId )
+
2745 {
+
2746 function ( network.GeneratorSnapshotOf( generatorIds[generatorId], timestampPosition ) );
+
2747 }
+
2748 }
+
2749
+
2750 template<typename FUNCTION>
+
2751 inline static
+
2752 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
2753 , Types::vertexId vertexId
+
2754 , Types::index timestampPosition
+
2755 , FUNCTION function )
+
2756 {
+
2757 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
2758
+
2759 std::vector<Types::generatorId> generatorIds;
+
2760 network.GeneratorIds ( vertexId, generatorIds );
+
2761
+
2762 #pragma omp parallel for
+
2763 for ( Types::index generatorId = 0
+
2764 ; generatorId < generatorIds.size()
+
2765 ; ++generatorId )
+
2766 {
+
2767 function ( network.GeneratorSnapshotOf( generatorIds[generatorId], timestampPosition ) );
+
2768 }
+
2769 }
+
2771
+
2804 template<typename FUNCTION>
+
2805 inline static
+
2806 void for_all_real_power_generator_snapshots_at ( TNetwork & network
+
2807 , TVertex const & vertex
+
2808 , Types::index timestampPosition
+
2809 , FUNCTION function )
+
2810 {
+
2811 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2812
+
2813 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
2814
+
2815 for_all_real_power_generator_snapshots_at ( network, vertexId, timestampPosition, function );
+
2816 }
+
2817
+
2818 template<typename FUNCTION>
+
2819 inline static
+
2820 void for_all_real_power_generator_snapshots_at ( TNetwork const & network
+
2821 , TVertex const & vertex
+
2822 , Types::index timestampPosition
+
2823 , FUNCTION function )
+
2824 {
+
2825 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
2826
+
2827 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
2828
+
2829 for_all_real_power_generator_snapshots_at ( network, vertexId, timestampPosition, function );
+
2830 }
+
2832
+
2835#pragma mark PARALLEL_LOAD_LOOPS
+
2836
+
2857 template<typename FUNCTION>
+
2858 inline static
+
2859 void for_all_loads ( TNetwork & network
+
2860 , FUNCTION function )
+
2861 {
+
2862 #pragma omp parallel for
+
2863 for ( Types::loadId loadId = 0
+
2864 ; loadId < network.loads_.size()
+
2865 ; ++loadId )
+
2866 {
+
2867 function ( network.loads_[loadId] );
+
2868 }
+
2869 }
+
2870
+
2891 template<typename FUNCTION>
+
2892 inline static
+
2893 void for_all_loads ( TNetwork const & network
+
2894 , FUNCTION function )
+
2895 {
+
2896 #pragma omp parallel for
+
2897 for ( Types::loadId loadId = 0
+
2898 ; loadId < network.loads_.size()
+
2899 ; ++loadId )
+
2900 {
+
2901 function ( network.loads_[loadId] );
+
2902 }
+
2903 }
+
2904
+
2926 template<typename FUNCTION>
+
2927 inline static
+
2928 void for_all_vertex_identifiers_with_load ( TNetwork const & network
+
2929 , FUNCTION function )
+
2930 {
+
2931 Types::vertexId vertexIdSafeguard = 0;
+
2932 #pragma omp parallel for
+
2933 for ( Types::vertexId vertexId = 0
+
2934 ; vertexId < network.Graph().Vertices().size()
+
2935 ; ++vertexId )
+
2936 {
+
2937 if ( network.HasLoadAt(vertexId)
+
2938 && network.Graph().VertexExists(vertexId) )
+
2939 {
+
2940 vertexIdSafeguard = vertexId;
+
2941 function ( vertexIdSafeguard );
+
2942 }
+
2943 }
+
2944 }
+
2945
+
2968 template<typename FUNCTION>
+
2969 inline static
+
2970 void for_all_load_identifiers_at ( Types::vertexId vertexId
+
2971 , TNetwork const & network
+
2972 , FUNCTION function )
+
2973 {
+
2974 if ( network.HasLoadAt ( vertexId )
+
2975 && network.Graph().VertexExists ( vertexId ) )
+
2976 {
+
2977 #pragma omp parallel for
+
2978 for ( Types::index index = 0
+
2979 ; index < network.loadsAtVertex_[vertexId].size()
+
2980 ; ++index )
+
2981 {
+
2982 function ( network.loadsAtVertex_[vertexId][index] );
+
2983 }
+
2984 }
+
2985 }
+
2986
+
3008 template<typename FUNCTION>
+
3009 inline static
+
3010 void for_all_load_identifiers_at ( TVertex const & vertex
+
3011 , TNetwork const & network
+
3012 , FUNCTION function )
+
3013 {
+
3014 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3015 for_all_load_identifiers_at ( vertexId, network, function );
+
3016 }
+
3017
+
3039 template<typename FUNCTION>
+
3040 inline static
+
3041 void for_all_loads_at ( TVertex const & vertex
+
3042 , TNetwork & network
+
3043 , FUNCTION function )
+
3044 {
+
3045 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3046 for_all_loads_at ( vertexId, network, function );
+
3047 }
+
3048
+
3070 template<typename FUNCTION>
+
3071 inline static
+
3072 void for_all_loads_at ( TVertex const & vertex
+
3073 , TNetwork const & network
+
3074 , FUNCTION function )
+
3075 {
+
3076 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3077 for_all_loads_at ( vertexId, network, function );
+
3078 }
+
3079
+
3101 template<typename FUNCTION>
+
3102 inline static
+
3103 void for_all_loads_at ( Types::vertexId const vertexId
+
3104 , TNetwork & network
+
3105 , FUNCTION function )
+
3106 {
+
3107 for_all_load_identifiers_at ( vertexId, network,
+
3108 [ &network, &function ]( Types::loadId loadId )
+
3109 {
+
3110 function ( network.loads_[loadId] );
+
3111 }
+
3112 );
+
3113 }
+
3114
+
3136 template<typename FUNCTION>
+
3137 inline static
+
3138 void for_all_loads_at ( Types::vertexId const vertexId
+
3139 , TNetwork const & network
+
3140 , FUNCTION function )
+
3141 {
+
3142 for_all_load_identifiers_at ( vertexId, network,
+
3143 [ &network, &function ]( Types::loadId loadId )
+
3144 {
+
3145 function ( network.loads_[loadId] );
+
3146 }
+
3147 );
+
3148 }
+
3149
+
3171 template<typename FUNCTION>
+
3172 inline static
+
3173 void for_all_load_tuples ( TNetwork & network
+
3174 , FUNCTION function )
+
3175 {
+
3176 Types::vertexId vertexIdSafeguard = 0;
+
3177 #pragma omp parallel for
+
3178 for ( Types::vertexId vertexId = 0
+
3179 ; vertexId < network.Graph().Vertices().size()
+
3180 ; ++vertexId )
+
3181 {
+
3182 if ( network.HasLoadAt(vertexId) )
+
3183 {
+
3184 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
3185 {
+
3186 vertexIdSafeguard = vertexId;
+
3187 function( vertexIdSafeguard, network.loads_[loadId] );
+
3188 }
+
3189 }
+
3190 }
+
3191 }
+
3192
+
3214 template<typename FUNCTION>
+
3215 inline static
+
3216 void for_all_load_tuples ( TNetwork const & network
+
3217 , FUNCTION function )
+
3218 {
+
3219 Types::vertexId vertexIdSafeguard = 0;
+
3220 #pragma omp parallel for
+
3221 for ( Types::vertexId vertexId = 0
+
3222 ; vertexId < network.Graph().Vertices().size()
+
3223 ; ++vertexId )
+
3224 {
+
3225 if ( network.HasLoadAt(vertexId) )
+
3226 {
+
3227 for ( Types::loadId loadId : network.loadsAtVertex_[vertexId] )
+
3228 {
+
3229 vertexIdSafeguard = vertexId;
+
3230 function( vertexIdSafeguard, network.loads_[loadId] );
+
3231 }
+
3232 }
+
3233 }
+
3234 }
+
3235
+
3258 template<typename FUNCTION>
+
3259 inline static
+
3260 void for_all_loads_tuple ( TNetwork const & network
+
3261 , FUNCTION function )
+
3262 {
+
3263 Types::vertexId vertexIdSafeguard = 0;
+
3264 #pragma omp parallel for
+
3265 for ( Types::vertexId vertexId = 0
+
3266 ; vertexId < network.Graph().Vertices().size()
+
3267 ; ++vertexId )
+
3268 {
+
3269 if ( network.HasLoadAt(vertexId) )
+
3270 {
+
3271 std::vector<TLoadProperties> loads;
+
3272 network.LoadsAt ( vertexId, loads );
+
3273 vertexIdSafeguard = vertexId;
+
3274 function( vertexIdSafeguard, loads );
+
3275 }
+
3276 }
+
3277 }
+
3279
+
3280#pragma mark PARALLEL_LOAD_SNAPSHOT_LOOPS
+
3281
+
3304 template<typename FUNCTION>
+
3305 inline static
+
3306 void for_all_real_power_load_snapshots ( TNetwork & network
+
3307 , FUNCTION function )
+
3308 {
+
3309 #pragma omp parallel for
+
3310 for ( Types::loadId loadId = 0
+
3311 ; loadId < network.loadSnapshots_.size()
+
3312 ; ++loadId )
+
3313 {
+
3314 for_all_real_power_load_snapshots_of ( network
+
3315 , loadId
+
3316 , function );
+
3317 }
+
3318 }
+
3319
+
3320 template<typename FUNCTION>
+
3321 inline static
+
3322 void for_all_real_power_load_snapshots ( TNetwork const & network
+
3323 , FUNCTION function )
+
3324 {
+
3325 #pragma omp parallel for
+
3326 for ( Types::loadId loadId = 0
+
3327 ; loadId < network.loadSnapshots_.size()
+
3328 ; ++loadId )
+
3329 {
+
3330 for_all_real_power_load_snapshots_of ( network
+
3331 , loadId
+
3332 , function );
+
3333 }
+
3334 }
+
3336
+
3367 template<typename FUNCTION>
+
3368 inline static
+
3369 void for_all_real_power_load_snapshots_of ( TNetwork & network
+
3370 , Types::loadId loadId
+
3371 , FUNCTION function )
+
3372 {
+
3373 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
3374
+
3375 #pragma omp parallel for
+
3376 for ( Types::index timestampPosition = 0
+
3377 ; timestampPosition < network.loadSnapshots_.size()
+
3378 ; ++timestampPosition )
+
3379 {
+
3380 function ( timestampPosition
+
3381 , network.LoadSnapshotOf( loadId, timestampPosition ) );
+
3382 }
+
3383 }
+
3384
+
3385 template<typename FUNCTION>
+
3386 inline static
+
3387 void for_all_real_power_load_snapshots_of ( TNetwork const & network
+
3388 , Types::loadId loadId
+
3389 , FUNCTION function )
+
3390 {
+
3391 #pragma omp parallel for
+
3392 for ( Types::index timestampPosition = 0
+
3393 ; timestampPosition < network.loadSnapshots_.size()
+
3394 ; ++timestampPosition )
+
3395 {
+
3396 function ( timestampPosition
+
3397 , network.LoadSnapshotOf( loadId, timestampPosition ) );
+
3398 }
+
3399 }
+
3401
+
3402
+
3432 template<typename FUNCTION>
+
3433 inline static
+
3434 void for_all_real_power_load_snapshots_of ( TNetwork & network
+
3435 , TLoadProperties loadProperties
+
3436 , FUNCTION function )
+
3437 {
+
3438 Types::loadId loadId = network.LoadId ( loadProperties );
+
3439
+
3440 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
3441
+
3442 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
3443 }
+
3444
+
3445 template<typename FUNCTION>
+
3446 inline static
+
3447 void for_all_real_power_load_snapshots_of ( TNetwork const & network
+
3448 , TLoadProperties loadProperties
+
3449 , FUNCTION function )
+
3450 {
+
3451 Types::loadId loadId = network.LoadId ( loadProperties );
+
3452
+
3453 USAGE_ASSERT ( network.HasLoad ( loadId ) );
+
3454
+
3455 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
3456 }
+
3458
+
3489 template<typename FUNCTION>
+
3490 inline static
+
3491 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
3492 , Types::vertexId vertexId
+
3493 , FUNCTION function )
+
3494 {
+
3495 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
3496
+
3497 std::vector<Types::loadId> loadIds;
+
3498 network.LoadIds ( vertexId, loadIds );
+
3499
+
3500 #pragma omp parallel for
+
3501 for ( Types::index loadId = 0
+
3502 ; loadId < loadIds.size()
+
3503 ; ++loadId )
+
3504 {
+
3505 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
3506 }
+
3507 }
+
3508
+
3509 template<typename FUNCTION>
+
3510 inline static
+
3511 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
3512 , Types::vertexId vertexId
+
3513 , FUNCTION function )
+
3514 {
+
3515 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
3516
+
3517 std::vector<Types::loadId> loadIds;
+
3518 network.LoadIds ( vertexId, loadIds );
+
3519
+
3520 #pragma omp parallel for
+
3521 for ( Types::index loadId = 0
+
3522 ; loadId < loadIds.size()
+
3523 ; ++loadId )
+
3524 {
+
3525 for_all_real_power_load_snapshots_of ( network, loadId, function );
+
3526 }
+
3527 }
+
3529
+
3560 template<typename FUNCTION>
+
3561 inline static
+
3562 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
3563 , TVertex vertex
+
3564 , FUNCTION function )
+
3565 {
+
3566 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3567
+
3568 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
3569
+
3570 for_all_real_power_load_snapshots_at ( network, vertexId, function );
+
3571 }
+
3572
+
3573 template<typename FUNCTION>
+
3574 inline static
+
3575 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
3576 , TVertex vertex
+
3577 , FUNCTION function )
+
3578 {
+
3579 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3580
+
3581 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
3582
+
3583 for_all_real_power_load_snapshots_at ( network, vertexId, function );
+
3584 }
+
3586
+
3621 template<typename FUNCTION>
+
3622 inline static
+
3623 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
3624 , Types::vertexId vertexId
+
3625 , Types::index timestampPosition
+
3626 , FUNCTION function )
+
3627 {
+
3628 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
3629
+
3630 std::vector<Types::loadId> loadIds;
+
3631 network.LoadIds ( vertexId, loadIds );
+
3632
+
3633 #pragma omp parallel for
+
3634 for ( Types::index loadId = 0
+
3635 ; loadId < loadIds.size()
+
3636 ; ++loadId )
+
3637 {
+
3638 function ( network.LoadSnapshotOf( loadId, timestampPosition ) );
+
3639 }
+
3640 }
+
3641
+
3642 template<typename FUNCTION>
+
3643 inline static
+
3644 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
3645 , Types::vertexId vertexId
+
3646 , Types::index timestampPosition
+
3647 , FUNCTION function )
+
3648 {
+
3649 USAGE_ASSERT( network.Graph().VertexExists( vertexId ) );
+
3650
+
3651 std::vector<Types::loadId> loadIds;
+
3652 network.LoadIds ( vertexId, loadIds );
+
3653
+
3654 #pragma omp parallel for
+
3655 for ( Types::index loadId = 0
+
3656 ; loadId < loadIds.size()
+
3657 ; ++loadId )
+
3658 {
+
3659 function ( network.LoadSnapshotOf( loadId, timestampPosition ) );
+
3660 }
+
3661 }
+
3663
+
3696 template<typename FUNCTION>
+
3697 inline static
+
3698 void for_all_real_power_load_snapshots_at ( TNetwork & network
+
3699 , TVertex const & vertex
+
3700 , Types::index timestampPosition
+
3701 , FUNCTION function )
+
3702 {
+
3703 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3704
+
3705 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
3706
+
3707 for_all_real_power_load_snapshots_at ( network, vertexId, timestampPosition, function );
+
3708 }
+
3709
+
3710 template<typename FUNCTION>
+
3711 inline static
+
3712 void for_all_real_power_load_snapshots_at ( TNetwork const & network
+
3713 , TVertex const & vertex
+
3714 , Types::index timestampPosition
+
3715 , FUNCTION function )
+
3716 {
+
3717 Types::vertexId vertexId = network.Graph().VertexId( vertex );
+
3718
+
3719 USAGE_ASSERT ( network.Graph().VertexExists ( vertexId ) );
+
3720
+
3721 for_all_real_power_load_snapshots_at ( network, vertexId, timestampPosition, function );
+
3722 }
+
3724};
+
3725
+
3726#else // OPENMP_AVAILABLE
+
3727
+
3734template<typename PowerGridType>
+
+
3735class PowerGridLoopDifferentiation<PowerGridType, ExecutionPolicy::parallel>
+
3736 : public PowerGridLoopDifferentiation<PowerGridType, ExecutionPolicy::sequential> {};
+
+
3737
+
3738#endif // OPENMP_AVAILABLE
+
3739
+
3740} // namespace egoa::internal
+
3741
+
3742#endif // EGOA__DATASTRUCTURES__GRAPHS__ITERATORS__POWER_GRID_ITERATORS_HPP
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at
static void for_all_loads_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
The sequential for loop over all load objects at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:1258
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators
static void for_all_generators(TNetwork const &network, FUNCTION function)
The sequential for loop over all generators (vertex independent).
Definition PowerGridIterators.hpp:103
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of
static void for_all_real_power_load_snapshots_of(TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)
The sequential for loop over all real power snapshots of a load.
Definition PowerGridIterators.hpp:1550
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple
static void for_all_generator_tuple(TNetwork &network, FUNCTION function)
The sequential for loop over all verticesthat have a generator and its generator objects.
Definition PowerGridIterators.hpp:378
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots
static void for_all_real_power_generator_snapshots(TNetwork &network, FUNCTION function)
The sequential for loop over all generator maximum real power p.u. snapshots.
Definition PowerGridIterators.hpp:550
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple
static void for_all_generators_tuple(TNetwork &network, FUNCTION function)
The sequential for loop over all verticesthat have a generator.
Definition PowerGridIterators.hpp:463
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of
static void for_all_real_power_generator_snapshots_of(TNetwork &network, Types::generatorId generatorId, FUNCTION function)
The sequential for loop over all maximum real power p.u. snapshots of a generator with generatorId.
Definition PowerGridIterators.hpp:608
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at
static void for_all_loads_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)
The sequential for loop over all load objects at a vertex.
Definition PowerGridIterators.hpp:1192
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators
static void for_all_generators(TNetwork &network, FUNCTION function)
The sequential for loop over all generators (vertex independent).
Definition PowerGridIterators.hpp:72
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads
static void for_all_loads(TNetwork const &network, FUNCTION function)
The sequential for loop over all loads (vertex independent).
Definition PowerGridIterators.hpp:1019
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at
static void for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)
The sequential for loop over all load identifiers at a vertex.
Definition PowerGridIterators.hpp:1130
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at
static void for_all_generator_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
The sequential for loop over all generator identifiers at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:174
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples
static void for_all_load_tuples(TNetwork const &network, FUNCTION function)
The sequential for loop over all verticesthat have a load and its load objects.
Definition PowerGridIterators.hpp:1335
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples
static void for_all_load_tuples(TNetwork &network, FUNCTION function)
The sequential for loop over all verticesthat have a load and its load objects.
Definition PowerGridIterators.hpp:1293
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_load
static void for_all_vertex_identifiers_with_load(TNetwork const &network, FUNCTION function)
The sequential for loop over all vertices that have a load.
Definition PowerGridIterators.hpp:1051
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at
static void for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
The sequential for loop over snapshots with a certain @ timestampPosition for all load.
Definition PowerGridIterators.hpp:1732
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at
static void for_all_generators_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
The sequential for loop over all generator objects at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:343
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_tuple
static void for_all_loads_tuple(TNetwork const &network, FUNCTION function)
The sequential for loop over all verticesthat have a load.
Definition PowerGridIterators.hpp:1378
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at
static void for_all_generators_at(TVertex const &vertex, TNetwork &network, FUNCTION function)
The sequential for loop over all generator objects at a vertex.
Definition PowerGridIterators.hpp:246
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at
static void for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)
The sequential for loop over all real power snapshots of a load.
Definition PowerGridIterators.hpp:1607
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots
static void for_all_real_power_load_snapshots(TNetwork &network, FUNCTION function)
The sequential for loop over all load real power snapshots.
Definition PowerGridIterators.hpp:1424
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of
static void for_all_real_power_load_snapshots_of(TNetwork &network, Types::loadId loadId, FUNCTION function)
The sequential for loop over all real power snapshots of a load with loadId.
Definition PowerGridIterators.hpp:1485
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple
static void for_all_generators_tuple(TNetwork const &network, FUNCTION function)
The sequential for loop over all verticesthat have a generator.
Definition PowerGridIterators.hpp:505
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at
static void for_all_generators_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
The sequential for loop over all generator objects at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:308
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at
static void for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)
The for loop over all real power snapshots of a load.
Definition PowerGridIterators.hpp:1671
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at
static void for_all_generators_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)
The sequential for loop over all generator objects at a vertex.
Definition PowerGridIterators.hpp:277
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at
static void for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
The for loop over all real power snapshots of a load and a timestamp at timestampPosition.
Definition PowerGridIterators.hpp:1800
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at
static void for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
The sequential for loop over all load identifiers at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:1092
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of
static void for_all_real_power_generator_snapshots_of(TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)
The sequential for loop over all maximum real power p.u. snapshots of a generator.
Definition PowerGridIterators.hpp:671
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at
static void for_all_generator_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)
The sequential for loop over all generator identifiers at a vertex.
Definition PowerGridIterators.hpp:214
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_generator
static void for_all_vertex_identifiers_with_generator(TNetwork const &network, FUNCTION function)
The sequential for loop over all vertices that have a generator.
Definition PowerGridIterators.hpp:134
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads
static void for_all_loads(TNetwork &network, FUNCTION function)
The sequential for loop over all loads (vertex independent).
Definition PowerGridIterators.hpp:988
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple
static void for_all_generator_tuple(TNetwork const &network, FUNCTION function)
The sequential for loop over all verticesthat have a generator and its generator objects.
Definition PowerGridIterators.hpp:420
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at
static void for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)
The sequential for loop over all generator maximum real power p.u. snapshots at a vertex with vertexI...
Definition PowerGridIterators.hpp:729
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at
static void for_all_loads_at(TVertex const &vertex, TNetwork &network, FUNCTION function)
The sequential for loop over all load objects at a vertex.
Definition PowerGridIterators.hpp:1161
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at
static void for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)
The sequential for loop over all generator maximum real power p.u. snapshots at a vertex.
Definition PowerGridIterators.hpp:796
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at
static void for_all_loads_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
The sequential for loop over all load objects at a vertex identifier vertexId.
Definition PowerGridIterators.hpp:1223
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at
static void for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
The sequential for loop over snapshots with a certain @ timestampPosition for all generators.
Definition PowerGridIterators.hpp:864
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at
static void for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.
Definition PowerGridIterators.hpp:934
+
egoa::internal::PowerGridLoopDifferentiation
The base class for for loops for power grid.
Definition PowerGridIterators.hpp:33
+
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_prim_8hpp_source.html b/_prim_8hpp_source.html new file mode 100644 index 00000000..946bd282 --- /dev/null +++ b/_prim_8hpp_source.html @@ -0,0 +1,188 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/SpanningTree/Prim.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Prim.hpp
+
+
+
1/*
+
2 * Prim.hpp
+
3 *
+
4 * Created on: Nov 22, 2018
+
5 * Author: Franziska Wegner, Matthias Wolf
+
6 */
+
7
+
8#ifndef EGOA__ALGORITHMS__SPANNING_TREES__PRIM_HPP
+
9#define EGOA__ALGORITHMS__SPANNING_TREES__PRIM_HPP
+
10
+
11#include "Algorithms/SpanningTree/MST.hpp"
+
12
+
13#include "DataStructures/Container/Queues/MappingBinaryHeap.hpp"
+
14
+
15namespace egoa {
+
29template< typename GraphType>
+
+
30class Prim final : public MST<GraphType> {
+
31
+
32 using TSpanningTree = MST<GraphType>;
+
33 using typename TSpanningTree::TGraph;
+
34 using typename TSpanningTree::TEdge;
+
35 using typename TSpanningTree::TComparator;
+
36
+
37 public:
+
38 Prim(TGraph & graph,
+
39 TComparator comparator)
+
40 : TSpanningTree( graph, std::move(comparator) )
+
41 {}
+
42
+
43 virtual ~Prim() {}
+
44
+
+
62 virtual inline void Run ( ) override {
+
63 Types::count const numberOfVertices = this->Graph().NumberOfVertices();
+
64
+
65 if (numberOfVertices == 0) return;
+
66
+
67 std::vector<bool> isVertexInMst( numberOfVertices, false );
+
68 std::vector<bool> visited(numberOfVertices, false);
+
69 std::vector<Types::edgeId> edgesInSpanningTree;
+
70
+
71 // TODO: Use vector instead of the default unordered_map
+
72 MappingBinaryHeap<Types::vertexId, Types::edgeId> heap(this->Comparator());
+
73
+
74 Types::vertexId currentVertex = 0;
+
75 visited[currentVertex] = true;
+
76
+
77 while (true) {
+
78 isVertexInMst[currentVertex] = true;
+
79
+
80 // Iterate over all incident edges
+
81 this->Graph().template for_all_edges_at<ExecutionPolicy::sequential>( currentVertex,
+
82 [&]( TEdge const & edge ) {
+
83 Types::vertexId neighbor = edge.Other( currentVertex );
+
84
+
85 // Ignore edges to vertices that have already been included in the MST
+
86 if (isVertexInMst[neighbor]) return;
+
87
+
88 if (!visited[neighbor])
+
89 { // The neighbor has not been visited before
+
90 heap.Insert(neighbor, edge.Identifier());
+
91 visited[neighbor] = true;
+
92 } else if ( this->Comparator()( edge.Identifier(), heap.KeyOf(neighbor) ) )
+
93 {
+
94 // Better edge to neighbor has been found
+
95 heap.ChangeKey(neighbor, edge.Identifier());
+
96 }
+
97 });
+
98
+
99 if (heap.Empty()) break;
+
100
+
101 Types::edgeId parentEdge;
+
102 std::tie(currentVertex, parentEdge) = heap.DeleteTop();
+
103 edgesInSpanningTree.push_back(parentEdge);
+
104 } // while loop
+
105
+
106 this->SetResult(std::move(edgesInSpanningTree));
+
107 }
+
+
108};
+
+
109
+
110} // namespace egoa
+
111
+
112
+
113#endif // EGOA__ALGORITHMS__SPANNING_TREES__PRIM_HPP
+
egoa::MST
Base class for minimum spanning tree algorithms.
Definition MST.hpp:38
+
egoa::MST::SetResult
void SetResult(std::vector< Types::edgeId > &&edges)
Builds a subgraph object representing the spanning tree given by the edges.
Definition MST.hpp:86
+
egoa::MappingBinaryHeap
Class for binary heap data structure, in which elements are sorted by keys.
Definition MappingBinaryHeap.hpp:72
+
egoa::MappingBinaryHeap::DeleteTop
std::pair< TElement, TKey > DeleteTop()
Deletes the top element and returns it and its key.
Definition MappingBinaryHeap.hpp:303
+
egoa::MappingBinaryHeap::ChangeKey
void ChangeKey(const TElement &element, TKey newKey)
Changes the key of the element.
Definition MappingBinaryHeap.hpp:380
+
egoa::MappingBinaryHeap::Empty
bool Empty() const
Whether the heap is empty.
Definition MappingBinaryHeap.hpp:401
+
egoa::MappingBinaryHeap::Insert
void Insert(TElement element, TKey key)
Inserts the element with the given key.
Definition MappingBinaryHeap.hpp:225
+
egoa::MappingBinaryHeap::KeyOf
TKey const & KeyOf(TElement const &element) const
The key of the element.
Definition MappingBinaryHeap.hpp:197
+
egoa::Prim
An implementation of Prim's algorithm for finding minimum spanning trees.
Definition Prim.hpp:30
+
egoa::Prim::Run
virtual void Run() override
Prim's algorithm @detail Prim's algorithm is quite similar to Dijkstra's algorithm....
Definition Prim.hpp:62
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_priority_queue_8hpp_source.html b/_priority_queue_8hpp_source.html new file mode 100644 index 00000000..e239f652 --- /dev/null +++ b/_priority_queue_8hpp_source.html @@ -0,0 +1,175 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/PriorityQueue.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PriorityQueue.hpp
+
+
+
1/*
+
2 * PriorityQueue.hpp
+
3 *
+
4 * Created on: Jan 28, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__PRIORITY_QUEUE_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__PRIORITY_QUEUE_HPP
+
10
+
11#include <queue>
+
12#include "Queue.hpp"
+
13#include "Auxiliary/Auxiliary.hpp"
+
14
+
15namespace egoa {
+
16
+
17template<typename Type>
+
+
18class PriorityQueue : public Queue<Type> {
+
19 // Type aliasing
+
20 using TElement = Type;
+
21
+
22 public:
+
23#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
24 PriorityQueue(){}
+
25
+
26 template<typename Compare, class Container>
+
27 PriorityQueue ( Compare const & compare ) {}
+
28
+
29 template<class Container>
+
30 PriorityQueue ( Container const & container ) {}
+
31
+
32 template<typename Compare, class Container>
+
33 PriorityQueue ( Compare const & compare
+
34 , Container const & container ) {}
+
35
+
36 virtual ~PriorityQueue() override {}
+
37
+
38#pragma mark LOOPS
+
39 template<bool IsParallel, typename FUNCTION>
+
40 inline void for_all_elements ( FUNCTION function ) {}
+
41
+
42 template<bool IsParallel, typename FUNCTION>
+
43 inline void for_all_elements ( FUNCTION function ) const {}
+
44
+
45 template<typename FUNCTION>
+
46 inline void breakable_for_all_elements ( FUNCTION function ) {}
+
47
+
48 template<typename FUNCTION>
+
49 inline void breakable_for_all_elements ( FUNCTION function ) const {}
+
50
+
51#pragma mark ELEMENT_ACCESS
+
54 virtual inline TElement const & Top () const override = 0;
+
56
+
59 virtual inline void BuildWith( std::vector<TElement> const & elements ) = 0;
+
60
+
61#pragma mark ADD_ELEMENTS
+
62 virtual inline void Push ( TElement const & value ) override = 0;
+
63 virtual inline void Push ( TElement && value ) override = 0;
+
64#pragma mark MODIFIERS
+
65 virtual inline void Pop () override = 0;
+
66 virtual inline TElement DeleteMin () override = 0;
+
67 virtual inline void Clear () override = 0;
+
68
+
69 virtual inline void ChangeKey ( Types::index index
+
70 , TElement const & element ) = 0;
+
71 virtual inline void DecreaseKey ( Types::index index
+
72 , TElement const & element ) = 0;
+
74
+
75#pragma mark CAPACITY
+
78 virtual inline bool Empty () const override = 0;
+
79 virtual inline Types::count Size () const override = 0;
+
81};
+
+
82
+
83} // namespace egoa
+
84
+
85#endif // EGOA__DATA_STRUCTURES__CONTAINER__PRIORITY_QUEUE_HPP
+ +
egoa::PriorityQueue::Push
virtual void Push(TElement const &value) override=0
+
egoa::PriorityQueue::BuildWith
virtual void BuildWith(std::vector< TElement > const &elements)=0
+
egoa::PriorityQueue::Empty
virtual bool Empty() const override=0
+
egoa::PriorityQueue::Top
virtual TElement const & Top() const override=0
+ +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_py_psa_parser_8hpp_source.html b/_py_psa_parser_8hpp_source.html new file mode 100644 index 00000000..33f5c6ce --- /dev/null +++ b/_py_psa_parser_8hpp_source.html @@ -0,0 +1,2710 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Parser/PyPsaParser.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PyPsaParser.hpp
+
+
+
1/*
+
2 * PyPsaParser.hpp
+
3 * https://pypsa.org/doc/components.html
+
4 * https://pypsa.org
+
5 * https://wiki.openmod-initiative.org/wiki/Transmission_network_datasets
+
6 *
+
7 * Created on: Nov 20, 2018
+
8 * Author: Franziska Wegner
+
9 */
+
10
+
11#ifndef EGOA__IO__PARSER___PY_PSA_PARSER_HPP
+
12#define EGOA__IO__PARSER___PY_PSA_PARSER_HPP
+
13
+
14#include <typeinfo>
+
15
+
16#include <QFile>
+
17#include <QStringList>
+
18
+
19#include "IO/Wrapper/Edge.hpp"
+
20#include "IO/Helper/DataValidation.hpp"
+
21
+
22#include "DataStructures/Networks/PowerGrid.hpp"
+
23#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
24#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
25#include "DataStructures/Graphs/Vertices/GeneratorProperties.hpp"
+
26#include "DataStructures/Graphs/Vertices/LoadProperties.hpp"
+
27
+
28#include "Auxiliary/Auxiliary.hpp"
+
29
+
30namespace egoa {
+
31
+
32namespace internal {
+
33template<typename VertexTypeProperties, typename EdgeTypeProperties, typename GraphType>
+
34class NetworkDifferentiation;
+
35} // namespace internal
+
36
+
37template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties > >
+
+
38class PyPsaParser {
+
39
+
40#pragma mark TEMPLATE_TYPE_ALIASING
+
41 // Template type aliasing
+
42 using TGraph = GraphType;
+
43 using TNetwork = PowerGrid<GraphType>;
+
44 // Vertices
+
45 using TVertex = typename TGraph::TVertex;
+
46 using TVertexProperties = typename TGraph::TVertexProperties;
+
47 using TVertexType = typename TVertexProperties::TVertexType;
+
48 using TGeneratorProperties = typename TNetwork::TGeneratorProperties;
+
49 using TLoadProperties = typename TNetwork::TLoadProperties;
+
50 // Edges
+
51 using TEdge = typename TGraph::TEdge;
+
52 using TEdgeProperties = typename TGraph::TEdgeProperties;
+
53 using TIoEdge = io::Edge<TEdgeProperties>;
+
54 // Bounds
+
55 using TBound = Bound<>;
+
56
+
57 public:
+
58
+
61#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
62
+
63 explicit PyPsaParser ( std::string const & filename )
+
64 : path2FileDirectory_( filename )
+
65 , filenameBuses_("buses.csv")
+
66 , filenameCarriers_("carriers.csv")
+
67 , filenameGenerators_("generators.csv")
+
68 , filenameGeneratorsPMaxPu_("generators-p_max_pu.csv")
+
69 , filenameGlobalConstraints_("global_constraints.csv")
+
70 , filenameLines_("lines.csv")
+
71 , filenameLinesNew_("lines_new.csv")
+
72 , filenameLoads_("loads.csv")
+
73 , filenameLoadsPSet_("loads-p_set.csv")
+
74 , filenameNetwork_("network.csv")
+
75 , filenameSnapshots_("snapshots.csv")
+
76 , filenameStorageUnits_("storage_units.csv")
+
77 , filenameStorageUnitsInflow_("storage_units-inflow.csv")
+
78 , generatorSnapshotsSize(0)
+
79 , loadSnapshotsSize(0)
+
80 {}
+
81
+
82 PyPsaParser ( std::string filenameBuses
+
83 , std::string filenameCarriers
+
84 , std::string filenameGenerators
+
85 , std::string filenameGeneratorsPMaxPu
+
86 , std::string filenameGlobalConstraints
+
87 , std::string filenameLines
+
88 , std::string filenameLinesNew
+
89 , std::string filenameLoads
+
90 , std::string filenameLoadsPSet
+
91 , std::string filenameNetwork
+
92 , std::string filenameSnapshots
+
93 , std::string filenameStorageUnits
+
94 , std::string filenameStorageUnitsInflow )
+
95 : filenameBuses_(filenameBuses)
+
96 , filenameCarriers_(filenameCarriers)
+
97 , filenameGenerators_(filenameGenerators)
+
98 , filenameGeneratorsPMaxPu_(filenameGeneratorsPMaxPu)
+
99 , filenameGlobalConstraints_(filenameGlobalConstraints)
+
100 , filenameLines_(filenameLines)
+
101 , filenameLinesNew_(filenameLinesNew)
+
102 , filenameLoads_(filenameLoads)
+
103 , filenameLoadsPSet_(filenameLoadsPSet)
+
104 , filenameNetwork_(filenameNetwork)
+
105 , filenameSnapshots_(filenameSnapshots)
+
106 , filenameStorageUnits_(filenameStorageUnits)
+
107 , filenameStorageUnitsInflow_(filenameStorageUnitsInflow)
+
108 , generatorSnapshotsSize(0)
+
109 , loadSnapshotsSize(0)
+
110 {}
+
111
+
112 ~PyPsaParser()
+
113 {
+
114 mapBusName2VertexId_.clear();
+
115 mapGeneratorName2Generator_.clear();
+
116 mapGeneratorName2Identifier_.clear();
+
117 mapGeneratorName2BusName_.clear();
+
118 mapLoadName2Identifier_.clear();
+
119 }
+
121
+
124#pragma mark READERS
+
125
+
140 inline bool ReadStorageUnitsInflows ()
+
141 {
+
142 throw std::runtime_error ( "Not implemented yet! Storage units are currently unsupported." );
+
143 return true;
+
144 }
+
145
+
184 inline bool ReadStorageUnits()
+
185 {
+
186 throw std::runtime_error ( "Not implemented yet! Storage units are currently unsupported." );
+
187 return true;
+
188 }
+
189
+
229 inline bool ReadBuses ( TNetwork & network
+
+
230 , std::string const & filename )
+
231 {
+
232 QFile file( QString::fromStdString(filename + "/" + filenameBuses_) );
+
233 OpenFile(file);
+
234 QList<QByteArray> splitted = ReadLine( file );
+
235
+
236 dataMapperBuses_.clear();
+
237 ExtractBusHeader( splitted );
+
238 while( !file.atEnd() )
+
239 {
+
240 TVertexProperties vertexProperties;
+
241 std::string temp;
+
242
+
243 splitted = ReadLine( file, false );
+
244
+
245 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperBuses_.size() );
+
246
+
247 for ( Types::count counter = 0
+
248 ; counter < static_cast<Types::count>( splitted.size() )
+
249 ; ++counter )
+
250 {
+
251 temp = splitted[counter].toStdString();
+
252 (this->*dataMapperBuses_[counter])( temp , vertexProperties);
+
253 } // for
+
254 Types::vertexId index = AddVertex<TNetwork>( network, vertexProperties );
+
255 mapBusName2VertexId_[ vertexProperties.Name() ] = index;
+
256 } // while
+
257 return true;
+
258 }
+
259
+
+
272 inline bool ReadCarriers()
+
273 {
+
274 throw std::runtime_error ( "Not implemented yet! Storage units are currently unsupported." );
+
275 return true;
+
+
276 }
+
277
+
295 inline bool ReadGeneratorsRealPowerMaxPu ( TNetwork & network
+
296 , std::string const & filename )
+
297 {
+
298 QFile file( QString::fromStdString(filename + "/" + filenameGeneratorsPMaxPu_) );
+
299 OpenFile(file);
+
300 QList<QByteArray> splitted = ReadLine( file, false );
+
301
+
302 dataMapperGeneratorsRealPowerMaxPu_.clear();
+
303 ExtractGeneratorMaximumRealPowerPuHeader( splitted );
+
304
+
305 while( !file.atEnd() )
+
306 {
+
307 splitted = ReadLine( file, false );
+
308 std::string generationValue;
+
309
+
310 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperGeneratorsRealPowerMaxPu_.size() );
+
311
+
312 if ( !splitted[0].isEmpty() )
+
313 {
+
314 ++ generatorSnapshotsSize;
+
315 }
+
316 for ( Types::count counter = 0
+
317 ; counter < static_cast<Types::count>( splitted.size() )
+
318 ; ++counter )
+
319 {
+
320 generationValue = splitted[counter].toStdString();
+
321 dataMapperGeneratorsRealPowerMaxPu_[counter]( generationValue, network );
+
322 } // for
+
323 } // while
+
+
324 return true;
+
325 }
+
326
+
385 inline bool ReadGenerators ( TNetwork & network
+
386 , std::string const & filename )
+
387 {
+
388 QFile file( QString::fromStdString(filename + "/" + filenameGenerators_) );
+
389 OpenFile(file);
+
390 QList<QByteArray> splitted = ReadLine( file );
+
391
+
392 dataMapperGenerators_.clear();
+
393 ExtractGeneratorHeader( splitted );
+
394
+
+
395 while( !file.atEnd() )
+
396 {
+
397 splitted = ReadLine( file, false );
+
398 TGeneratorProperties generator;
+
399 std::string temp;
+
400
+
401 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperGenerators_.size() );
+
402
+
403 for ( Types::count counter = 0;
+
404 counter < static_cast<Types::count>( splitted.size() );
+
405 ++counter
+
406 )
+
407 {
+
408 temp = splitted[counter].toStdString();
+
409 (this->*dataMapperGenerators_[counter])( temp , generator);
+
410 } // for
+
411 Types::vertexId generatorId = Const::NONE;
+
412 if ( mapGeneratorName2BusName_.find(generator.Name()) != mapGeneratorName2BusName_.end() )
+
413 {
+
414 if ( mapBusName2VertexId_.find(mapGeneratorName2BusName_[generator.Name()]) != mapBusName2VertexId_.end() )
+
415 {
+
416 generatorId = network.AddGeneratorAt(mapBusName2VertexId_[mapGeneratorName2BusName_[generator.Name()]], generator);
+
417 } else {
+
418 ESSENTIAL_ASSERT( false && "Bus name does not exist" );
+
+
419 }
+
420 } else {
+
421 ESSENTIAL_ASSERT( false && "Generator name does not exist" );
+
422 }
+
423 if ( mapGeneratorName2Identifier_.find(generator.Name()) == mapGeneratorName2Identifier_.end() )
+
424 {
+
425 mapGeneratorName2Identifier_[generator.Name()] = generatorId;
+
426 } else {
+
427 ESSENTIAL_ASSERT( false && "Generator name to identifier, Generator name duplicates" );
+
428 }
+
429 } // while
+
430 network.UpdateGeneratorSnapshotSize();
+
431 return true;
+
+
432 }
+
433
+
451 inline bool ReadGlobalConstraints()
+
452 {
+
453 throw std::runtime_error ( "Not implemented yet! Storage units are currently unsupported." );
+
454 return true;
+
455 }
+
456
+
+
552 template<typename Graph = TNetwork>
+
553 inline bool ReadLines ( Graph & network
+
554 , const std::string & filename )
+
555 {
+
556 QFile file( QString::fromStdString ( filename + "/" + filenameLines_ ) );
+
557 OpenFile(file);
+
558 QList<QByteArray> splitted = ReadLine( file );
+
559
+
560 dataMapperLines_.clear();
+
561 ExtractLineHeader( splitted );
+
562
+
563 while( !file.atEnd() )
+
564 {
+
+
565 splitted = ReadLine( file, false );
+
566 TIoEdge edge;
+
567 SetLineDefaultValues ( edge );
+
568 std::string temp;
+
569
+
570 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperLines_.size() );
+
571
+
572 for ( Types::count counter = 0
+
573 ; counter < static_cast<Types::count>( splitted.size() )
+
+
574 ; ++counter )
+
575 {
+
576 temp = splitted[counter].toStdString();
+
577 (this->*dataMapperLines_[counter])( temp , edge );
+
578 } // for
+
579 AddEdge<Graph>( network, edge );
+
580 } // while
+
581 return true;
+
582 }
+
+
583
+
+
631 inline void SetLineDefaultValues( TIoEdge & edge )
+
632 {
+
633 edge.Properties().Status() = true;
+
634 edge.Properties().Type() = Edges::ElectricalEdgeType::standard;
+
635 edge.Properties().Reactance() = 0;
+
636 edge.Properties().Resistance() = 0;
+
637
+
638 // calculated by r and x
+
639 edge.Properties().Conductance(0.0);
+
+
640 edge.Properties().Susceptance(0.0);
+
641
+
642 edge.Properties().TapRatio() = 1;
+
643 edge.Properties().NominalApparentPower() = 0.0;
+
644 edge.Properties().NominalApparentPowerExtendable() = false;
+
+
645 edge.Properties().NominalApparentPowerBound().Minimum() = 0.0;
+
646 edge.Properties().NominalApparentPowerBound().Maximum() = Const::REAL_INFTY;
+
647 edge.Properties().ThermalLimit() = 1.0;
+
648 edge.Properties().CapitalCost() = 0.0;
+
649 edge.Properties().Length() = 0.0;
+
650 edge.Properties().TerrainFactor() = 0.0;
+
651 edge.Properties().NumberOfParallelLines() = 1.0;
+
652 edge.Properties().ThetaBound().Minimum() = -Const::REAL_INFTY;
+
653 edge.Properties().ThetaBound().Maximum() = Const::REAL_INFTY;
+
654 }
+
+
655
+
+
676 inline bool ReadLoadsPset ( TNetwork & network
+
677 , std::string const & filename )
+
678 {
+
+
679 QFile file( QString::fromStdString(filename + "/" + filenameLoadsPSet_) );
+
680 OpenFile(file);
+
681 QList<QByteArray> splitted = ReadLine( file, false );
+
682
+
683 dataMapperLoadsRealPowerMaxPu_.clear();
+
684 ExtractLoadMaximumRealPowerPuHeader( splitted );
+
+
685
+
686 while( !file.atEnd() )
+
687 {
+
688 splitted = ReadLine( file, false );
+
689 std::string loadValue;
+
690
+
691 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperLoadsRealPowerMaxPu_.size() );
+
692 if ( !splitted[0].isEmpty() )
+
693 {
+
694 ++ loadSnapshotsSize;
+
695 }
+
696
+
+
697 for ( Types::count counter = 0
+
698 ; counter < static_cast<Types::count>( splitted.size() )
+
699 ; ++counter )
+
700 {
+
701 loadValue = splitted[counter].toStdString();
+
702 dataMapperLoadsRealPowerMaxPu_[counter]( loadValue, network );
+
+
703 } // for
+
704 } // while
+
705 return true;
+
706 }
+
707
+
731 inline bool ReadLoads ( TNetwork & network
+
732 , std::string const & filename )
+
733 {
+
734 QFile file( QString::fromStdString(filename + "/" + filenameLoads_) );
+
735 OpenFile(file);
+
736 QList<QByteArray> splitted = ReadLine( file );
+
737 Types::index busColumn(0);
+
738
+
+
739 dataMapperLoads_.clear();
+
740 ExtractLoadHeader( splitted, busColumn );
+
741
+
742 while( !file.atEnd() )
+
743 {
+
744 splitted = ReadLine( file, false );
+
745 TLoadProperties vertex;
+
746 SetLoadDefaultValues(vertex);
+
747 Types::string temp;
+
+
748
+
749 USAGE_ASSERT ( static_cast<Types::count>( splitted.size() ) == dataMapperLoads_.size() );
+
750
+
751 // Read a row
+
752 for ( Types::count counter = 0
+
753 ; counter < static_cast<Types::count>( splitted.size() )
+
+
754 ; ++counter )
+
755 {
+
756 temp = splitted[counter].toStdString();
+
757 (this->*dataMapperLoads_[counter])( temp , vertex);
+
758 } // for each column in a row
+
+
759
+
760 Types::loadId loadId = Const::NONE;
+
761 if (mapBusName2VertexId_.find( splitted[ busColumn ].toStdString() ) != mapBusName2VertexId_.end() )
+
762 {
+
763 loadId = network.AddLoadAt( mapBusName2VertexId_[ splitted[ busColumn ].toStdString() ], vertex );
+
764 } else {
+
765 ESSENTIAL_ASSERT( false && "Bus name does not exist" );
+
766 }
+
767
+
768 if ( mapLoadName2Identifier_.find( vertex.Name() ) == mapLoadName2Identifier_.end() ) {
+
769 mapLoadName2Identifier_[vertex.Name()] = loadId;
+
770 } else {
+
771 ESSENTIAL_ASSERT( false && "Load name duplicates" );
+
772 }
+
773
+
774 } // while
+
+
775 return true;
+
776 }
+
777
+
796 inline void SetLoadDefaultValues ( TLoadProperties & vertex )
+
797 {
+
798 vertex.Type() = Vertices::IeeeBusType::load;
+
799 }
+
800
+
816 inline bool ReadNetwork( TNetwork & network )
+
817 {
+
818 throw std::runtime_error ( "Not implemented yet! Storage units are currently unsupported." );
+
819 return true;
+
820 }
+
821
+
+
836 inline bool ReadSnapshots( TNetwork & network )
+
837 {
+
838 throw std::runtime_error ( "Not implemented yet! Snapshots weightings are currently unsupported." );
+
839 // if ( !splitted[0].empty() )
+
840 // {
+
841 // ++ snapshotsSize;
+
842 // }
+
843 return true;
+
844 }
+
+
845
+
854 inline bool ReadCompleteNetwork ( TNetwork & network
+
855 , std::string const & filename )
+
856 {
+
857 network.BaseMva() = 1.0;
+
858 return ReadBuses ( network, filename )
+
859 && ReadGenerators ( network, filename )
+
860 && ReadGeneratorsRealPowerMaxPu ( network, filename )
+
861 && ReadLines ( network.Graph(), filename )
+
862 && ReadLoads ( network, filename )
+
863 && ReadLoadsPset ( network, filename )
+
864 && HasCorrectSnapshotSizes()
+
865 && IO::Helper::HasNetworkCorrectBounds<TNetwork> ( network );
+
866 }
+
867
+
877 inline bool ReadCompleteNetwork ( TNetwork & network
+
878 , TGraph & candidateNetwork
+
879 , std::string const & filename )
+
880 {
+
881 network.BaseMva() = 1.0;
+
882 bool booleanBuses = ReadBuses ( network, filename );
+
883 candidateNetwork = network.Graph();
+
884
+
885 return booleanBuses
+
886 && ReadGenerators ( network, filename )
+
887 && ReadGeneratorsRealPowerMaxPu ( network, filename )
+
888 && ReadLines ( network, filename )
+
889 && ReadLines<TGraph> ( candidateNetwork, filename )
+
890 && ReadLoads ( network, filename )
+
891 && ReadLoadsPset ( network, filename )
+
892 && HasCorrectSnapshotSizes()
+
893 && IO::Helper::HasNetworkCorrectBounds<TNetwork> ( network )
+
894 && IO::Helper::HasGraphCorrectBounds<TGraph> ( candidateNetwork );
+
895 }
+
897
+
898 public:
+
901#pragma mark READER
+
902
+
911 bool read ( TNetwork & network
+
912 , std::string const & filename )
+
913 {
+
914 return ReadCompleteNetwork ( network, filename );
+
915 }
+
916
+
926 bool read ( TNetwork & network
+
927 , TGraph & candidateNetwork
+
928 , std::string const & filename )
+
929 {
+
930 return ReadCompleteNetwork ( network, candidateNetwork, filename );
+
931 }
+
933
+
934 private:
+
937#pragma mark AUXILIARY
+
938
+
949 template<typename Graph = TNetwork>
+
950 inline Types::vertexId AddVertex ( Graph & network
+
951 , TVertexProperties const & vertexProperties )
+
952 {
+
953 return internal::NetworkDifferentiation<TVertexProperties, TEdgeProperties, Graph>::AddVertex ( network
+
954 , vertexProperties );
+
955 }
+
956
+
+
967 template<typename Graph = TNetwork>
+
968 inline Types::edgeId AddEdge ( Graph & network
+
969 , TIoEdge const & ioEdge )
+
+
970 {
+
971 return internal::NetworkDifferentiation<TVertexProperties, TEdgeProperties, Graph>::AddEdge ( network
+
972 , ioEdge );
+
973 }
+
974
+
984 inline QList<QByteArray> ReadLine ( QFile & file
+
985 , bool compress = true )
+
986 {
+
987 QByteArray line = file.readLine();
+
988 if ( compress ) CompressString( line);
+
989 line = line.trimmed();
+
990 return line.split(',');
+
991 }
+
992
+
998 inline void CompressString ( QByteArray & list )
+
999 {
+
1000 list = list.replace(" ","");
+
1001 }
+
1002
+
1010 inline bool OpenFile ( QFile & file )
+
1011 {
+
1012 if (!file.open(QIODevice::ReadOnly))
+
1013 {
+
1014 qDebug() << file.errorString();
+
1015 return false; // TODO throw exception
+
1016 }
+
1017 return true;
+
1018 }
+
1019
+
1025 inline bool HasCorrectSnapshotSizes()
+
1026 {
+
1027 USAGE_ASSERT ( generatorSnapshotsSize == loadSnapshotsSize );
+
1028 return (generatorSnapshotsSize == loadSnapshotsSize);
+
1029 }
+
1031
+
1034#pragma mark EXTRACT_HEADER
+
1035
+
1046 inline bool ExtractBusHeader( QList<QByteArray> const & splitted )
+
1047 {
+
1048 for ( Types::count counter = 0
+
1049 ; counter < static_cast<Types::count>( splitted.size() )
+
1050 ; ++counter )
+
1051 {
+
1052 if ( splitted[counter] == "name" )
+
1053 {
+
1054 dataMapperBuses_.emplace_back( &PyPsaParser::AddBusName );
+
1055 } else if ( splitted[counter] == "v_nom" )
+
1056 {
+
1057 dataMapperBuses_.emplace_back( &PyPsaParser::AddNominalVoltageToVertexProperty );
+
1058 } else if ( splitted[counter] == "x" )
+
1059 {
+
1060 dataMapperBuses_.emplace_back( &PyPsaParser::AddXcoordinateToVertexProperty );
+
1061 } else if ( splitted[counter] == "y" )
+
1062 {
+
1063 dataMapperBuses_.emplace_back( &PyPsaParser::AddYcoordinateToVertexProperty );
+
1064 } else if ( splitted[counter] == "carrier" )
+
1065 {
+
1066 dataMapperBuses_.emplace_back( &PyPsaParser::AddCarrierToVertexProperty );
+
1067 } else if ( splitted[counter] == "country" )
+
1068 {
+
1069 dataMapperBuses_.emplace_back( &PyPsaParser::AddCountryToVertexProperty );
+
1070 } else if ( splitted[counter] == "v_mag_pu_set" )
+
1071 {
+
1072 dataMapperBuses_.emplace_back( &PyPsaParser::AddVoltageMagnitudePuSetPointToVertexProperty );
+
1073 } else if ( splitted[counter] == "v_mag_pu_min" )
+
1074 {
+
1075 dataMapperBuses_.emplace_back( &PyPsaParser::AddMinimumVoltageMagnitudePuToVertexProperty );
+
1076 } else if ( splitted[counter] == "v_mag_pu_max" )
+
1077 {
+
+
1078 dataMapperBuses_.emplace_back( &PyPsaParser::AddMaximumVoltageMagnitudePuToVertexProperty );
+
1079 } else if ( splitted[counter] == "control" )
+
1080 {
+
1081 dataMapperBuses_.emplace_back( &PyPsaParser::AddControlTypeToVertexProperty );
+
1082 } else if ( splitted[counter] == "sub_network" )
+
1083 {
+
1084 dataMapperBuses_.emplace_back( &PyPsaParser::AddSubnetworkToVertexProperty );
+
1085 } else if ( splitted[counter] == "p" )
+
1086 {
+
+
1087 dataMapperBuses_.emplace_back( &PyPsaParser::AddRealPowerToVertexProperty );
+
1088 } else if ( splitted[counter] == "q" )
+
1089 {
+
1090 dataMapperBuses_.emplace_back( &PyPsaParser::AddReactivePowerToVertexProperty );
+
1091 } else if ( splitted[counter] == "v_mag_pu" )
+
1092 {
+
1093 dataMapperBuses_.emplace_back( &PyPsaParser::AddVoltageMagnitudePuToVertexProperty );
+
1094 } else if ( splitted[counter] == "v_ang" )
+
1095 {
+
1096 dataMapperBuses_.emplace_back( &PyPsaParser::AddVoltageAngleToVertexProperty );
+
1097 } else if ( splitted[counter] == "marginal_price" )
+
1098 {
+
1099 dataMapperBuses_.emplace_back( &PyPsaParser::AddMarginalPriceToVertexProperty );
+
1100 } // if
+
1101 } // for
+
1102
+
1103 return true;
+
1104 }
+
1105
+
1116 inline bool ExtractLineHeader( QList<QByteArray> const & splitted )
+
1117 {
+
1118 for ( Types::count counter = 0
+
1119 ; counter < static_cast<Types::count>( splitted.size() )
+
1120 ; ++counter )
+
1121 {
+
+
1122 if ( splitted[counter] == "name" )
+
1123 {
+
1124 dataMapperLines_.emplace_back( &PyPsaParser::AddNameToEdge );
+
1125 } else if ( splitted[counter] == "bus0" )
+
1126 {
+
1127 dataMapperLines_.emplace_back( &PyPsaParser::AddSourceVertexToEdge );
+
1128 } else if ( splitted[counter] == "bus1" )
+
1129 {
+
1130 dataMapperLines_.emplace_back( &PyPsaParser::AddTargetVertexToEdge );
+
1131 } else if ( splitted[counter] == "capital_cost" )
+
+
1132 {
+
1133 dataMapperLines_.emplace_back( &PyPsaParser::AddCapitalCostToEdge );
+
1134 } else if ( splitted[counter] == "length" )
+
1135 {
+
1136 dataMapperLines_.emplace_back( &PyPsaParser::AddLengthToEdge );
+
1137 } else if ( splitted[counter] == "num_parallel" )
+
1138 {
+
1139 dataMapperLines_.emplace_back( &PyPsaParser::AddNumberOfParallelLinesToEdge );
+
1140 } else if ( splitted[counter] == "s_max_pu" )
+
1141 {
+
1142 dataMapperLines_.emplace_back( &PyPsaParser::AddMaximumApparentPowerPuToEdge );
+
1143 } else if ( splitted[counter] == "s_nom" )
+
1144 {
+
1145 dataMapperLines_.emplace_back( &PyPsaParser::AddNominalApparentPowerToEdge );
+
1146 } else if ( splitted[counter] == "type" )
+
1147 {
+
1148 dataMapperLines_.emplace_back( &PyPsaParser::AddLineTypeToEdge );
+
1149 } else if ( splitted[counter] == "v_nom" )
+
1150 {
+
1151 dataMapperLines_.emplace_back( &PyPsaParser::AddNominalVoltageToEdge );
+
1152 } else if ( splitted[counter] == "s_nom_min" )
+
1153 {
+
1154 dataMapperLines_.emplace_back( &PyPsaParser::AddMinimumNominalApparentPowerToEdge );
+
1155 } else if ( splitted[counter] == "s_nom_max" )
+
1156 {
+
1157 dataMapperLines_.emplace_back( &PyPsaParser::AddMaximalNominalApparentPowerToEdge );
+
1158 } else if ( splitted[counter] == "x" )
+
1159 {
+
1160 dataMapperLines_.emplace_back( &PyPsaParser::AddReactanceToEdge );
+
1161 } else if ( splitted[counter] == "r" )
+
1162 {
+
1163 dataMapperLines_.emplace_back( &PyPsaParser::AddResistanceToEdge );
+
1164 } else if ( splitted[counter] == "g" )
+
1165 {
+
1166 dataMapperLines_.emplace_back( &PyPsaParser::AddConductanceToEdge );
+
1167 } else if ( splitted[counter] == "b" )
+
+
1168 {
+
1169 dataMapperLines_.emplace_back( &PyPsaParser::AddSusceptanceToEdge );
+
1170 } else if ( splitted[counter] == "s_nom_extendable" )
+
1171 {
+
1172 dataMapperLines_.emplace_back( &PyPsaParser::AddNominalExtendableApparentPowerToEdge );
+
1173 } else if ( splitted[counter] == "terrain_factor" )
+
1174 {
+
1175 dataMapperLines_.emplace_back( &PyPsaParser::AddTerrainFactorToEdge );
+
+
1176 } else if ( splitted[counter] == "v_ang_min" )
+
1177 {
+
1178 dataMapperLines_.emplace_back( &PyPsaParser::AddMinimumVoltageAngleToEdge );
+
1179 } else if ( splitted[counter] == "v_ang_max" )
+
1180 {
+
1181 dataMapperLines_.emplace_back( &PyPsaParser::AddMaximumVoltageAngleToEdge );
+
1182 }
+
1183 // [out]
+
1184 else if ( splitted[counter] == "sub_network" )
+
1185 {
+
1186 dataMapperLines_.emplace_back( &PyPsaParser::AddSubnetworkToEdge );
+
1187 } else if ( splitted[counter] == "p0" )
+
1188 {
+
1189 dataMapperLines_.emplace_back( &PyPsaParser::AddP0ToEdge );
+
1190 } else if ( splitted[counter] == "q0" )
+
1191 {
+
1192 dataMapperLines_.emplace_back( &PyPsaParser::AddQ0ToEdge );
+
1193 } else if ( splitted[counter] == "p1" )
+
1194 {
+
1195 dataMapperLines_.emplace_back( &PyPsaParser::AddP1ToEdge );
+
1196 } else if ( splitted[counter] == "q1" )
+
1197 {
+
1198 dataMapperLines_.emplace_back( &PyPsaParser::AddQ1ToEdge );
+
1199 } else if ( splitted[counter] == "x_pu" )
+
1200 {
+
1201 dataMapperLines_.emplace_back( &PyPsaParser::AddReactancePuToEdge );
+
1202 } else if ( splitted[counter] == "r_pu" )
+
1203 {
+
1204 dataMapperLines_.emplace_back( &PyPsaParser::AddResistancePuToEdge );
+
1205 } else if ( splitted[counter] == "g_pu" )
+
1206 {
+
1207 dataMapperLines_.emplace_back( &PyPsaParser::AddConductancePuToEdge );
+
1208 } else if ( splitted[counter] == "b_pu" )
+
1209 {
+
+
1210 dataMapperLines_.emplace_back( &PyPsaParser::AddSusceptancePuToEdge );
+
1211 } else if ( splitted[counter] == "x_pu_eff" )
+
1212 {
+
1213 dataMapperLines_.emplace_back( &PyPsaParser::AddEffectiveReactancePuToEdge );
+
1214 } else if ( splitted[counter] == "r_pu_eff" )
+
1215 {
+
1216 dataMapperLines_.emplace_back( &PyPsaParser::AddEffectiveResistancePuToEdge );
+
1217 } else if ( splitted[counter] == "s_nom_opt" )
+
1218 {
+
1219 dataMapperLines_.emplace_back( &PyPsaParser::AddOptimalNominalApparentPowerToEdge );
+
1220 } else if ( splitted[counter] == "mu_lower" )
+
1221 {
+
1222 dataMapperLines_.emplace_back( &PyPsaParser::AddMuLowerToEdge );
+
1223 } else if ( splitted[counter] == "mu_upper" )
+
1224 {
+
1225 dataMapperLines_.emplace_back( &PyPsaParser::AddMuUpperToEdge );
+
1226 } // if
+
1227 } // for
+
1228 return true;
+
1229 }
+
1230
+
1241 inline bool ExtractGeneratorHeader( QList<QByteArray> const & splitted )
+
1242 {
+
1243 for ( Types::count counter = 0
+
1244 ; counter < static_cast<Types::count>( splitted.size() )
+
1245 ; ++counter )
+
1246 {
+
1247 if ( splitted[counter] == "name" )
+
1248 {
+
1249 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNameToGenerator );
+
1250 } else if ( splitted[counter] == "bus" )
+
1251 {
+
1252 dataMapperGenerators_.emplace_back( &PyPsaParser::AssociateGeneratorWithBus );
+
1253 } else if ( splitted[counter] == "control" )
+
1254 {
+
1255 dataMapperGenerators_.emplace_back( &PyPsaParser::AddControlTypeToGenerator );
+
1256 } else if ( splitted[counter] == "type" )
+
1257 {
+
+
1258 dataMapperGenerators_.emplace_back( &PyPsaParser::AddTypeToGenerator );
+
1259 } else if ( splitted[counter] == "efficiency" )
+
1260 {
+
1261 dataMapperGenerators_.emplace_back( &PyPsaParser::AddGeneratorEfficiencyToGenerator );
+
1262 } else if ( splitted[counter] == "p_nom" )
+
+
1263 {
+
1264 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNominalRealPowerToGenerator );
+
1265 } else if ( splitted[counter] == "p_nom_extendable" )
+
1266 {
+
1267 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNominalRealPowerToGeneratorExtendable );
+
1268 } else if ( splitted[counter] == "p_nom_min" )
+
1269 {
+
+
1270 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNominalRealPowerToGeneratorMin );
+
1271 } else if ( splitted[counter] == "p_nom_max" )
+
1272 {
+
1273 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNominalRealPowerToGeneratorMax );
+
1274 } else if ( splitted[counter] == "p_min_pu" )
+
1275 {
+
1276 dataMapperGenerators_.emplace_back( &PyPsaParser::AddMinimumRealPowerPuToGenerator );
+
1277 } else if ( splitted[counter] == "p_max_pu" )
+
1278 {
+
1279 dataMapperGenerators_.emplace_back( &PyPsaParser::AddMaximumRealPowerPuToGenerator );
+
1280 } else if ( splitted[counter] == "p_set" )
+
1281 {
+
1282 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRealPowerSetPointToGenerator );
+
+
1283 } else if ( splitted[counter] == "q_set" )
+
1284 {
+
1285 dataMapperGenerators_.emplace_back( &PyPsaParser::AddReactivePowerSetPointToGenerator );
+
1286 } else if ( splitted[counter] == "sign" )
+
1287 {
+
1288 dataMapperGenerators_.emplace_back( &PyPsaParser::AddGeneratorSignToGenerator );
+
1289 } else if ( splitted[counter] == "carrier" )
+
1290 {
+
1291 dataMapperGenerators_.emplace_back( &PyPsaParser::AddCarrierToGenerator );
+
1292 } else if ( splitted[counter] == "marginal_cost" )
+
1293 {
+
+
1294 dataMapperGenerators_.emplace_back( &PyPsaParser::AddMarginalCostToGenerator );
+
1295 } else if ( splitted[counter] == "capital_cost" )
+
1296 {
+
1297 dataMapperGenerators_.emplace_back( &PyPsaParser::AddCapitalCostToGenerator );
+
1298 } else if ( splitted[counter] == "committable" )
+
1299 {
+
1300 dataMapperGenerators_.emplace_back( &PyPsaParser::AddCommittabilityToGenerator );
+
1301 } else if ( splitted[counter] == "start_up_cost" )
+
+
1302 {
+
1303 dataMapperGenerators_.emplace_back( &PyPsaParser::AddStartUpCostToGenerator );
+
1304 } else if ( splitted[counter] == "shut_down_cost" )
+
1305 {
+
1306 dataMapperGenerators_.emplace_back( &PyPsaParser::AddShutDownCostToGenerator );
+
1307 } else if ( splitted[counter] == "min_up_time" )
+
1308 {
+
+
1309 dataMapperGenerators_.emplace_back( &PyPsaParser::AddMinimumUpTimeToGenerator );
+
1310 } else if ( splitted[counter] == "min_down_time" )
+
1311 {
+
1312 dataMapperGenerators_.emplace_back( &PyPsaParser::AddMinimumDownTimeToGenerator );
+
1313 } else if ( splitted[counter] == "initial_status" )
+
1314 {
+
1315 dataMapperGenerators_.emplace_back( &PyPsaParser::AddInitialStatusToGenerator );
+
1316 } else if ( splitted[counter] == "ramp_limit_up" )
+
+
1317 {
+
1318 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRampLimitUpToGenerator );
+
1319 } else if ( splitted[counter] == "ramp_limit_down" )
+
1320 {
+
1321 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRampLimitDownToGenerator );
+
1322 } else if ( splitted[counter] == "ramp_limit_start_up" )
+
1323 {
+
+
1324 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRampLimitStartUpToGenerator );
+
1325 } else if ( splitted[counter] == "ramp_limit_shut_down" )
+
1326 {
+
1327 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRampLimitShutDownToGenerator );
+
1328 }
+
1329 // [out]
+
1330 else if ( splitted[counter] == "p" )
+
1331 {
+
+
1332 dataMapperGenerators_.emplace_back( &PyPsaParser::AddRealPowerToGenerator );
+
1333 } else if ( splitted[counter] == "q" )
+
1334 {
+
1335 dataMapperGenerators_.emplace_back( &PyPsaParser::AddReactivePowerToGenerator );
+
1336 } else if ( splitted[counter] == "p_nom_opt" )
+
1337 {
+
1338 dataMapperGenerators_.emplace_back( &PyPsaParser::AddNominalRealPowerToGeneratorOpt );
+
+
1339 } else if ( splitted[counter] == "status" )
+
1340 {
+
1341 dataMapperGenerators_.emplace_back( &PyPsaParser::AddStatusToGenerator );
+
1342 } else if ( splitted[counter] == "weight" )
+
1343 {
+
1344 dataMapperGenerators_.emplace_back( &PyPsaParser::AddWeightToGenerator );
+
1345 } // if
+
1346 } // for
+
+
1347 return true;
+
1348 }
+
1349
+
1358 inline bool ExtractGeneratorMaximumRealPowerPuHeader( QList<QByteArray> const & splitted )
+
1359 {
+
1360 for ( Types::count counter = 0
+
1361 ; counter < static_cast<Types::count>( splitted.size() )
+
1362 ; ++counter )
+
1363 {
+
1364 if ( splitted[counter] == "name" )
+
1365 {
+
1366 dataMapperGeneratorsRealPowerMaxPu_.emplace_back (
+
1367 std::bind ( & PyPsaParser::AddTimestampOfGenerator
+
1368 , this
+
+
1369 , std::placeholders::_1 // input string
+
1370 , std::placeholders::_2 // network
+
1371 )
+
1372 );
+
1373 } else
+
1374 {
+
1375 std::string generatorName = splitted[counter].trimmed().toStdString();
+
1376 // dataMapperGeneratorsRealPowerMaxPu_.emplace_back( std::bind(&PyPsaParser::AddMaximumRealPowerSnapshotPuToGenerator, std::placeholders::_1, mapGeneratorName2Generator_[generatorName]) );
+
1377
+
1378 if ( mapGeneratorName2Identifier_.find(generatorName) == mapGeneratorName2Identifier_.end() )
+
1379 {
+
1380 ESSENTIAL_ASSERT( false && "Generator name does not exist" );
+
1381 }
+
+
1382
+
1383 dataMapperGeneratorsRealPowerMaxPu_.emplace_back (
+
1384 std::bind ( & PyPsaParser::AddMaximumRealPowerSnapshotPuToGenerator
+
1385 , this
+
1386 , std::placeholders::_1 // input string
+
1387 , std::placeholders::_2 // network
+
1388 , mapGeneratorName2Identifier_[generatorName] ) ); // identifier
+
+
1389 }
+
1390 } // for
+
1391 return true;
+
1392 }
+
1393
+
+
1403 inline bool ExtractLoadHeader ( QList<QByteArray> const & splitted
+
1404 , Types::index & column )
+
1405 {
+
1406 for ( Types::count counter = 0
+
1407 ; counter < static_cast<Types::count>( splitted.size() )
+
1408 ; ++counter )
+
+
1409 {
+
1410 if ( splitted[counter] == "name" )
+
1411 {
+
1412 dataMapperLoads_.emplace_back( &PyPsaParser::AddNameToLoad );
+
1413 } else if ( splitted[counter] == "bus" )
+
1414 {
+
1415 dataMapperLoads_.emplace_back( &PyPsaParser::AssociateLoadWithVertex );
+
1416 column = counter;
+
1417 } else if ( splitted[counter] == "type" )
+
1418 {
+
1419 dataMapperLoads_.emplace_back( &PyPsaParser::AddTypeToLoad );
+
1420 } else if ( splitted[counter] == "p_set" )
+
1421 {
+
+
1422 dataMapperLoads_.emplace_back( &PyPsaParser::AddRealPowerSetPointToLoad );
+
1423 } else if ( splitted[counter] == "q_set" )
+
1424 {
+
1425 dataMapperLoads_.emplace_back( &PyPsaParser::AddReactivePowerSetPointToLoad );
+
1426 } else if ( splitted[counter] == "sign" )
+
1427 {
+
1428 dataMapperLoads_.emplace_back( &PyPsaParser::AddSignToLoad );
+
1429 } else if ( splitted[counter] == "p" )
+
1430 {
+
1431 dataMapperLoads_.emplace_back( &PyPsaParser::AddRealPowerToLoad );
+
1432 } else if ( splitted[counter] == "q" )
+
1433 {
+
1434 dataMapperLoads_.emplace_back( &PyPsaParser::AddReactivePowerToLoad );
+
1435 }
+
+
1436 } // for
+
1437 return true;
+
1438 }
+
1439
+
+
1447 inline bool ExtractLoadMaximumRealPowerPuHeader( QList<QByteArray> const & splitted )
+
1448 {
+
1449 for ( Types::count counter = 0
+
1450 ; counter < static_cast<Types::count>( splitted.size() )
+
1451 ; ++counter )
+
1452 {
+
+
1453 if ( splitted[counter] == "name" )
+
1454 {
+
1455 dataMapperLoadsRealPowerMaxPu_.emplace_back(
+
1456 std::bind ( &PyPsaParser::AddLoadTimestampName
+
1457 , this
+
1458 , std::placeholders::_1 // input string
+
1459 , std::placeholders::_2 // network
+
1460 )
+
1461 );
+
1462 } else
+
1463 {
+
1464 std::string loadName = splitted[counter].toStdString();
+
1465
+
+
1466 if ( mapLoadName2Identifier_.find(loadName) == mapLoadName2Identifier_.end() )
+
1467 {
+
1468 ESSENTIAL_ASSERT( false && "Load name does not exist" );
+
1469 }
+
1470
+
1471 dataMapperLoadsRealPowerMaxPu_.emplace_back(
+
1472 std::bind ( &PyPsaParser::AddMaximumRealPowerSnapshotPuToLoad
+
1473 , this
+
1474 , std::placeholders::_1 // input string
+
+
1475 , std::placeholders::_2 // network
+
1476 , mapLoadName2Identifier_[loadName] ) ); // identifier
+
1477 }
+
1478 } // for
+
1479 return true;
+
1480 }
+
1482
+
1483#pragma mark FUNCTION_POINTER_VECTOR_WITH_FUNCTION_POINTER
+
1484
+
1485 std::vector<TGeneratorProperties*> headerGeneratorMaximumRealPowerPu_;
+
+
1489 using ElectricalVertexFunc = void (PyPsaParser::*)( Types::name const &, TVertexProperties& );
+
1490
+
1491 using GeneratorVertexFunc = void (PyPsaParser::*)( Types::name const &, TGeneratorProperties& );
+
1492 using GeneratorMaximumRealPowerPuFunc = std::function<void(Types::string const &, TNetwork&)>;
+
1493
+
1494 using LoadVertexFunc = void (PyPsaParser::*)( Types::name const &, TLoadProperties& );
+
1495 using LoadMaximumRealPowerPuFunc = std::function<void(Types::string const &, TNetwork&)>;
+
1496
+
+
1497 using ElectricalEdgeFunc = void (PyPsaParser::*)( Types::name const &, TIoEdge& );
+
1499
+
1502 // std::vector<void *(*)(void *)> dataMapperStorageUnitsInflows_;
+
1503 // std::vector<void *(*)(void *)> dataMapperStorageUnits_;
+
1504 std::vector<ElectricalVertexFunc> dataMapperBuses_;
+
1505 // std::vector<ElectricalEdgeFunc> dataMapperCarrier_;
+
1506 std::vector<GeneratorMaximumRealPowerPuFunc> dataMapperGeneratorsRealPowerMaxPu_;
+
1507 std::vector<GeneratorVertexFunc> dataMapperGenerators_;
+
1508 // std::vector<void *(*)(void *)> dataMapperGlobalConstraints_;
+
1509
+
+
1510 std::vector<ElectricalEdgeFunc> dataMapperCandidateNetwork_; // dataMapperLinesNew_;
+
1511 std::vector<ElectricalEdgeFunc> dataMapperLines_;
+
1512
+
1513 std::vector<LoadVertexFunc> dataMapperLoads_;
+
1514 std::vector<LoadMaximumRealPowerPuFunc> dataMapperLoadsRealPowerMaxPu_;
+
1515 // std::vector<void *(*)(void *)> dataMapperNetwork_;
+
1516 // std::vector<void *(*)(void *)> dataMapperSnapshots_; //void *(*)(void *)
+
1518
+
1521#pragma mark BUS_DATA_EXTRACTION
+
1522
+
1529 void AddBusName ( Types::name const & name
+
1530 , TVertexProperties & vertexProperty )
+
1531 {
+
1532 vertexProperty.Name() = name;
+
1533 }
+
1534
+
+
1541 void AddNominalVoltageToVertexProperty ( Types::name const & voltageNominal
+
1542 , TVertexProperties & vertexProperty )
+
1543 {
+
1544 if ( !voltageNominal.empty() )
+
1545 {
+
1546 if ( voltageNominal.compare("inf") != 0 )
+
1547 { // not inf
+
1548 vertexProperty.NominalVoltage() = Types::String2double( voltageNominal );
+
1549 } else { //inf
+
1550 vertexProperty.NominalVoltage() = Const::REAL_INFTY;
+
1551 }
+
1552 }
+
1553 }
+
+
1554
+
1565 inline void AddBusTypeToVertexProperty ( Types::name const & type
+
1566 , TVertexProperties & vertexProperty )
+
1567 {
+
1568 if ( !type.empty() )
+
1569 {
+
1570 vertexProperty.Type() = Vertices::StringToIeeeBusType ( type );
+
1571 }
+
1572 }
+
1573
+
1580 inline void AddXcoordinateToVertexProperty ( Types::name const & xCoordinate
+
1581 , TVertexProperties & vertexProperty )
+
1582 {
+
1583 if ( !xCoordinate.empty() )
+
1584 {
+
1585 vertexProperty.X() = Types::String2double( xCoordinate );
+
1586 }
+
1587 }
+
+
1588
+
1595 inline void AddYcoordinateToVertexProperty ( Types::name const & yCoordinate
+
1596 , TVertexProperties & vertexProperty )
+
+
1597 {
+
1598 if ( !yCoordinate.empty() )
+
1599 {
+
1600 vertexProperty.Y() = Types::String2double( yCoordinate );
+
1601 }
+
1602 }
+
1603
+
1610 inline void AddCarrierToVertexProperty ( Types::name const & carrier
+
1611 , TVertexProperties & vertexProperty )
+
1612 {
+
1613 if ( !carrier.empty() )
+
1614 {
+
1615 vertexProperty.Carrier() = Vertices::StringToEnergyCarrier ( carrier );
+
1616 }
+
1617 }
+
1618
+
1625 inline void AddCountryToVertexProperty ( Types::name const & country
+
1626 , TVertexProperties & vertexProperty )
+
1627 { // used in data but not specified
+
1628 if ( !country.empty() )
+
1629 {
+
1630 vertexProperty.Country() = country;
+
1631 }
+
1632 }
+
1633
+
1640 inline void AddVoltageMagnitudePuSetPointToVertexProperty ( Types::name const & voltageMagnitudePuSetpoint
+
1641 , TVertexProperties & vertexProperty )
+
1642 {
+
1643 if ( !voltageMagnitudePuSetpoint.empty() )
+
1644 {
+
1645 if ( voltageMagnitudePuSetpoint.compare("inf") != 0 )
+
1646 { // not inf
+
1647 vertexProperty.VoltageMagnitude() = Types::String2double( voltageMagnitudePuSetpoint );
+
1648 } else { //inf
+
1649 vertexProperty.VoltageMagnitude() = Const::REAL_INFTY;
+
1650 }
+
1651 }
+
1652 }
+
1653
+
1660 inline void AddMinimumVoltageMagnitudePuToVertexProperty ( Types::name const & voltageMagnitudePuMinimum
+
1661 , TVertexProperties & vertexProperty )
+
1662 {
+
1663 if ( !voltageMagnitudePuMinimum.empty() )
+
1664 { /* vertex voltageMagnitudePuMinimum */
+
1665 if ( voltageMagnitudePuMinimum.compare("inf") != 0 )
+
1666 { // not inf
+
1667 vertexProperty.MinimumVoltage() = Types::String2double( voltageMagnitudePuMinimum );
+
1668 } else { //inf
+
1669 vertexProperty.MinimumVoltage() = Const::REAL_INFTY;
+
1670 }
+
1671 }
+
1672 }
+
1673
+
+
1680 inline void AddMaximumVoltageMagnitudePuToVertexProperty ( Types::name const & voltageMagnitudePuMaximum
+
1681 , TVertexProperties & vertexProperty )
+
1682 {
+
1683 if ( !voltageMagnitudePuMaximum.empty() )
+
1684 { /* vertex voltageMagnitudePuMaximum */
+
1685 if ( voltageMagnitudePuMaximum.compare("inf") != 0 )
+
1686 { // not inf
+
1687 vertexProperty.MaximumVoltage() = Types::String2double( voltageMagnitudePuMaximum );
+
+
1688 } else { //inf
+
1689 vertexProperty.MaximumVoltage() = Const::REAL_INFTY;
+
1690 }
+
1691 }
+
1692 }
+
1694
+
1697#pragma mark BUS_DATA_OUTPUT
+
1698
+
1707 inline void AddControlTypeToVertexProperty ( Types::string const & control
+
1708 , TVertexProperties & vertexProperty )
+
1709 {
+
1710 if ( !control.empty() )
+
1711 { /* vertex control */
+
1712 vertexProperty.Control() = Vertices::StringToControlType ( control );
+
1713 }
+
1714 }
+
+
1715
+
1724 inline void AddSubnetworkToVertexProperty ( Types::name const & subnetwork
+
1725 , TVertexProperties & vertexProperty )
+
1726 {
+
1727 if ( !subnetwork.empty() )
+
+
1728 {
+
1729 if ( subnetwork.compare("inf") != 0 )
+
1730 { // not inf
+
1731 /* vertex subnetwork */
+
1732 } else { //inf
+
1733 /* vertex subnetwork */
+
1734 }
+
+
1735 }
+
1736 }
+
1737
+
1746 inline void AddRealPowerToVertexProperty ( Types::name const & realPower
+
1747 , TVertexProperties & vertexProperty )
+
+
1748 {
+
1749 if ( !realPower.empty() )
+
1750 {
+
1751 if ( realPower.compare("inf") != 0 )
+
1752 { // not inf
+
1753 /* vertex.RealPowerLoad() = Types::String2double( realPower ); */
+
1754 } else { //inf
+
+
1755 /* vertex.RealPowerLoad() = Types::String2double( realPower ); */
+
1756 }
+
1757 }
+
1758 }
+
1759
+
+
1768 inline void AddReactivePowerToVertexProperty ( Types::name const & reactivePower
+
1769 , TVertexProperties & vertexProperty )
+
1770 {
+
1771 if ( !reactivePower.empty() )
+
1772 {
+
1773 if ( reactivePower.compare("inf") != 0 )
+
1774 { // not inf
+
+
1775 /*vertex.ReactivePowerLoad() = Types::String2double( reactivePower ); */
+
1776 } else { //inf
+
1777 /*vertex.ReactivePowerLoad() = Types::String2double( reactivePower ); */
+
1778 }
+
1779 }
+
1780 }
+
1781
+
+
1790 inline void AddVoltageMagnitudePuToVertexProperty ( Types::name const & voltageMagnitudePu
+
1791 , TVertexProperties & vertexProperty )
+
1792 {
+
1793 if ( !voltageMagnitudePu.empty() )
+
1794 {
+
+
1795 if ( voltageMagnitudePu.compare("inf") != 0 )
+
1796 { // not inf
+
1797 /* vertex.VoltageMagnitude() = voltageMagnitudePu; */
+
1798 } else { //inf
+
1799 /* vertex.VoltageMagnitude() = voltageMagnitudePu; */
+
1800 }
+
1801 }
+
1802 }
+
1803
+
+
1812 inline void AddVoltageAngleToVertexProperty ( Types::name const & voltageAngle
+
1813 , TVertexProperties & vertexProperty )
+
1814 {
+
+
1815 if ( !voltageAngle.empty() )
+
1816 {
+
1817 if ( voltageAngle.compare("inf") != 0 )
+
1818 { // not inf
+
1819 vertexProperty.VoltageAngle() = Types::String2double( voltageAngle );
+
1820 } else { //inf
+
1821 vertexProperty.VoltageAngle() = Const::REAL_INFTY;
+
1822 }
+
1823 }
+
1824 }
+
1825
+
+
1834 inline void AddMarginalPriceToVertexProperty ( Types::name const & marginalPrice
+
+
1835 , TVertexProperties & vertex )
+
1836 {
+
1837 if ( !marginalPrice.empty() )
+
1838 {
+
1839 if ( marginalPrice.compare("inf") != 0 )
+
1840 { // not inf
+
1841 /* marginalPrice */
+
1842 } else { //inf
+
1843 /* marginalPrice */
+
1844 }
+
1845 }
+
1846 }
+
1848
+
+
1851#pragma mark GENERATOR_DATA_EXTRACTION
+
1852
+
1859 inline void AddControlTypeToGenerator ( Types::string const & control
+
1860 , TGeneratorProperties & generatorProperty )
+
1861 {
+
1862 generatorProperty.Control() = Vertices::StringToControlType ( control );
+
1863 if ( Vertices::ControlType::unknown == generatorProperty.Control() )
+
1864 {
+
1865 generatorProperty.Control() = Vertices::ControlType::PQ;
+
1866 }
+
1867 }
+
1868
+
1875 inline void AddNominalRealPowerToGenerator ( Types::string const & pNom
+
1876 , TGeneratorProperties & generatorProperty )
+
1877 {
+
1878 if ( Types::String2double( pNom ) != 0 )
+
1879 {
+
1880 generatorProperty.NominalPower() = Types::String2double( pNom );
+
1881 } else {
+
1882 generatorProperty.NominalPower() = 1;
+
1883 }
+
1884 }
+
1885
+
+
1892 inline void AddNominalRealPowerToGeneratorExtendable ( Types::string const & pNomExtendable
+
1893 , TGeneratorProperties & generatorProperty )
+
1894 {
+
1895 if ( pNomExtendable == "TRUE" )
+
1896 {
+
1897 generatorProperty.IsExtendable() = true;
+
1898 } else {
+
1899 generatorProperty.IsExtendable() = false;
+
1900 }
+
1901 }
+
1902
+
+
1909 inline void AddNameToGenerator ( Types::name const & name
+
1910 , TGeneratorProperties & generatorProperty )
+
1911 {
+
1912 generatorProperty.Name() = name;
+
1913 if ( mapGeneratorName2Generator_.find ( generatorProperty.Name() )
+
1914 == mapGeneratorName2Generator_.end() )
+
1915 {
+
1916 mapGeneratorName2Generator_[generatorProperty.Name()] = generatorProperty;
+
1917 } else {
+
1918 ESSENTIAL_ASSERT( false && "Generator duplicates" );
+
+
1919 }
+
1920 }
+
1921
+
1928 inline void AssociateGeneratorWithBus ( Types::name const & bus
+
+
1929 , TGeneratorProperties & generatorProperty )
+
1930 {
+
1931 if ( !bus.empty() )
+
1932 {
+
1933 if ( mapGeneratorName2BusName_.find( generatorProperty.Name() )
+
1934 == mapGeneratorName2BusName_.end() )
+
1935 {
+
+
1936 mapGeneratorName2BusName_[ generatorProperty.Name() ] = bus;
+
1937 } else {
+
1938 ESSENTIAL_ASSERT( false && "Generator duplicates" );
+
1939 }
+
1940 } else {
+
1941 USAGE_ASSERT ( false && "Generator bus is empty!" );
+
1942 }
+
1943 }
+
1944
+
+
1951 inline void AddTypeToGenerator ( Types::string const & type
+
1952 , TGeneratorProperties & generatorProperty )
+
1953 {
+
1954 if ( !type.empty() )
+
1955 {
+
+
1956 /* generator type */
+
1957 }
+
1958 }
+
1959
+
1966 inline void AddGeneratorEfficiencyToGenerator ( Types::string const & efficiency
+
1967 , TGeneratorProperties & generatorProperty )
+
1968 {
+
+
1969 if ( !efficiency.empty() )
+
1970 {
+
1971 if ( efficiency.compare("inf") != 0 )
+
1972 { // not inf
+
1973 generatorProperty.Efficiency() = Types::String2double( efficiency );
+
1974 } else { //inf
+
1975 generatorProperty.Efficiency() = Const::REAL_INFTY;
+
+
1976 }
+
1977 }
+
1978 }
+
1979
+
1986 inline void AddNominalRealPowerToGeneratorMin ( Types::string const & pNomMin
+
1987 , TGeneratorProperties & generatorProperty )
+
1988 {
+
+
1989 if ( !pNomMin.empty() )
+
1990 {
+
1991 if ( pNomMin.compare("inf") != 0 )
+
1992 { // not inf
+
1993 generatorProperty.NominalRealPowerBound().Minimum() = Types::String2double( pNomMin );
+
1994 } else { //inf
+
1995 generatorProperty.NominalRealPowerBound().Minimum() = Const::REAL_INFTY;
+
+
1996 }
+
1997 }
+
1998 }
+
1999
+
2006 inline void AddNominalRealPowerToGeneratorMax ( Types::string const & pNomMax
+
2007 , TGeneratorProperties & generatorProperty )
+
2008 {
+
+
2009 if ( !pNomMax.empty() )
+
2010 {
+
2011 if ( pNomMax.compare("inf") != 0 )
+
2012 { // not inf
+
2013 generatorProperty.NominalRealPowerBound().Maximum() = Types::String2double( pNomMax );
+
2014 } else { //inf
+
2015 generatorProperty.NominalRealPowerBound().Maximum() = Const::REAL_INFTY;
+
+
2016 }
+
2017 }
+
2018 }
+
2019
+
2026 inline void AddMinimumRealPowerPuToGenerator ( Types::string const & pMinPu
+
2027 , TGeneratorProperties & generatorProperty )
+
+
2028 {
+
2029 if ( !pMinPu.empty() )
+
2030 {
+
2031 if ( pMinPu.compare("inf") != 0 )
+
2032 { // not inf
+
2033 generatorProperty.RealPowerBound().Minimum() = Types::String2double( pMinPu );
+
2034 } else { //inf
+
+
2035 generatorProperty.RealPowerBound().Minimum() = Const::REAL_INFTY;
+
2036 }
+
2037 }
+
2038 }
+
2039
+
2046 inline void AddMaximumRealPowerPuToGenerator ( Types::string const & pMaxPu
+
2047 , TGeneratorProperties & generatorProperty )
+
+
2048 {
+
2049 if ( !pMaxPu.empty() )
+
2050 {
+
2051 if ( pMaxPu.compare("inf") != 0 )
+
2052 { // not inf
+
2053 generatorProperty.RealPowerBound().Maximum() = Types::String2double( pMaxPu );
+
2054 } else { //inf
+
+
2055 generatorProperty.RealPowerBound().Maximum() = Const::REAL_INFTY;
+
2056 }
+
2057 }
+
2058 }
+
2059
+
2066 inline void AddRealPowerSetPointToGenerator ( Types::string const & pSet
+
2067 , TGeneratorProperties & generatorProperty )
+
+
2068 {
+
2069 if ( !pSet.empty() )
+
2070 {
+
2071 if ( pSet.compare("inf") != 0 )
+
2072 { // not inf
+
2073 generatorProperty.RealPower() = Types::String2double( pSet );
+
2074 } else { //inf
+
+
2075 generatorProperty.RealPower() = Const::REAL_INFTY;
+
2076 }
+
2077 }
+
2078 }
+
2079
+
2086 inline void AddReactivePowerSetPointToGenerator ( Types::string const & qSet
+
2087 , TGeneratorProperties & generatorProperty )
+
+
2088 {
+
2089 if ( !qSet.empty() )
+
2090 {
+
2091 if ( qSet.compare("inf") != 0 )
+
2092 { // not inf
+
2093 generatorProperty.ReactivePower() = Types::String2double( qSet );
+
2094 } else { //inf
+
+
2095 generatorProperty.ReactivePower() = Const::REAL_INFTY;
+
2096 }
+
2097 }
+
2098 }
+
2099
+
2106 inline void AddGeneratorSignToGenerator ( Types::string const & sign
+
2107 , TGeneratorProperties & generatorProperty )
+
+
2108 {
+
2109 if ( !sign.empty() )
+
2110 {
+
2111 Types::integer powerSign = Types::String2integer( sign );
+
2112 if ( powerSign >= 0 )
+
2113 {
+
2114 generatorProperty.PowerSign() = Vertices::PowerSign::positive;
+
2115 }
+
2116 else {
+
2117 generatorProperty.PowerSign() = Vertices::PowerSign::negative;
+
2118 }
+
2119 }
+
+
2120 }
+
2121
+
2128 inline void AddCarrierToGenerator ( Types::string const & carrier
+
2129 , TGeneratorProperties & generatorProperty )
+
2130 {
+
2131 if ( !carrier.empty() )
+
2132 {
+
+
2133 generatorProperty.GeneratorType() = Vertices::StringToGeneratorType ( carrier );
+
2134 }
+
2135 }
+
2136
+
2143 inline void AddMarginalCostToGenerator ( Types::string const & marginalCost
+
2144 , TGeneratorProperties & generatorProperty )
+
2145 {
+
2146 if ( !marginalCost.empty() )
+
2147 {
+
2148 if ( marginalCost.compare("inf") != 0 )
+
2149 { // not inf
+
2150 generatorProperty.MarginalCost() = Types::String2double( marginalCost );
+
2151 } else { //inf
+
2152 generatorProperty.MarginalCost() = Const::REAL_INFTY;
+
2153 }
+
2154 }
+
2155 }
+
2156
+
2163 inline void AddCapitalCostToGenerator ( Types::string const & capitalCost
+
2164 , TGeneratorProperties & generatorProperty )
+
2165 {
+
2166 if ( !capitalCost.empty() )
+
2167 {
+
2168 if ( capitalCost.compare("inf") != 0 )
+
2169 { // not inf
+
2170 generatorProperty.CapitalCost() = Types::String2double( capitalCost );
+
2171 } else { //inf
+
2172 generatorProperty.CapitalCost() = Const::REAL_INFTY;
+
2173 }
+
2174 }
+
2175 }
+
2176
+
2190 inline void AddCommittabilityToGenerator ( Types::string const & committable
+
2191 , TGeneratorProperties & generatorProperty )
+
2192 {
+
2193 if ( committable == "True" )
+
2194 {
+
2195 generatorProperty.Committable() = true;
+
2196 } else {
+
2197 generatorProperty.Committable() = false;
+
2198 }
+
2199 }
+
+
2200
+
2207 inline void AddStartUpCostToGenerator ( Types::string const & startUpCost
+
2208 , TGeneratorProperties & generatorProperty )
+
2209 {
+
2210 if ( !startUpCost.empty() )
+
2211 {
+
2212 if ( startUpCost.compare("inf") != 0 )
+
+
2213 { // not inf
+
2214 generatorProperty.StartUpCost() = Types::String2double( startUpCost );
+
2215 } else { //inf
+
2216 generatorProperty.StartUpCost() = Const::REAL_INFTY;
+
2217 }
+
2218 }
+
2219 }
+
2220
+
2227 inline void AddShutDownCostToGenerator ( Types::string const & shutDownCost
+
+
2228 , TGeneratorProperties & generatorProperty )
+
2229 {
+
2230 if ( !shutDownCost.empty() )
+
2231 {
+
+
2232 if ( shutDownCost.compare("inf") != 0 )
+
2233 { // not inf
+
2234 generatorProperty.ShutDownCost() = Types::String2double( shutDownCost );
+
2235 } else { //inf
+
2236 generatorProperty.ShutDownCost() = Const::REAL_INFTY;
+
2237 }
+
2238 }
+
2239 }
+
2240
+
2247 inline void AddMinimumUpTimeToGenerator ( Types::string const & minUpTime
+
2248 , TGeneratorProperties & generatorProperty )
+
2249 {
+
2250 if ( !minUpTime.empty() )
+
2251 {
+
2252 if ( minUpTime.compare("inf") != 0 )
+
2253 { // not inf
+
2254 generatorProperty.MinimumUpTime() = Types::String2double( minUpTime );
+
2255 } else { //inf
+
2256 generatorProperty.MinimumUpTime() = Const::REAL_INFTY;
+
2257 }
+
2258 }
+
2259 }
+
2260
+
2267 inline void AddMinimumDownTimeToGenerator ( Types::string const & minDownTime
+
2268 , TGeneratorProperties & generatorProperty )
+
2269 {
+
2270 if ( !minDownTime.empty() )
+
2271 {
+
+
2272 if ( minDownTime.compare("inf") != 0 )
+
2273 { // not inf
+
2274 generatorProperty.MinimumDownTime() = Types::String2double( minDownTime );
+
2275 } else { //inf
+
2276 generatorProperty.MinimumDownTime() = Const::REAL_INFTY;
+
+
2277 }
+
2278 }
+
2279 }
+
2280
+
2287 inline void AddInitialStatusToGenerator ( Types::string const & initialStatus
+
2288 , TGeneratorProperties & generatorProperty )
+
2289 {
+
2290 if ( !initialStatus.empty() )
+
2291 {
+
2292 Types::index status = Types::String2integer( initialStatus );
+
2293 if ( status )
+
2294 generatorProperty.Status() = Vertices::BusStatus::active;
+
2295 else
+
2296 generatorProperty.Status() = Vertices::BusStatus::inactive;
+
2297 }
+
2298 }
+
2299
+
2306 inline void AddRampLimitUpToGenerator ( Types::string const & rampLimitUp
+
2307 , TGeneratorProperties & generatorProperty )
+
2308 {
+
2309 if ( !rampLimitUp.empty() )
+
2310 {
+
2311 if ( rampLimitUp.compare("inf") != 0 )
+
2312 { // not inf
+
2313 generatorProperty.RampLimitUp() = Types::String2double( rampLimitUp );
+
2314 } else { //inf
+
2315 generatorProperty.RampLimitUp() = Const::REAL_INFTY;
+
2316 }
+
2317 }
+
2318 }
+
2319
+
2326 inline void AddRampLimitDownToGenerator ( Types::string const & rampLimitDown
+
2327 , TGeneratorProperties & generatorProperty )
+
2328 {
+
2329 if ( !rampLimitDown.empty() )
+
2330 {
+
2331 if ( rampLimitDown.compare("inf") != 0 )
+
2332 { // not inf
+
2333 generatorProperty.RampLimitDown() = Types::String2double( rampLimitDown );
+
2334 } else { //inf
+
2335 generatorProperty.RampLimitDown() = Const::REAL_INFTY;
+
2336 }
+
2337 }
+
2338 }
+
2339
+
2346 inline void AddRampLimitStartUpToGenerator ( Types::string const & rampLimitStartUp
+
2347 , TGeneratorProperties & generatorProperty )
+
2348 {
+
2349 if ( !rampLimitStartUp.empty() )
+
2350 {
+
2351 if ( rampLimitStartUp.compare("inf") != 0 )
+
2352 { // not inf
+
2353 generatorProperty.RampLimitStartUp() = Types::String2double( rampLimitStartUp);
+
2354 } else { //inf
+
2355 generatorProperty.RampLimitStartUp() = Const::REAL_INFTY;
+
2356 }
+
2357 }
+
2358 }
+
2359
+
2366 inline void AddRampLimitShutDownToGenerator ( Types::string const & rampLimitShutDown
+
2367 , TGeneratorProperties & generatorProperty )
+
2368 {
+
2369 if ( !rampLimitShutDown.empty() )
+
2370 {
+
2371 if ( rampLimitShutDown.compare("inf") != 0 )
+
2372 { // not inf
+
2373 generatorProperty.RampLimitShutDown() = Types::String2double( rampLimitShutDown );
+
2374 } else { //inf
+
2375 generatorProperty.RampLimitShutDown() = Const::REAL_INFTY;
+
2376 }
+
2377 }
+
2378 }
+
+
2380
+
2383#pragma mark GENERATOR_DATA_OUTPUT
+
2384
+
2391 inline void AddRealPowerToGenerator ( Types::name const & realPower
+
2392 , TGeneratorProperties & generatorProperty )
+
+
2393 {
+
2394 if ( !realPower.empty() )
+
2395 {
+
2396 if ( realPower.compare("inf") != 0 )
+
2397 { // not inf
+
2398 /* realPower */
+
2399 } else { //inf
+
+
2400 /* realPower */
+
2401 }
+
2402 }
+
2403 }
+
2404
+
2411 inline void AddReactivePowerToGenerator ( Types::name const & reactivePower
+
2412 , TGeneratorProperties & generatorProperty )
+
+
2413 {
+
2414 if ( !reactivePower.empty() )
+
2415 {
+
2416 if ( reactivePower.compare("inf") != 0 )
+
2417 { // not inf
+
2418 /* reactivePower */
+
2419 } else { //inf
+
+
2420 /* reactivePower */
+
2421 }
+
2422 }
+
2423 }
+
2424
+
+
2431 inline void AddNominalRealPowerToGeneratorOpt ( Types::name const & pNomOpt
+
2432 , TGeneratorProperties & generatorProperty )
+
2433 {
+
2434 if ( !pNomOpt.empty() )
+
+
2435 {
+
2436 if ( pNomOpt.compare("inf") != 0 )
+
2437 { // not inf
+
2438 /* pNomOpt */
+
2439 } else { //inf
+
2440 /* pNomOpt */
+
2441 }
+
2442 }
+
2443 }
+
2444
+
+
2451 inline void AddStatusToGenerator ( Types::name const & status
+
2452 , TGeneratorProperties & generatorProperty )
+
2453 {
+
2454 if ( !status.empty() )
+
+
2455 {
+
2456 if ( status.compare("inf") != 0 )
+
2457 { // not inf
+
2458 /* status */
+
2459 } else { //inf
+
2460 /* status */
+
2461 }
+
2462 }
+
2463 }
+
2464
+
+
2471 inline void AddWeightToGenerator ( Types::name const & weight
+
2472 , TGeneratorProperties & generatorProperty )
+
2473 {
+
2474 if ( !weight.empty() )
+
+
2475 {
+
2476 if ( weight.compare("inf") != 0 )
+
2477 { // not inf
+
2478 /* weight */
+
2479 } else { //inf
+
2480 /* weight */
+
2481 }
+
2482 }
+
2483 }
+
2485
+
+
2488#pragma mark GENERATOR_SNAPSHOT_EXTRACTION
+
2489
+
2499 void AddTimestampOfGenerator ( Types::name const & name
+
2500 , TNetwork & network )
+
2501 { /*network.AddSnapshotTimestamp( name ); is already implemented at load equivalent*/
+
2502 }
+
2503
+
2514 inline void AddMaximumRealPowerSnapshotPuToGenerator ( Types::name const & maximumRealPowerPu
+
+
2515 , TNetwork & network
+
2516 , Types::vertexId generatorId )
+
2517 {
+
2518 if ( !maximumRealPowerPu.empty() )
+
2519 {
+
2520 if ( maximumRealPowerPu.compare("inf") != 0 )
+
2521 { // not inf
+
2522 network.AddGeneratorRealPowerSnapshotAt ( generatorId, Types::String2double( maximumRealPowerPu ) );
+
2523 } else { //inf
+
2524 network.AddGeneratorRealPowerSnapshotAt ( generatorId, Const::REAL_INFTY );
+
2525 }
+
2526 } else {
+
2527 USAGE_ASSERT ( false && "Generator real power snapshot at generatorId is empty!" );
+
+
2528 }
+
2529 }
+
2530 // void AddMaximumRealPowerSnapshotPuToGenerator ( Types::name & maximumRealPowerPu, TGeneratorProperties * generator ) { generator->RealPower() = Types::String2double( maximumRealPowerPu ); }
+
2532
+
+
2535#pragma mark LINE_DATA_EXTRACTION
+
2536
+
2543 inline void AddNameToEdge ( Types::name const & name
+
2544 , TIoEdge & edge )
+
2545 {
+
2546 edge.Properties().Name() = name;
+
2547 }
+
+
2548
+
+
2555 inline void AddSourceVertexToEdge ( Types::name const & source
+
2556 , TIoEdge & edge )
+
2557 {
+
2558 if ( !source.empty() )
+
2559 {
+
2560 if ( mapBusName2VertexId_.find ( source ) != mapBusName2VertexId_.end() )
+
2561 {
+
2562 edge.Source() = mapBusName2VertexId_[source];
+
2563 }
+
2564 }
+
2565 }
+
2566
+
+
2573 inline void AddTargetVertexToEdge ( Types::name const & target
+
2574 , TIoEdge & edge )
+
+
2575 {
+
2576 if ( !target.empty() )
+
2577 {
+
2578 if ( mapBusName2VertexId_.find ( target ) != mapBusName2VertexId_.end() )
+
2579 {
+
2580 edge.Target() = mapBusName2VertexId_[target];
+
2581 }
+
2582 }
+
+
2583 }
+
2584
+
2591 inline void AddCapitalCostToEdge ( Types::name const & capitalCost
+
2592 , TIoEdge & edge )
+
2593 {
+
2594 if ( !capitalCost.empty() )
+
2595 {
+
2596 if ( capitalCost.compare("inf") != 0 )
+
2597 { // not inf
+
2598 edge.Properties().CapitalCost() = Types::String2double( capitalCost );
+
2599 } else { //inf
+
2600 edge.Properties().CapitalCost() = Const::REAL_INFTY;
+
2601 }
+
2602 }
+
2603 }
+
2604
+
2611 inline void AddLengthToEdge ( Types::name const & length
+
2612 , TIoEdge & edge )
+
2613 {
+
2614 if ( !length.empty() )
+
2615 {
+
2616 if ( length.compare("inf") != 0 )
+
2617 { // not inf
+
2618 edge.Properties().Length() = Types::String2double( length );
+
2619 } else {
+
2620 ESSENTIAL_ASSERT( false && "Infinity line length");
+
2621 }
+
2622 }
+
2623 }
+
2624
+
2631 inline void AddNumberOfParallelLinesToEdge ( Types::name const & numberParallelLines
+
2632 , TIoEdge & edge )
+
2633 {
+
2634 if ( !numberParallelLines.empty() )
+
2635 {
+
2636 if ( numberParallelLines.compare("inf") != 0 )
+
2637 { // not inf
+
2638 edge.Properties().NumberOfParallelLines() = Types::String2integer( numberParallelLines );
+
2639 } else {
+
2640 ESSENTIAL_ASSERT( false && "Infinity parallel lines");
+
2641 }
+
2642 }
+
2643 }
+
2644
+
2651 inline void AddMaximumApparentPowerPuToEdge ( Types::name const & apparentPowerMaximumPu
+
2652 , TIoEdge & edge )
+
2653 {
+
2654 if ( !apparentPowerMaximumPu.empty() )
+
2655 {
+
2656 if ( apparentPowerMaximumPu.compare("inf") != 0 )
+
2657 { // not inf
+
2658 edge.Properties().ThermalLimit() = Types::String2double( apparentPowerMaximumPu );
+
2659 } else { //inf
+
2660 edge.Properties().ThermalLimit() = Const::REAL_INFTY;
+
2661 }
+
2662 }
+
+
2663 }
+
2664
+
2671 void AddNominalApparentPowerToEdge ( Types::name const & apparentPowerNominal
+
2672 , TIoEdge & edge )
+
2673 {
+
2674 if ( !apparentPowerNominal.empty() )
+
2675 {
+
+
2676 if ( apparentPowerNominal.compare("inf") != 0 )
+
2677 { // not inf
+
2678 edge.Properties().NominalApparentPower() = Types::String2double( apparentPowerNominal );
+
2679 } else { //inf
+
2680 edge.Properties().NominalApparentPower() = Const::REAL_INFTY;
+
2681 }
+
2682 }
+
2683 }
+
2684
+
2691 inline void AddLineTypeToEdge ( Types::name const & type
+
2692 , TIoEdge & edge )
+
2693 {
+
2694 if ( !type.empty() )
+
2695 {
+
2696 edge.Properties().Type() = Edges::ElectricalEdgeType::standard;
+
2697 }
+
2698 }
+
2699
+
2706 void AddNominalVoltageToEdge ( Types::name const & voltageNominal
+
+
2707 , TIoEdge & edge )
+
2708 {
+
2709 if ( !voltageNominal.empty() )
+
2710 {
+
2711 if ( voltageNominal.compare("inf") != 0 )
+
2712 { // not inf
+
2713 edge.Properties().NominalVoltage() = Types::String2double( voltageNominal );
+
2714 } else { //inf
+
2715 edge.Properties().NominalVoltage() = Const::REAL_INFTY;
+
2716 }
+
2717 }
+
2718 }
+
2719
+
+
2726 inline void AddMinimumNominalApparentPowerToEdge ( Types::name const & apparentPowerNominalMinimum
+
2727 , TIoEdge & edge )
+
2728 { /* difference to apparentPowerMaximumPu apart the pu */
+
+
2729 if ( !apparentPowerNominalMinimum.empty() )
+
2730 {
+
2731 if ( apparentPowerNominalMinimum.compare("inf") != 0 )
+
2732 { // not inf
+
2733 edge.Properties().NominalApparentPowerBound().Minimum() = Types::String2double( apparentPowerNominalMinimum );
+
2734 } else { //inf
+
2735 edge.Properties().NominalApparentPowerBound().Minimum() = Const::REAL_INFTY;
+
2736 }
+
2737 }
+
2738 }
+
2739
+
+
2746 inline void AddMaximalNominalApparentPowerToEdge ( Types::name const & apparentPowerNominalMaximum
+
2747 , TIoEdge & edge )
+
2748 {
+
2749 if ( !apparentPowerNominalMaximum.empty() )
+
2750 {
+
+
2751 if ( apparentPowerNominalMaximum.compare("inf") != 0 )
+
2752 { // not inf
+
2753 edge.Properties().NominalApparentPowerBound().Maximum() = Types::String2double( apparentPowerNominalMaximum );
+
2754 } else { //inf
+
2755 edge.Properties().NominalApparentPowerBound().Maximum() = Const::REAL_INFTY;
+
2756 }
+
2757 }
+
2758 }
+
2759
+
+
2766 inline void AddResistanceToEdge ( Types::name const & resistance
+
2767 , TIoEdge & edge )
+
2768 {
+
2769 if ( !resistance.empty() )
+
2770 {
+
2771 if ( resistance.compare("inf") != 0 )
+
2772 { // not inf
+
+
2773 edge.Properties().Resistance() = Types::String2double( resistance );
+
2774 } else { //inf
+
2775 edge.Properties().Resistance() = Const::REAL_INFTY;
+
2776 }
+
2777 }
+
2778 }
+
2779
+
+
2786 inline void AddReactanceToEdge ( Types::name const & reactance
+
2787 , TIoEdge & edge )
+
2788 {
+
2789 if ( !reactance.empty() )
+
2790 {
+
2791 if ( reactance.compare("inf") != 0 )
+
2792 { // not inf
+
2793 edge.Properties().Reactance() = Types::String2double( reactance );
+
+
2794 } else { //inf
+
2795 edge.Properties().Reactance() = Const::REAL_INFTY;
+
2796 }
+
2797 }
+
2798 }
+
2799
+
2806 inline void AddConductanceToEdge ( Types::name const & conductance
+
+
2807 , TIoEdge & edge )
+
2808 { /* Can be calculated by r and x */
+
2809 if ( !conductance.empty() )
+
2810 {
+
2811 if ( conductance.compare("inf") != 0 )
+
2812 { // not inf
+
2813 edge.Properties().Conductance( Types::String2double( conductance ) );
+
2814 } else { //inf
+
2815 edge.Properties().Conductance( Const::REAL_INFTY );
+
+
2816 }
+
2817 }
+
2818 }
+
2819
+
2826 inline void AddSusceptanceToEdge ( Types::name const & susceptance
+
2827 , TIoEdge & edge )
+
2828 { /* Can be calculated by r and x */
+
+
2829 if ( !susceptance.empty() )
+
2830 {
+
2831 if ( susceptance.compare("inf") != 0 )
+
2832 { // not inf
+
2833 edge.Properties().Susceptance( Types::String2double( susceptance ) );
+
2834 } else { //inf
+
2835 edge.Properties().Susceptance( Const::REAL_INFTY );
+
2836 }
+
2837 }
+
+
2838 }
+
2839
+
2846 void AddNominalExtendableApparentPowerToEdge ( Types::name const & apparentPowerNominalExtendable
+
2847 , TIoEdge & edge )
+
2848 {
+
2849 if ( !apparentPowerNominalExtendable.empty() )
+
2850 {
+
+
2851 edge.Properties().NominalApparentPowerExtendable() = Types::String2double( apparentPowerNominalExtendable );
+
2852 }
+
2853 }
+
2854
+
2861 inline void AddTerrainFactorToEdge ( Types::name const & terrainFactor
+
2862 , TIoEdge & edge )
+
2863 {
+
2864 if ( !terrainFactor.empty() )
+
2865 {
+
2866 if ( terrainFactor.compare("inf") != 0 )
+
2867 { // not inf
+
2868 edge.Properties().TerrainFactor() = Types::String2double( terrainFactor );
+
2869 } else { //inf
+
2870 edge.Properties().TerrainFactor() = Const::REAL_INFTY;
+
2871 }
+
2872 }
+
2873 }
+
2874
+
2881 inline void AddMinimumVoltageAngleToEdge ( Types::name const & voltageAngleMin
+
+
2882 , TIoEdge & edge )
+
2883 {
+
2884 if ( !voltageAngleMin.empty() )
+
2885 {
+
2886 if ( voltageAngleMin.compare("inf") != 0 )
+
2887 { // not inf
+
2888 edge.Properties().ThetaBound().Minimum() = Types::String2double( voltageAngleMin );
+
2889 } else { //inf
+
2890 edge.Properties().ThetaBound().Minimum() = Const::REAL_INFTY;
+
2891 }
+
2892 }
+
2893 }
+
2894
+
+
2901 inline void AddMaximumVoltageAngleToEdge ( Types::name const & voltageAngleMax
+
2902 , TIoEdge & edge )
+
2903 {
+
+
2904 if ( !voltageAngleMax.empty() )
+
2905 {
+
2906 if ( voltageAngleMax.compare("inf") != 0 )
+
2907 { // not inf
+
2908 edge.Properties().ThetaBound().Maximum() = Types::String2double( voltageAngleMax );
+
2909 } else { //inf
+
2910 edge.Properties().ThetaBound().Maximum() = Const::REAL_INFTY;
+
2911 }
+
2912 }
+
2913 }
+
2915
+
+
2924#pragma mark LINE_DATA_OUTPUT
+
2925
+
2934 inline void AddSubnetworkToEdge ( Types::name const & subnetwork
+
2935 , TIoEdge & edge )
+
2936 {
+
2937 if ( !subnetwork.empty() )
+
2938 {
+
2939 if ( subnetwork.compare("inf") != 0 )
+
2940 { // not inf
+
2941 /* edge subnetwork */
+
2942 } else { //inf
+
2943 /* edge subnetwork */
+
2944 }
+
2945 }
+
2946 }
+
2947
+
2956 inline void AddP0ToEdge ( Types::name const & p0
+
2957 , TIoEdge & edge )
+
2958 {
+
2959 if ( !p0.empty() )
+
2960 {
+
2961 if ( p0.compare("inf") != 0 )
+
2962 { // not inf
+
2963 /* edge p0 */
+
2964 } else { //inf
+
2965 /* edge p0 */
+
2966 }
+
2967 }
+
2968 }
+
2969
+
2978 inline void AddQ0ToEdge ( Types::name const & q0
+
+
2979 , TIoEdge & edge )
+
2980 {
+
2981 if ( !q0.empty() )
+
2982 {
+
2983 if ( q0.compare("inf") != 0 )
+
+
2984 { // not inf
+
2985 /* edge q0 */
+
2986 } else { //inf
+
2987 /* edge q0 */
+
2988 }
+
2989 }
+
2990 }
+
+
2991
+
+
3000 inline void AddP1ToEdge ( Types::name const & p1
+
3001 , TIoEdge & edge )
+
3002 {
+
3003 if ( !p1.empty() )
+
3004 {
+
3005 if ( p1.compare("inf") != 0 )
+
+
3006 { // not inf
+
3007 /* edge p1 */
+
3008 } else { //inf
+
3009 /* edge p1 */
+
3010 }
+
3011 }
+
3012 }
+
3013
+
+
3022 inline void AddQ1ToEdge ( Types::name const & q1
+
3023 , TIoEdge & edge )
+
+
3024 {
+
3025 if ( !q1.empty() )
+
3026 {
+
3027 if ( q1.compare("inf") != 0 )
+
3028 { // not inf
+
3029 /* edge q1 */
+
3030 } else { //inf
+
3031 /* edge q1 */
+
3032 }
+
3033 }
+
3034 }
+
3035
+
+
+
3044 inline void AddReactancePuToEdge ( Types::name const & reactancePu
+
3045 , TIoEdge & edge )
+
3046 {
+
3047 if ( !reactancePu.empty() )
+
3048 {
+
3049 if ( reactancePu.compare("inf") != 0 )
+
3050 { // not inf
+
3051 /* edge reactancePu */
+
3052 } else { //inf
+
3053 /* edge reactancePu */
+
3054 }
+
3055 }
+
3056 }
+
+
3065 inline void AddResistancePuToEdge ( Types::name const & resistancePu
+
3066 , TIoEdge & edge )
+
3067 {
+
3068 if ( !resistancePu.empty() )
+
3069 {
+
3070 if ( resistancePu.compare("inf") != 0 )
+
3071 { // not inf
+
3072 /* edge resistancePu */
+
3073 } else { //inf
+
3074 /* edge resistancePu */
+
3075 }
+
3076 }
+
3077 }
+
3078
+
3087 inline void AddConductancePuToEdge ( Types::name const & conductancePu
+
3088 , TIoEdge & edge )
+
3089 {
+
3090 if ( !conductancePu.empty() )
+
3091 {
+
3092 if ( conductancePu.compare("inf") != 0 )
+
3093 { // not inf
+
3094 /* edge conductancePu */
+
3095 } else { //inf
+
3096 /* edge conductancePu */
+
3097 }
+
3098 }
+
3099 }
+
3100
+
3109 inline void AddSusceptancePuToEdge ( Types::name const & susceptancePu
+
3110 , TIoEdge & edge )
+
3111 {
+
3112 if ( !susceptancePu.empty() )
+
3113 {
+
3114 if ( susceptancePu.compare("inf") != 0 )
+
3115 { // not inf
+
3116 /* edge susceptancePu */
+
3117 } else { //inf
+
3118 /* edge susceptancePu */
+
3119 }
+
3120 }
+
3121 }
+
3122
+
3131 inline void AddEffectiveReactancePuToEdge ( Types::name const & reactancePuEffective
+
3132 , TIoEdge & edge )
+
3133 {
+
3134 if ( !reactancePuEffective.empty() )
+
3135 {
+
3136 if ( reactancePuEffective.compare("inf") != 0 )
+
+
3137 { // not inf
+
3138 /* edge reactancePuEffective */
+
3139 } else { //inf
+
3140 /* edge reactancePuEffective */
+
3141 }
+
+
3142 }
+
3143 }
+
3144
+
3153 inline void AddEffectiveResistancePuToEdge ( Types::name const & resistancePuEffective
+
3154 , TIoEdge & edge )
+
3155 {
+
3156 if ( !resistancePuEffective.empty() )
+
3157 {
+
3158 if ( resistancePuEffective.compare("inf") != 0 )
+
3159 { // not inf
+
3160 /* edge resistancePuEffective */
+
3161 } else { //inf
+
3162 /* edge resistancePuEffective */
+
3163 }
+
3164 }
+
3165 }
+
3166
+
3175 inline void AddOptimalNominalApparentPowerToEdge ( Types::name const & apparentPowerNominalOptimal
+
3176 , TIoEdge & edge )
+
3177 {
+
3178 if ( !apparentPowerNominalOptimal.empty() )
+
3179 {
+
3180 if ( apparentPowerNominalOptimal.compare("inf") != 0 )
+
3181 { // not inf
+
3182 /* edge apparentPowerNominalOptimal */
+
3183 } else { //inf
+
3184 /* edge apparentPowerNominalOptimal */
+
3185 }
+
3186 }
+
3187 }
+
3188
+
3197 inline void AddMuLowerToEdge ( Types::name const & muLower
+
3198 , TIoEdge & edge )
+
3199 {
+
3200 if ( !muLower.empty() )
+
3201 {
+
3202 if ( muLower.compare("inf") != 0 )
+
3203 { // not inf
+
3204 /* edge muLower */
+
3205 } else { //inf
+
3206 /* edge muLower */
+
3207 }
+
3208 }
+
3209 }
+
3210
+
+
+
3219 inline void AddMuUpperToEdge ( Types::name const & muUpper
+
3220 , TIoEdge & edge )
+
3221 {
+
3222 if ( !muUpper.empty() )
+
3223 {
+
3224 if ( muUpper.compare("inf") != 0 )
+
3225 { // not inf
+
3226 /* edge muUpper */
+
3227 } else { //inf
+
3228 /* edge muUpper */
+
3229 }
+
3230 }
+
3231 }
+
3233
+
3242#pragma mark LOAD_DATA_EXTRACTION
+
3243
+
+
3250 inline void AddNameToLoad ( Types::string const & name
+
3251 , TLoadProperties & vertexProperty )
+
3252 {
+
3253 vertexProperty.Name() = name;
+
3254 }
+
3255
+
3262 inline void AssociateLoadWithVertex ( Types::string const & bus
+
3263 , TLoadProperties & vertexProperty )
+
3264 {
+
3265 if ( !bus.empty() )
+
3266 {
+
3267 /* load bus */
+
3268 }
+
3269 }
+
3270
+
3277 inline void AddTypeToLoad ( Types::string const & type
+
3278 , TLoadProperties & vertexProperty )
+
3279 {
+
3280 if ( !type.empty() )
+
3281 {
+
3282 vertexProperty.Type() = Vertices::IeeeBusType::load;
+
3283
+
3284 } else {
+
3285 vertexProperty.Type() = Vertices::IeeeBusType::load;
+
3286 }
+
3287 }
+
3288
+
3295 inline void AddRealPowerSetPointToLoad ( Types::string const & pset
+
3296 , TLoadProperties & vertexProperty )
+
3297 {
+
3298 if ( !pset.empty() )
+
3299 {
+
3300 if ( pset.compare("inf") != 0 )
+
3301 { // not inf
+
3302 /* load pset */
+
3303 } else { //inf
+
3304 /* load pset */
+
3305 }
+
3306 }
+
3307 }
+
3308
+
3315 inline void AddReactivePowerSetPointToLoad ( Types::string const & qset
+
3316 , TLoadProperties & vertexProperty )
+
3317 {
+
3318 if ( !qset.empty() )
+
3319 {
+
3320 if ( qset.compare("inf") != 0 )
+
3321 { // not inf
+
3322 /* load qset */
+
3323 } else { //inf
+
3324 /* load qset */
+
3325 }
+
3326 }
+
3327 }
+
3328
+
3335 inline void AddSignToLoad ( Types::string const & sign
+
3336 , TLoadProperties & vertexProperty )
+
3337 {
+
3338 if ( !sign.empty() )
+
3339 {
+
3340 if ( sign.compare("inf") != 0 )
+
3341 { // not inf
+
3342 /* power sign */
+
3343 } else { //inf
+
3344 /* power sign */
+
3345 }
+
3346 }
+
3347 }
+
3348
+
3355 inline void AddRealPowerToLoad ( Types::string const & realPower
+
3356 , TLoadProperties & vertexProperty )
+
3357 {
+
3358 if ( !realPower.empty() )
+
3359 {
+
3360 if ( realPower.compare("inf") != 0 )
+
3361 { // not inf
+
3362 /* load realPower */
+
3363 } else { //inf
+
3364 /* load realPower */
+
3365 }
+
3366 }
+
3367 }
+
3368
+
3375 inline void AddReactivePowerToLoad ( Types::string const & reactivePower
+
3376 , TLoadProperties & vertexProperty )
+
3377 {
+
3378 if ( !reactivePower.empty() )
+
3379 {
+
3380 if ( reactivePower.compare("inf") != 0 )
+
3381 { // not inf
+
3382 /* load reactivePower */
+
3383 } else { //inf
+
3384 /* load reactivePower */
+
3385 }
+
3386 }
+
3387 }
+
3389
+
3400#pragma mark LINE_SNAPSHOT_EXTRACTION
+
3401
+
3408 inline void AddLoadTimestampName ( Types::name const & name
+
3409 , TNetwork & network )
+
3410 {
+
3411 network.AddSnapshotTimestamp( name );
+
3412 }
+
3413
+
3421 inline void AddMaximumRealPowerSnapshotPuToLoad ( Types::name const & maximumRealPowerPu
+
3422 , TNetwork & network
+
3423 , Types::vertexId loadId )
+
3424 {
+
3425 if ( !maximumRealPowerPu.empty() )
+
3426 {
+
3427 if ( maximumRealPowerPu.compare("inf") != 0 )
+
3428 { // not inf
+
3429 network.AddLoadSnapshotAt ( loadId, Types::String2double( maximumRealPowerPu ) );
+
3430 } else { //inf
+
3431 network.AddLoadSnapshotAt ( loadId, Const::REAL_INFTY );
+
3432 }
+
3433 } else {
+
3434 USAGE_ASSERT ( false && "Load real power snapshot at loadId is empty!" );
+
3435 }
+
3436 }
+
3438
+
3441#pragma mark FILE_AND_DIRECTORY_INFORMATION
+
3442
+
3443 Types::name path2FileDirectory_;
+
3444 Types::name const filenameBuses_;
+
3445 Types::name const filenameCarriers_;
+
3446 Types::name const filenameGenerators_;
+
3447 Types::name const filenameGeneratorsPMaxPu_;
+
3448 Types::name const filenameGlobalConstraints_;
+
3449 Types::name const filenameLines_;
+
3450 Types::name const filenameLinesNew_;
+
3451 Types::name const filenameLoads_;
+
3452 Types::name const filenameLoadsPSet_;
+
3453 Types::name const filenameNetwork_;
+
3454 Types::name const filenameSnapshots_;
+
3455 Types::name const filenameStorageUnits_;
+
3456 Types::name const filenameStorageUnitsInflow_;
+
3458
+
3461#pragma mark MAPPING_OF_DIFFERENT_INPUTS
+
3462
+
3463 std::unordered_map<Types::name, Types::vertexId> mapBusName2VertexId_;
+
3464 std::unordered_map<Types::name, TGeneratorProperties> mapGeneratorName2Generator_;
+
3465 std::unordered_map<Types::name, Types::vertexId> mapGeneratorName2Identifier_;
+
3466 std::unordered_map<Types::name, Types::name> mapGeneratorName2BusName_;
+
3467 std::unordered_map<Types::name, Types::vertexId> mapLoadName2Identifier_;
+
3469
+
3472#pragma mark COUNTER
+
3473 Types::count generatorSnapshotsSize;
+
3474 Types::count loadSnapshotsSize;
+
3475 // Types::count snapshotsSize;
+
3476 // Types::count storageUnitsInflowSize;
+
3478
+
3481#pragma mark FRIENDS
+
3483 friend internal::NetworkDifferentiation< TVertex, TIoEdge, PowerGrid< StaticGraph<TVertex,TIoEdge>, TGeneratorProperties, TLoadProperties > >;
+
3484 friend internal::NetworkDifferentiation< TVertex, TIoEdge, StaticGraph<TVertex,TIoEdge> >;
+
3486};
+
3487
+
3488namespace internal {
+
3489template<>
+
3490class NetworkDifferentiation< egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType>
+
3491 , egoa::Edges::ElectricalProperties
+
3492 , StaticGraph<egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType>
+
3493 , egoa::Edges::ElectricalProperties> >
+
3494{
+
3495 using TGraph = StaticGraph<egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType>
+
3496 , egoa::Edges::ElectricalProperties>;
+
3497 using TVertexProperties = egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType>;
+
3498 using TEdgeProperties = egoa::Edges::ElectricalProperties;
+
3499
+
3500 using TIoEdge = io::Edge<TEdgeProperties>;
+
3501
+
3502 public:
+
3503 static Types::edgeId AddEdge ( TGraph & network
+
3504 , TIoEdge const & ioEdge )
+
3505 {
+
3506 return network.AddEdge( ioEdge.Source(), ioEdge.Target(), ioEdge.Properties() );
+
3507 }
+
3508
+
3509 static Types::vertexId AddVertex ( TGraph & network
+
3510 , TVertexProperties const & vertexProperties )
+
3511 {
+
3512 return network.AddVertex( vertexProperties );
+
3513 }
+
3514};
+
3515
+
3516template<typename VertexTypeProperties, typename EdgeTypeProperties>
+
3517class NetworkDifferentiation< VertexTypeProperties
+
3518 , EdgeTypeProperties
+
3519 , StaticGraph<VertexTypeProperties
+
3520 , EdgeTypeProperties> >
+
3521{
+
3522 using TVertexProperties = VertexTypeProperties;
+
3523 using TEdgeProperties = EdgeTypeProperties;
+
3524
+
3525 using TGraph = StaticGraph<TVertexProperties
+
3526 , TEdgeProperties>;
+
3527
+
3528 using TIoEdge = io::Edge<TEdgeProperties>;
+
3529 public:
+
3530 static Types::edgeId AddEdge ( TGraph & network
+
3531 , TIoEdge const & ioEdge )
+
3532 {
+
3533 return network.AddEdge( ioEdge.Source(), ioEdge.Target(), ioEdge.Properties() );
+
3534 }
+
3535
+
3536 static Types::vertexId AddVertex ( TGraph & network
+
3537 , TVertexProperties const & vertexProperties )
+
3538 {
+
3539 return network.AddVertex( vertexProperties );
+
3540 }
+
3541};
+
3542
+
3543template<typename VertexTypeProperties, typename EdgeTypeProperties>
+
3544class NetworkDifferentiation< VertexTypeProperties
+
3545 , EdgeTypeProperties
+
3546 , PowerGrid< StaticGraph< VertexTypeProperties
+
3547 , EdgeTypeProperties >
+
3548 , Vertices::GeneratorProperties<>
+
3549 , Vertices::LoadProperties<Vertices::IeeeBusType> > >
+
3550{
+
3551 using TVertexProperties = VertexTypeProperties;
+
3552 using TEdgeProperties = EdgeTypeProperties;
+
3553
+
3554 using TGraph = PowerGrid<StaticGraph<TVertexProperties
+
3555 , TEdgeProperties>>;
+
3556
+
3557 using TIoEdge = io::Edge<TEdgeProperties>;
+
3558
+
3559 public:
+
3560 static Types::edgeId AddEdge ( TGraph & network
+
3561 , TIoEdge const & ioEdge )
+
3562 {
+
3563 return network.Graph().AddEdge( ioEdge.Source(), ioEdge.Target(), ioEdge.Properties() );
+
3564 }
+
3565
+
3566 static Types::vertexId AddVertex ( TGraph & network
+
3567 , TVertexProperties const & vertexProperties )
+
3568 {
+
3569 return network.Graph().AddVertex( vertexProperties );
+
3570 }
+
3571};
+
3572} // namespace internal
+
3573
+
3574} // namespace egoa
+
3575
+
3576#endif // EGOA__IO__PARSER___PY_PSA_PARSER_HPP
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+
egoa::Edges::ElectricalProperties
Class having all edge electrical properties (branch properties).
Definition ElectricalProperties.hpp:27
+ + +
egoa::PyPsaParser::AddSubnetworkToEdge
void AddSubnetworkToEdge(Types::name const &subnetwork, TIoEdge &edge)
Add the subnetwork.
Definition PyPsaParser.hpp:2663
+
egoa::PyPsaParser::AddMaximumVoltageAngleToEdge
void AddMaximumVoltageAngleToEdge(Types::name const &voltageAngleMax, TIoEdge &edge)
Add maximum voltage angle to the line.
Definition PyPsaParser.hpp:2630
+
egoa::PyPsaParser::ExtractGeneratorHeader
bool ExtractGeneratorHeader(QList< QByteArray > const &splitted)
Extract the generator header.
Definition PyPsaParser.hpp:970
+
egoa::PyPsaParser::AddMuLowerToEdge
void AddMuLowerToEdge(Types::name const &muLower, TIoEdge &edge)
Add mu lower of a line.
Definition PyPsaParser.hpp:2926
+
egoa::PyPsaParser::ExtractLoadMaximumRealPowerPuHeader
bool ExtractLoadMaximumRealPowerPuHeader(QList< QByteArray > const &splitted)
Extract load maximum real power p.u.
Definition PyPsaParser.hpp:1176
+
egoa::PyPsaParser::ReadStorageUnits
bool ReadStorageUnits()
Reads storage units.
Definition PyPsaParser.hpp:151
+
egoa::PyPsaParser::filenameLoadsPSet_
Types::name const filenameLoadsPSet_
Definition PyPsaParser.hpp:3181
+
egoa::PyPsaParser::AddRealPowerToVertexProperty
void AddRealPowerToVertexProperty(Types::name const &realPower, TVertexProperties &vertexProperty)
Add the real power to the vertex property.
Definition PyPsaParser.hpp:1475
+
egoa::PyPsaParser::SetLoadDefaultValues
void SetLoadDefaultValues(TLoadProperties &vertex)
Sets the load default values.
Definition PyPsaParser.hpp:532
+
egoa::PyPsaParser::ReadCompleteNetwork
bool ReadCompleteNetwork(TNetwork &network, std::string const &filename)
Reads a complete network.
Definition PyPsaParser.hpp:583
+
egoa::PyPsaParser::AddRealPowerToLoad
void AddRealPowerToLoad(Types::string const &realPower, TLoadProperties &vertexProperty)
Add the real power load to the vertex property.
Definition PyPsaParser.hpp:3084
+
egoa::PyPsaParser::ExtractLoadHeader
bool ExtractLoadHeader(QList< QByteArray > const &splitted, Types::index &column)
Extract the existing load header data.
Definition PyPsaParser.hpp:1132
+
egoa::PyPsaParser::AddNominalRealPowerToGeneratorOpt
void AddNominalRealPowerToGeneratorOpt(Types::name const &pNomOpt, TGeneratorProperties &generatorProperty)
Adds a optimal nominal real power to the generator.
Definition PyPsaParser.hpp:2160
+
egoa::PyPsaParser::AddStatusToGenerator
void AddStatusToGenerator(Types::name const &status, TGeneratorProperties &generatorProperty)
Adds a status to the generator .
Definition PyPsaParser.hpp:2180
+
egoa::PyPsaParser::ReadLines
bool ReadLines(Graph &network, const std::string &filename)
Reads branch (lines) matrix.
Definition PyPsaParser.hpp:355
+
egoa::PyPsaParser::AddRealPowerToGenerator
void AddRealPowerToGenerator(Types::name const &realPower, TGeneratorProperties &generatorProperty)
Adds a real power to the generator.
Definition PyPsaParser.hpp:2120
+
egoa::PyPsaParser::AddMarginalPriceToVertexProperty
void AddMarginalPriceToVertexProperty(Types::name const &marginalPrice, TVertexProperties &vertex)
Add the marginal price to the vertex property.
Definition PyPsaParser.hpp:1563
+
egoa::PyPsaParser::HasCorrectSnapshotSizes
bool HasCorrectSnapshotSizes()
Check if the snapshot size maps.
Definition PyPsaParser.hpp:754
+
egoa::PyPsaParser::AddRampLimitShutDownToGenerator
void AddRampLimitShutDownToGenerator(Types::string const &rampLimitShutDown, TGeneratorProperties &generatorProperty)
Adds a ramp limit shut down to the generator.
Definition PyPsaParser.hpp:2095
+
egoa::PyPsaParser::AddBusTypeToVertexProperty
void AddBusTypeToVertexProperty(Types::name const &type, TVertexProperties &vertexProperty)
Add the bus type to the vertex property.
Definition PyPsaParser.hpp:1294
+
egoa::PyPsaParser::AddStartUpCostToGenerator
void AddStartUpCostToGenerator(Types::string const &startUpCost, TGeneratorProperties &generatorProperty)
Adds a start up cost to the generator.
Definition PyPsaParser.hpp:1936
+
egoa::PyPsaParser::AddGeneratorEfficiencyToGenerator
void AddGeneratorEfficiencyToGenerator(Types::string const &efficiency, TGeneratorProperties &generatorProperty)
Adds a generator efficiency to generator.
Definition PyPsaParser.hpp:1695
+
egoa::PyPsaParser::path2FileDirectory_
Types::name path2FileDirectory_
Definition PyPsaParser.hpp:3172
+
egoa::PyPsaParser::read
bool read(TNetwork &network, std::string const &filename)
Read network from file.
Definition PyPsaParser.hpp:640
+
egoa::PyPsaParser::AddMinimumNominalApparentPowerToEdge
void AddMinimumNominalApparentPowerToEdge(Types::name const &apparentPowerNominalMinimum, TIoEdge &edge)
Add the minimum nominal apparent power.
Definition PyPsaParser.hpp:2455
+
egoa::PyPsaParser::ExtractBusHeader
bool ExtractBusHeader(QList< QByteArray > const &splitted)
Extract the bus header.
Definition PyPsaParser.hpp:775
+
egoa::PyPsaParser::AddVoltageMagnitudePuToVertexProperty
void AddVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePu, TVertexProperties &vertexProperty)
Add the voltage magnitude in p.u. to the vertex property.
Definition PyPsaParser.hpp:1519
+
egoa::PyPsaParser::AddShutDownCostToGenerator
void AddShutDownCostToGenerator(Types::string const &shutDownCost, TGeneratorProperties &generatorProperty)
Adds a shut down cost to the generator.
Definition PyPsaParser.hpp:1956
+
egoa::PyPsaParser::AddBusName
void AddBusName(Types::name const &name, TVertexProperties &vertexProperty)
Add bus name to the vertex property.
Definition PyPsaParser.hpp:1258
+
egoa::PyPsaParser::ReadLine
QList< QByteArray > ReadLine(QFile &file, bool compress=true)
Reads a line.
Definition PyPsaParser.hpp:713
+
egoa::PyPsaParser::mapGeneratorName2BusName_
std::unordered_map< Types::name, Types::name > mapGeneratorName2BusName_
Definition PyPsaParser.hpp:3195
+
egoa::PyPsaParser::AddNominalApparentPowerToEdge
void AddNominalApparentPowerToEdge(Types::name const &apparentPowerNominal, TIoEdge &edge)
Add the nominal apparent power to the line.
Definition PyPsaParser.hpp:2400
+
egoa::PyPsaParser::mapGeneratorName2Identifier_
std::unordered_map< Types::name, Types::vertexId > mapGeneratorName2Identifier_
Definition PyPsaParser.hpp:3194
+
egoa::PyPsaParser::AddReactivePowerSetPointToGenerator
void AddReactivePowerSetPointToGenerator(Types::string const &qSet, TGeneratorProperties &generatorProperty)
Adds a reactive power set point to the generator.
Definition PyPsaParser.hpp:1815
+
egoa::PyPsaParser::AddMaximalNominalApparentPowerToEdge
void AddMaximalNominalApparentPowerToEdge(Types::name const &apparentPowerNominalMaximum, TIoEdge &edge)
Add the maximum nominal apparent power to the line.
Definition PyPsaParser.hpp:2475
+
egoa::PyPsaParser::AddTimestampOfGenerator
void AddTimestampOfGenerator(Types::name const &name, TNetwork &network)
Add the time stamp of the maximum real power.
Definition PyPsaParser.hpp:2228
+
egoa::PyPsaParser::AddRampLimitUpToGenerator
void AddRampLimitUpToGenerator(Types::string const &rampLimitUp, TGeneratorProperties &generatorProperty)
Adds a ramp up time limit to the generator.
Definition PyPsaParser.hpp:2035
+
egoa::PyPsaParser::filenameGlobalConstraints_
Types::name const filenameGlobalConstraints_
Definition PyPsaParser.hpp:3177
+
egoa::PyPsaParser::AddReactivePowerToVertexProperty
void AddReactivePowerToVertexProperty(Types::name const &reactivePower, TVertexProperties &vertexProperty)
Add reactive power to the vertex property.
Definition PyPsaParser.hpp:1497
+
egoa::PyPsaParser::AddP0ToEdge
void AddP0ToEdge(Types::name const &p0, TIoEdge &edge)
Add the real power P0.
Definition PyPsaParser.hpp:2685
+
egoa::PyPsaParser::CompressString
void CompressString(QByteArray &list)
Compress the string by removing spaces.
Definition PyPsaParser.hpp:727
+
egoa::PyPsaParser::AddLoadTimestampName
void AddLoadTimestampName(Types::name const &name, TNetwork &network)
Add a maximum real power load time stamp in p.u.
Definition PyPsaParser.hpp:3137
+
egoa::PyPsaParser::mapLoadName2Identifier_
std::unordered_map< Types::name, Types::vertexId > mapLoadName2Identifier_
Definition PyPsaParser.hpp:3196
+
egoa::PyPsaParser::AddGeneratorSignToGenerator
void AddGeneratorSignToGenerator(Types::string const &sign, TGeneratorProperties &generatorProperty)
Add the generator's sign to the generator.
Definition PyPsaParser.hpp:1835
+
egoa::PyPsaParser::AddNominalRealPowerToGenerator
void AddNominalRealPowerToGenerator(Types::string const &pNom, TGeneratorProperties &generatorProperty)
Adds a nominal real power to the generator.
Definition PyPsaParser.hpp:1604
+
egoa::PyPsaParser::AddReactivePowerToGenerator
void AddReactivePowerToGenerator(Types::name const &reactivePower, TGeneratorProperties &generatorProperty)
Adds a reactive power to the generator.
Definition PyPsaParser.hpp:2140
+
egoa::PyPsaParser::ReadGenerators
bool ReadGenerators(TNetwork &network, std::string const &filename)
Read the generator matrix.
Definition PyPsaParser.hpp:276
+
egoa::PyPsaParser::AddInitialStatusToGenerator
void AddInitialStatusToGenerator(Types::string const &initialStatus, TGeneratorProperties &generatorProperty)
Adds an initial status to the generator.
Definition PyPsaParser.hpp:2016
+
egoa::PyPsaParser::AddQ0ToEdge
void AddQ0ToEdge(Types::name const &q0, TIoEdge &edge)
Add the reactive power Q0.
Definition PyPsaParser.hpp:2707
+
egoa::PyPsaParser::AddCommittabilityToGenerator
void AddCommittabilityToGenerator(Types::string const &committable, TGeneratorProperties &generatorProperty)
Add if the generator is committable or not.
Definition PyPsaParser.hpp:1919
+
egoa::PyPsaParser::AddMinimumDownTimeToGenerator
void AddMinimumDownTimeToGenerator(Types::string const &minDownTime, TGeneratorProperties &generatorProperty)
Adds a minimum down time to the generator.
Definition PyPsaParser.hpp:1996
+
egoa::PyPsaParser::AddCarrierToVertexProperty
void AddCarrierToVertexProperty(Types::name const &carrier, TVertexProperties &vertexProperty)
Add carrier to the vertex property.
Definition PyPsaParser.hpp:1339
+
egoa::PyPsaParser::AddLineTypeToEdge
void AddLineTypeToEdge(Types::name const &type, TIoEdge &edge)
Add the line type to the line.
Definition PyPsaParser.hpp:2420
+
egoa::PyPsaParser::AddNominalVoltageToEdge
void AddNominalVoltageToEdge(Types::name const &voltageNominal, TIoEdge &edge)
Add the nominal voltage to the line.
Definition PyPsaParser.hpp:2435
+
egoa::PyPsaParser::ReadLoads
bool ReadLoads(TNetwork &network, std::string const &filename)
Read the load matrix that is a mapping of load to bus.
Definition PyPsaParser.hpp:476
+
egoa::PyPsaParser::ExtractGeneratorMaximumRealPowerPuHeader
bool ExtractGeneratorMaximumRealPowerPuHeader(QList< QByteArray > const &splitted)
Extract the existing generator maximum real power p.u. header.
Definition PyPsaParser.hpp:1087
+
egoa::PyPsaParser::AddControlTypeToGenerator
void AddControlTypeToGenerator(Types::string const &control, TGeneratorProperties &generatorProperty)
Adds a control type to the generator.
Definition PyPsaParser.hpp:1588
+
egoa::PyPsaParser::AddNameToLoad
void AddNameToLoad(Types::string const &name, TLoadProperties &vertexProperty)
Add the name of the load.
Definition PyPsaParser.hpp:2979
+
egoa::PyPsaParser::AddNameToGenerator
void AddNameToGenerator(Types::name const &name, TGeneratorProperties &generatorProperty)
Adds a name to the generator.
Definition PyPsaParser.hpp:1638
+
egoa::PyPsaParser::AssociateLoadWithVertex
void AssociateLoadWithVertex(Types::string const &bus, TLoadProperties &vertexProperty)
Associating the load with a bus.
Definition PyPsaParser.hpp:2991
+
egoa::PyPsaParser::ReadNetwork
bool ReadNetwork(TNetwork &network)
Reads a network.
Definition PyPsaParser.hpp:548
+
egoa::PyPsaParser::filenameGeneratorsPMaxPu_
Types::name const filenameGeneratorsPMaxPu_
Definition PyPsaParser.hpp:3176
+
egoa::PyPsaParser::AddNominalRealPowerToGeneratorMin
void AddNominalRealPowerToGeneratorMin(Types::string const &pNomMin, TGeneratorProperties &generatorProperty)
Adds a minimum nominal real power to the generator.
Definition PyPsaParser.hpp:1715
+
egoa::PyPsaParser::SetLineDefaultValues
void SetLineDefaultValues(TIoEdge &edge)
Sets the branch default values.
Definition PyPsaParser.hpp:395
+
egoa::PyPsaParser::AddRealPowerSetPointToGenerator
void AddRealPowerSetPointToGenerator(Types::string const &pSet, TGeneratorProperties &generatorProperty)
Adds a real power set point to the generator.
Definition PyPsaParser.hpp:1795
+
egoa::PyPsaParser::filenameLinesNew_
Types::name const filenameLinesNew_
Definition PyPsaParser.hpp:3179
+
egoa::PyPsaParser::AssociateGeneratorWithBus
void AssociateGeneratorWithBus(Types::name const &bus, TGeneratorProperties &generatorProperty)
Associate the generator with a bus.
Definition PyPsaParser.hpp:1657
+
egoa::PyPsaParser::AddNominalVoltageToVertexProperty
void AddNominalVoltageToVertexProperty(Types::name const &voltageNominal, TVertexProperties &vertexProperty)
Add the nominal voltage to the vertex property.
Definition PyPsaParser.hpp:1270
+
egoa::PyPsaParser::AddReactancePuToEdge
void AddReactancePuToEdge(Types::name const &reactancePu, TIoEdge &edge)
Add the reactance in p.u.
Definition PyPsaParser.hpp:2773
+
egoa::PyPsaParser::AddVoltageMagnitudePuSetPointToVertexProperty
void AddVoltageMagnitudePuSetPointToVertexProperty(Types::name const &voltageMagnitudePuSetpoint, TVertexProperties &vertexProperty)
Add voltage magnitude set point to the vertex property.
Definition PyPsaParser.hpp:1369
+
egoa::PyPsaParser::AddMinimumRealPowerPuToGenerator
void AddMinimumRealPowerPuToGenerator(Types::string const &pMinPu, TGeneratorProperties &generatorProperty)
Adds a minimum real power in p.u. to the generator.
Definition PyPsaParser.hpp:1755
+
egoa::PyPsaParser::mapBusName2VertexId_
std::unordered_map< Types::name, Types::vertexId > mapBusName2VertexId_
Definition PyPsaParser.hpp:3192
+
egoa::PyPsaParser::AddMuUpperToEdge
void AddMuUpperToEdge(Types::name const &muUpper, TIoEdge &edge)
Add mu upper of a line.
Definition PyPsaParser.hpp:2948
+
egoa::PyPsaParser::AddOptimalNominalApparentPowerToEdge
void AddOptimalNominalApparentPowerToEdge(Types::name const &apparentPowerNominalOptimal, TIoEdge &edge)
Add the optimal nominal apparent power.
Definition PyPsaParser.hpp:2904
+
egoa::PyPsaParser::ReadCarriers
bool ReadCarriers()
Reads carriers.
Definition PyPsaParser.hpp:211
+
egoa::PyPsaParser::AddTerrainFactorToEdge
void AddTerrainFactorToEdge(Types::name const &terrainFactor, TIoEdge &edge)
Add the terrain factor to the line.
Definition PyPsaParser.hpp:2590
+
egoa::PyPsaParser::AddCarrierToGenerator
void AddCarrierToGenerator(Types::string const &carrier, TGeneratorProperties &generatorProperty)
Adds a carrier to the generator.
Definition PyPsaParser.hpp:1857
+
egoa::PyPsaParser::AddCapitalCostToEdge
void AddCapitalCostToEdge(Types::name const &capitalCost, TIoEdge &edge)
Add the capital cost to the line.
Definition PyPsaParser.hpp:2320
+
egoa::PyPsaParser::AddVoltageAngleToVertexProperty
void AddVoltageAngleToVertexProperty(Types::name const &voltageAngle, TVertexProperties &vertexProperty)
Add voltage angle to the vertex property.
Definition PyPsaParser.hpp:1541
+
egoa::PyPsaParser::ReadLoadsPset
bool ReadLoadsPset(TNetwork &network, std::string const &filename)
Read loads real power set.
Definition PyPsaParser.hpp:432
+
egoa::PyPsaParser::AddWeightToGenerator
void AddWeightToGenerator(Types::name const &weight, TGeneratorProperties &generatorProperty)
Adds a weight to the generator .
Definition PyPsaParser.hpp:2200
+
egoa::PyPsaParser::ReadGeneratorsRealPowerMaxPu
bool ReadGeneratorsRealPowerMaxPu(TNetwork &network, std::string const &filename)
Read generators maximum real power production snapshot in p.u.
Definition PyPsaParser.hpp:230
+
egoa::PyPsaParser::AddSourceVertexToEdge
void AddSourceVertexToEdge(Types::name const &source, TIoEdge &edge)
Associate the line with the source vertex.
Definition PyPsaParser.hpp:2284
+
egoa::PyPsaParser::filenameLines_
Types::name const filenameLines_
Definition PyPsaParser.hpp:3178
+
egoa::PyPsaParser::AddReactanceToEdge
void AddReactanceToEdge(Types::name const &reactance, TIoEdge &edge)
Add the reactance to the line.
Definition PyPsaParser.hpp:2515
+
egoa::PyPsaParser::AddMaximumVoltageMagnitudePuToVertexProperty
void AddMaximumVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePuMaximum, TVertexProperties &vertexProperty)
Add maximum voltage to the vertex property.
Definition PyPsaParser.hpp:1409
+
egoa::PyPsaParser::filenameSnapshots_
Types::name const filenameSnapshots_
Definition PyPsaParser.hpp:3183
+
egoa::PyPsaParser::AddSusceptancePuToEdge
void AddSusceptancePuToEdge(Types::name const &susceptancePu, TIoEdge &edge)
Add the susceptance in p.u.
Definition PyPsaParser.hpp:2838
+
egoa::PyPsaParser::AddQ1ToEdge
void AddQ1ToEdge(Types::name const &q1, TIoEdge &edge)
Add the reactive power Q1.
Definition PyPsaParser.hpp:2751
+
egoa::PyPsaParser::AddMinimumUpTimeToGenerator
void AddMinimumUpTimeToGenerator(Types::string const &minUpTime, TGeneratorProperties &generatorProperty)
Adds a minimum up time to the generator.
Definition PyPsaParser.hpp:1976
+
egoa::PyPsaParser::AddReactivePowerSetPointToLoad
void AddReactivePowerSetPointToLoad(Types::string const &qset, TLoadProperties &vertexProperty)
Add the reactive power set point.
Definition PyPsaParser.hpp:3044
+
egoa::PyPsaParser::AddControlTypeToVertexProperty
void AddControlTypeToVertexProperty(Types::string const &control, TVertexProperties &vertexProperty)
Add the control type to the vertex property.
Definition PyPsaParser.hpp:1436
+
egoa::PyPsaParser::filenameNetwork_
Types::name const filenameNetwork_
Definition PyPsaParser.hpp:3182
+
egoa::PyPsaParser::AddRampLimitDownToGenerator
void AddRampLimitDownToGenerator(Types::string const &rampLimitDown, TGeneratorProperties &generatorProperty)
Adds a ramp down time limit to the generator.
Definition PyPsaParser.hpp:2055
+
egoa::PyPsaParser::AddMinimumVoltageMagnitudePuToVertexProperty
void AddMinimumVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePuMinimum, TVertexProperties &vertexProperty)
Add minimum voltage magnitude to the vertex property.
Definition PyPsaParser.hpp:1389
+
egoa::PyPsaParser::AddRampLimitStartUpToGenerator
void AddRampLimitStartUpToGenerator(Types::string const &rampLimitStartUp, TGeneratorProperties &generatorProperty)
Adds a ramp start up time limit to the generator.
Definition PyPsaParser.hpp:2075
+
egoa::PyPsaParser::AddTypeToGenerator
void AddTypeToGenerator(Types::string const &type, TGeneratorProperties &generatorProperty)
Adds a type to the generator.
Definition PyPsaParser.hpp:1680
+
egoa::PyPsaParser::ReadBuses
bool ReadBuses(TNetwork &network, std::string const &filename)
Read the bus matrix.
Definition PyPsaParser.hpp:171
+
egoa::PyPsaParser::AddSignToLoad
void AddSignToLoad(Types::string const &sign, TLoadProperties &vertexProperty)
Add the data sign of the load.
Definition PyPsaParser.hpp:3064
+
egoa::PyPsaParser::AddMarginalCostToGenerator
void AddMarginalCostToGenerator(Types::string const &marginalCost, TGeneratorProperties &generatorProperty)
Adds a marginal cost to the generator.
Definition PyPsaParser.hpp:1872
+
egoa::PyPsaParser::AddVertex
Types::vertexId AddVertex(Graph &network, TVertexProperties const &vertexProperties)
Wrapper for adding a vertex.
Definition PyPsaParser.hpp:679
+
egoa::PyPsaParser::AddTargetVertexToEdge
void AddTargetVertexToEdge(Types::name const &target, TIoEdge &edge)
Associate the line with the target bus.
Definition PyPsaParser.hpp:2302
+
egoa::PyPsaParser::ReadStorageUnitsInflows
bool ReadStorageUnitsInflows()
Read storage units in flow.
Definition PyPsaParser.hpp:136
+
egoa::PyPsaParser::AddMaximumRealPowerSnapshotPuToGenerator
void AddMaximumRealPowerSnapshotPuToGenerator(Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId generatorId)
Add the maximum real power generation snapshot in p.u. to a generator.
Definition PyPsaParser.hpp:2243
+
egoa::PyPsaParser::AddYcoordinateToVertexProperty
void AddYcoordinateToVertexProperty(Types::name const &yCoordinate, TVertexProperties &vertexProperty)
Add y-coordinate to the vertex property.
Definition PyPsaParser.hpp:1324
+
egoa::PyPsaParser::AddReactivePowerToLoad
void AddReactivePowerToLoad(Types::string const &reactivePower, TLoadProperties &vertexProperty)
Add the reactive power loads.
Definition PyPsaParser.hpp:3104
+
egoa::PyPsaParser::AddEffectiveResistancePuToEdge
void AddEffectiveResistancePuToEdge(Types::name const &resistancePuEffective, TIoEdge &edge)
Add the effective resistance in p.u.
Definition PyPsaParser.hpp:2882
+
egoa::PyPsaParser::AddXcoordinateToVertexProperty
void AddXcoordinateToVertexProperty(Types::name const &xCoordinate, TVertexProperties &vertexProperty)
Add x-coordinate to the vertex property.
Definition PyPsaParser.hpp:1309
+
egoa::PyPsaParser::filenameGenerators_
Types::name const filenameGenerators_
Definition PyPsaParser.hpp:3175
+
egoa::PyPsaParser::AddMaximumRealPowerPuToGenerator
void AddMaximumRealPowerPuToGenerator(Types::string const &pMaxPu, TGeneratorProperties &generatorProperty)
Adds a maximum real power in p.u.
Definition PyPsaParser.hpp:1775
+
egoa::PyPsaParser::AddTypeToLoad
void AddTypeToLoad(Types::string const &type, TLoadProperties &vertexProperty)
Add the load type.
Definition PyPsaParser.hpp:3006
+
egoa::PyPsaParser::AddSubnetworkToVertexProperty
void AddSubnetworkToVertexProperty(Types::name const &subnetwork, TVertexProperties &vertexProperty)
Add the subnetwork to the vertex property.
Definition PyPsaParser.hpp:1453
+
egoa::PyPsaParser::ReadGlobalConstraints
bool ReadGlobalConstraints()
Sets the generator default values.
Definition PyPsaParser.hpp:334
+
egoa::PyPsaParser::AddMinimumVoltageAngleToEdge
void AddMinimumVoltageAngleToEdge(Types::name const &voltageAngleMin, TIoEdge &edge)
Add the minimum voltage angle to the line.
Definition PyPsaParser.hpp:2610
+
egoa::PyPsaParser::AddMaximumApparentPowerPuToEdge
void AddMaximumApparentPowerPuToEdge(Types::name const &apparentPowerMaximumPu, TIoEdge &edge)
Add the maximum apparent power in p.u. to the line.
Definition PyPsaParser.hpp:2380
+
egoa::PyPsaParser::ReadSnapshots
bool ReadSnapshots(TNetwork &network)
Reads snapshots.
Definition PyPsaParser.hpp:565
+
egoa::PyPsaParser::AddNominalExtendableApparentPowerToEdge
void AddNominalExtendableApparentPowerToEdge(Types::name const &apparentPowerNominalExtendable, TIoEdge &edge)
Add the nominal extendable apparent power to the line.
Definition PyPsaParser.hpp:2575
+
egoa::PyPsaParser::AddNameToEdge
void AddNameToEdge(Types::name const &name, TIoEdge &edge)
Add the name to the line.
Definition PyPsaParser.hpp:2272
+
egoa::PyPsaParser::filenameStorageUnits_
Types::name const filenameStorageUnits_
Definition PyPsaParser.hpp:3184
+
egoa::PyPsaParser::AddSusceptanceToEdge
void AddSusceptanceToEdge(Types::name const &susceptance, TIoEdge &edge)
Add the susceptance to the line.
Definition PyPsaParser.hpp:2555
+
egoa::PyPsaParser::AddLengthToEdge
void AddLengthToEdge(Types::name const &length, TIoEdge &edge)
Add the length to the line.
Definition PyPsaParser.hpp:2340
+
egoa::PyPsaParser::AddNominalRealPowerToGeneratorMax
void AddNominalRealPowerToGeneratorMax(Types::string const &pNomMax, TGeneratorProperties &generatorProperty)
Adds a maximum nominal real power to the generator.
Definition PyPsaParser.hpp:1735
+
egoa::PyPsaParser::filenameBuses_
Types::name const filenameBuses_
Definition PyPsaParser.hpp:3173
+
egoa::PyPsaParser::mapGeneratorName2Generator_
std::unordered_map< Types::name, TGeneratorProperties > mapGeneratorName2Generator_
Definition PyPsaParser.hpp:3193
+
egoa::PyPsaParser::AddConductancePuToEdge
void AddConductancePuToEdge(Types::name const &conductancePu, TIoEdge &edge)
Add the conductance G in p.u.
Definition PyPsaParser.hpp:2816
+
egoa::PyPsaParser::AddCountryToVertexProperty
void AddCountryToVertexProperty(Types::name const &country, TVertexProperties &vertexProperty)
Add data country to the vertex property.
Definition PyPsaParser.hpp:1354
+
egoa::PyPsaParser::AddEffectiveReactancePuToEdge
void AddEffectiveReactancePuToEdge(Types::name const &reactancePuEffective, TIoEdge &edge)
Add the effective reactance in p.u.
Definition PyPsaParser.hpp:2860
+
egoa::PyPsaParser::AddMaximumRealPowerSnapshotPuToLoad
void AddMaximumRealPowerSnapshotPuToLoad(Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId loadId)
Add a maximum real power load in p.u.
Definition PyPsaParser.hpp:3150
+
egoa::PyPsaParser::ExtractLineHeader
bool ExtractLineHeader(QList< QByteArray > const &splitted)
Extract the line (branch) header.
Definition PyPsaParser.hpp:845
+
egoa::PyPsaParser::AddP1ToEdge
void AddP1ToEdge(Types::name const &p1, TIoEdge &edge)
Add the real power P1.
Definition PyPsaParser.hpp:2729
+
egoa::PyPsaParser::AddNominalRealPowerToGeneratorExtendable
void AddNominalRealPowerToGeneratorExtendable(Types::string const &pNomExtendable, TGeneratorProperties &generatorProperty)
Changes whether the generator is extendable or not.
Definition PyPsaParser.hpp:1621
+
egoa::PyPsaParser::AddNumberOfParallelLinesToEdge
void AddNumberOfParallelLinesToEdge(Types::name const &numberParallelLines, TIoEdge &edge)
Add the number of parallel lines to the line.
Definition PyPsaParser.hpp:2360
+
egoa::PyPsaParser::AddResistanceToEdge
void AddResistanceToEdge(Types::name const &resistance, TIoEdge &edge)
Add the resistance to the line.
Definition PyPsaParser.hpp:2495
+
egoa::PyPsaParser::AddCapitalCostToGenerator
void AddCapitalCostToGenerator(Types::string const &capitalCost, TGeneratorProperties &generatorProperty)
Adds a capital cost to the generator.
Definition PyPsaParser.hpp:1892
+
egoa::PyPsaParser::AddEdge
Types::edgeId AddEdge(Graph &network, TIoEdge const &ioEdge)
Wrapper for adding an edge.
Definition PyPsaParser.hpp:697
+
egoa::PyPsaParser::filenameStorageUnitsInflow_
Types::name const filenameStorageUnitsInflow_
Definition PyPsaParser.hpp:3185
+
egoa::PyPsaParser::filenameCarriers_
Types::name const filenameCarriers_
Definition PyPsaParser.hpp:3174
+
egoa::PyPsaParser::AddConductanceToEdge
void AddConductanceToEdge(Types::name const &conductance, TIoEdge &edge)
Add the conductance to the line.
Definition PyPsaParser.hpp:2535
+
egoa::PyPsaParser::filenameLoads_
Types::name const filenameLoads_
Definition PyPsaParser.hpp:3180
+
egoa::PyPsaParser::OpenFile
bool OpenFile(QFile &file)
Opens a file.
Definition PyPsaParser.hpp:739
+
egoa::PyPsaParser::AddResistancePuToEdge
void AddResistancePuToEdge(Types::name const &resistancePu, TIoEdge &edge)
Add the resistance in p.u.
Definition PyPsaParser.hpp:2794
+
egoa::PyPsaParser::AddRealPowerSetPointToLoad
void AddRealPowerSetPointToLoad(Types::string const &pset, TLoadProperties &vertexProperty)
Add the real power load set point.
Definition PyPsaParser.hpp:3024
+
egoa::Vertices::ElectricalProperties
Class for electrical properties.
Definition ElectricalProperties.hpp:28
+ + +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_queue_8hpp_source.html b/_queue_8hpp_source.html new file mode 100644 index 00000000..806d9a31 --- /dev/null +++ b/_queue_8hpp_source.html @@ -0,0 +1,162 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/Queue.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Queue.hpp
+
+
+
1/*
+
2 * Queue.hpp
+
3 *
+
4 * Created on: Nov 18, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__QUEUE_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__QUEUE_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12
+
13namespace egoa {
+
14
+
15template<typename Type>
+
+
16class Queue {
+
17 using TElement = Type;
+
18 public:
+
19//@todo is Compare necessary? For PQ okay but standard queue?
+
20#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
21 Queue(){}
+
22
+
23 template<typename Compare, class Container>
+
24 Queue ( Compare const & compare ){}
+
25
+
26 template<class Container>
+
27 Queue ( Container const & container ){}
+
28
+
29 template<typename Compare, class Container>
+
30 Queue ( Compare const & compare, Container const & container ){}
+
31
+
32 virtual ~Queue() {}
+
33
+
34#pragma mark LOOPS
+
35 template<bool IsParallel, typename FUNCTION>
+
36 inline void for_all_elements ( FUNCTION function ) {}
+
37
+
38 template<bool IsParallel, typename FUNCTION>
+
39 inline void for_all_elements ( FUNCTION function ) const {}
+
40
+
41 template<typename FUNCTION>
+
42 inline void breakable_for_all_elements ( FUNCTION function ) {}
+
43
+
44 template<typename FUNCTION>
+
45 inline void breakable_for_all_elements ( FUNCTION function ) const {}
+
46
+
47#pragma mark ELEMENT_ACCESS
+
50 virtual inline TElement const & Top () const = 0;
+
52
+
55#pragma mark ADD_ELEMENTS
+
56 virtual inline void Push ( TElement const & element ) = 0;
+
57 virtual inline void Push ( TElement && element ) = 0;
+
58#pragma mark MODIFIERS
+
59 virtual inline void Pop () = 0;
+
60 virtual inline void Clear () = 0;
+
61 inline void Swap ( Queue & rhs) {};
+
63
+
64#pragma mark CAPACITY
+
67 virtual inline bool Empty () const = 0;
+
68 virtual inline Types::count Size () const = 0;
+
70};
+
+
71
+
72} // namespace egoa
+
73
+
74#endif // EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__QUEUE_HPP
+ +
egoa::Queue::Top
virtual TElement const & Top() const =0
+
egoa::Queue::Empty
virtual bool Empty() const =0
+
egoa::Queue::Push
virtual void Push(TElement const &element)=0
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_solver_runtime_collection_8hpp_source.html b/_solver_runtime_collection_8hpp_source.html new file mode 100644 index 00000000..7806e53b --- /dev/null +++ b/_solver_runtime_collection_8hpp_source.html @@ -0,0 +1,339 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Statistics/SolverRuntimeCollection.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SolverRuntimeCollection.hpp
+
+
+
1/*
+
2 * SolverRuntimeCollection.hpp
+
3 *
+
4 * Created on: Jan 29, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__STATISTICS__GUROBI_INFO_COLLECTION_HPP
+
9#define EGOA__IO__STATISTICS__GUROBI_INFO_COLLECTION_HPP
+
10
+
11#include "IO/Statistics/SolverRuntimeRow.hpp"
+
12#include "IO/Statistics/SolverRuntimeCollection.hpp"
+
13
+
14#include <string>
+
15#include <iostream>
+
16#include <iomanip>
+
17#include <vector>
+
18#include <fstream>
+
19
+
20using namespace std;
+
21
+
22namespace egoa::IO {
+
23
+
+
24class SolverRuntimeCollection {
+
25 public:
+
26 using TRow = SolverRuntimeRow;
+
27
+
28
+
31#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
32 SolverRuntimeCollection()
+
33 : information()
+
34 , min(), max(), avg()
+
35 , filename_("SolverRuntimeCollectionFilename")
+
36 , verbose_(false)
+
37 , name_("SolverRuntimeCollectionName")
+
38 , numberOfVertices_(0)
+
39 , numberOfEdges_(0)
+
40 {}
+
41
+
42 SolverRuntimeCollection ( Types::string filename
+
43 , bool verbose
+
44 , Types::string name
+
45 )
+
46 : information()
+
47 , min(), max(), avg()
+
48 , filename_(filename)
+
49 , verbose_(verbose)
+
50 , name_(name)
+
51 , numberOfVertices_(0)
+
52 , numberOfEdges_(0)
+
53 { }
+
55
+
58#pragma mark OPERATORS
+
59 inline SolverRuntimeCollection & operator+= ( TRow & rhs )
+
60 {
+
61 if (verbose_)
+
62 {
+
63 rhs.Name = name_;
+
64 rhs.NumberOfEdges = numberOfEdges_;
+
65 DumpLine ( filename_, rhs, false );
+
66 }
+
67 else information.push_back(rhs);
+
68 return *this;
+
69 }
+
70
+
71 inline void AddMeta ( Types::name name
+
72 , Types::count nrVertices
+
73 , Types::count nrEdges
+
74 )
+
75 {
+
76 for ( auto & info : information )
+
77 {
+
78 info.Name = name;
+
79 info.NumberOfVertices = nrVertices;
+
80 info.NumberOfEdges = nrEdges;
+
81 }
+
82 }
+
83
+
84 // Compute statistics.
+
85 inline void ComputeStatistics()
+
86 {
+
87 if ( information.empty() ) return;
+
88
+
89 // Compute average, minimum, and maximum.
+
90 avg = information[0];
+
91 min = information[0];
+
92 max = information[0];
+
93
+
94 for ( size_t i = 1; i < information.size(); ++i )
+
95 {
+
96 avg += information[i];
+
97 min.Min(information[i]);
+
98 max.Max(information[i]);
+
99 }
+
100 avg /= information.size();
+
101 }
+
103
+
104
+
107#pragma mark OUTPUT
+
108
+
109 inline void Dump ( ostream & os )
+
110 {
+
111 if ( information.empty() ) return;
+
112 // ComputeStatistics();
+
113 os << "\n"
+
114 << "Statistics:" << std::endl
+
115 << "-----------" << std::endl
+
116
+
117 << std::setprecision(2)
+
118 << std::fixed
+
119
+
120 << setw(30) << "Problem: " << setw(8) << information[0].NameOfProblem << ", " << std::endl
+
121 << setw(30) << "Name: " << setw(8) << information[0].Name << ", " << std::endl
+
122
+
123 << setw(30) << "Number of vertices: " << setw(8) << information[0].NumberOfVertices << ", " << std::endl
+
124 << setw(30) << "Number of edges: " << setw(8) << information[0].NumberOfEdges << ", " << std::endl
+
125
+
126 << setw(30) << "Total time: " << setw(8) << avg.OptimizationRuntimeSeconds << setw(11) << " sec (avg), "
+
127 << setw(8) << min.OptimizationRuntimeSeconds << setw(11) << " sec (min), "
+
128 << setw(8) << max.OptimizationRuntimeSeconds << setw(11) << " sec (max)" << std::endl
+
129
+
130 << setw(30) << "Solutions: " << setw(8) << avg.Solution << setw(11) << " (avg), "
+
131 << setw(8) << min.Solution << setw(11) << " (min), "
+
132 << setw(8) << max.Solution << setw(11) << " (max)" << std::endl
+
133
+
134 << setw(30) << "MipGap: " << setw(8) << avg.MipGap << setw(11) << " (avg), "
+
135 << setw(8) << min.MipGap << setw(11) << " (min), "
+
136 << setw(8) << max.MipGap << setw(11) << " (max)" << std::endl
+
137
+
138 << setw(30) << "Upper bound: " << setw(8) << avg.UpperBound << setw(11) << " (avg), "
+
139 << setw(8) << min.UpperBound << setw(11) << " (min), "
+
140 << setw(8) << max.UpperBound << setw(11) << " (max)" << std::endl
+
141
+
142 << setw(30) << "Lower bound: " << setw(8) << avg.LowerBound << setw(11) << " (avg), "
+
143 << setw(8) << min.LowerBound << setw(11) << " (min), "
+
144 << setw(8) << max.LowerBound << setw(11) << " (max)" << std::endl
+
145
+
146 << setw(30) << "NumberOfVariables: " << setw(8) << avg.NumberOfVariables << setw(11) << " (avg), "
+
147 << setw(8) << min.NumberOfVariables << setw(11) << " (min), "
+
148 << setw(8) << max.NumberOfVariables << setw(11) << " (max)" << std::endl
+
149 << setw(30) << "NumberOfConstraints: " << setw(8) << avg.NumberOfConstraints << setw(11) << " (avg), "
+
150 << setw(8) << min.NumberOfConstraints << setw(11) << " (min), "
+
151 << setw(8) << max.NumberOfConstraints << setw(11) << " (max)" << std::endl
+
152 << setw(30) << "NumberOfConstraints: " << setw(8) << avg.NumberOfSoS << setw(11) << " (avg), "
+
153 << setw(8) << min.NumberOfSoS << setw(11) << " (min), "
+
154 << setw(8) << max.NumberOfSoS << setw(11) << " (max)" << std::endl
+
155 << setw(30) << "NumberOfQConstrains: " << setw(8) << avg.NumberOfQConstrains << setw(11) << " (avg), "
+
156 << setw(8) << min.NumberOfQConstrains << setw(11) << " (min), "
+
157 << setw(8) << max.NumberOfQConstrains << setw(11) << " (max)" << std::endl
+
158 << setw(30) << "NumberOfQConstrains: " << setw(8) << avg.NumberOfGenConstrains << setw(11) << " (avg), "
+
159 << setw(8) << min.NumberOfGenConstrains << setw(11) << " (min), "
+
160 << setw(8) << max.NumberOfGenConstrains << setw(11) << " (max)" << std::endl
+
161 << setw(30) << "NumberOfNZs: " << setw(8) << avg.NumberOfNZs << setw(11) << " (avg), "
+
162 << setw(8) << min.NumberOfNZs << setw(11) << " (min), "
+
163 << setw(8) << max.NumberOfNZs << setw(11) << " (max)" << std::endl
+
164 << setw(30) << "NumberOfIntVars: " << setw(8) << avg.NumberOfIntVars << setw(11) << " (avg), "
+
165 << setw(8) << min.NumberOfIntVars << setw(11) << " (min), "
+
166 << setw(8) << max.NumberOfIntVars << setw(11) << " (max)" << std::endl
+
167 << setw(30) << "NumberOfBinaryVars: " << setw(8) << avg.NumberOfBinaryVars << setw(11) << " (avg), "
+
168 << setw(8) << min.NumberOfBinaryVars << setw(11) << " (min), "
+
169 << setw(8) << max.NumberOfBinaryVars << setw(11) << " (max)" << std::endl
+
170 << std::endl;
+
171 }
+
172
+
173 inline void DumpLine ( Types::string const filename
+
174 , TRow const & info
+
175 , bool const overwrite = false ) const
+
176 {
+
177#ifndef NDEBUG
+
178 qDebug() << "Dumping debug data to: " << QString::fromStdString(filename);
+
179#endif
+
180 // Open output stream.
+
181 // ofstream f(filename);
+
182 std::ofstream f;
+
183 overwrite?f.open(filename, std::ofstream::trunc):f.open(filename, std::ofstream::app);
+
184 if (!f.is_open()) return;
+
185
+
186 // GurobiInfo::Header(f);
+
187 // file is empty
+
188 f.seekp(0, ios::end);
+
189 if ( f.tellp() == 0 ) { TRow::Header(f); }
+
190
+
191 info.Content(f);
+
192 }
+
193
+
194 inline void Dump ( std::string const filename
+
195 , bool const overwrite = true ) const
+
196 {
+
197#ifdef NDEBUG
+
198 qDebug() << "Dumping debug data to: " << QString::fromStdString(filename);
+
199#endif
+
200 // Open output stream.
+
201 // ofstream f(filename);
+
202 std::ofstream f;
+
203 overwrite?f.open(filename, std::ofstream::trunc):f.open(filename, std::ofstream::app);
+
204 if (!f.is_open()) return;
+
205
+
206 // GurobiInfo::Header(f);
+
207 // file is empty
+
208 f.seekp(0, ios::end);
+
209 if ( f.tellp() == 0 ) { TRow::Header(f); }
+
210
+
211 for ( const auto & info : information ) { info.Content(f); }
+
212 }
+
214
+
215
+
216 inline Types::count NumberOfVertices () const { return numberOfVertices_; }
+
217 inline Types::count & NumberOfVertices () { return numberOfVertices_; }
+
218
+
219 inline Types::count NumberOfEdges () const { return numberOfEdges_; }
+
220 inline Types::count & NumberOfEdges () { return numberOfEdges_; }
+
221
+
222 private:
+
225#pragma mark MEMBER
+
226 vector<TRow> information;
+
227 TRow min, max, avg;
+
228
+
229 Types::name filename_;
+
230 bool verbose_;
+
231
+
232 Types::name problemName_;
+
233 Types::name name_;
+
234
+
235 Types::count numberOfVertices_;
+
236 Types::count numberOfEdges_;
+
238};
+
+
239
+
240} // namespace egoa::IO
+
241
+
242#endif // EGOA__IO__STATISTICS__GUROBI_INFO_COLLECTION_HPP
+ +
egoa::IO::SolverRuntimeRow
A struct representing one row of the statistics for mathematical models.
Definition SolverRuntimeRow.hpp:23
+ + + + + + + + + + + + + + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_solver_runtime_row_8hpp_source.html b/_solver_runtime_row_8hpp_source.html new file mode 100644 index 00000000..771ad353 --- /dev/null +++ b/_solver_runtime_row_8hpp_source.html @@ -0,0 +1,310 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Statistics/SolverRuntimeRow.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SolverRuntimeRow.hpp
+
+
+
1/*
+
2 * SolverRuntimeRow.hpp
+
3 *
+
4 * Created on: Jan 29, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__STATISTICS__GUROBI_INFO_HPP
+
9#define EGOA__IO__STATISTICS__GUROBI_INFO_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12
+
13#include <iostream>
+
14#include <vector>
+
15
+
16namespace egoa::IO {
+
17
+
+
23 struct SolverRuntimeRow {
+
24
+
25 Types::name NameOfProblem;
+
26 Types::name Name;
+
28 Types::count NumberOfVertices;
+
29 Types::count NumberOfEdges;
+
31 Types::real Solution;
+
32 Types::real OptimizationRuntimeSeconds;
+
33 Types::real BuildingRuntimeSeconds;
+
35 Types::string Status;
+
36 Types::real MipGap;
+
37 Types::real UpperBound;
+
38 Types::real LowerBound;
+
39 Types::count NumberOfVariables;
+
40 Types::count NumberOfConstraints;
+
41 Types::count NumberOfSoS;
+
42 Types::count NumberOfQConstrains;
+
43 Types::count NumberOfGenConstrains;
+
44 Types::count NumberOfNZs;
+
45 Types::count NumberOfIntVars;
+
46 Types::count NumberOfBinaryVars;
+
48 SolverRuntimeRow() :
+
49 NameOfProblem(""),
+
50 Name(""),
+
51
+
52 NumberOfVertices(0),
+
53 NumberOfEdges(0),
+
54
+
55 Solution(0.0),
+
56 OptimizationRuntimeSeconds(0.0),
+
57 BuildingRuntimeSeconds(0.0),
+
58
+
59 Status("unknown"),
+
60
+
61 MipGap(0.0),
+
62 UpperBound(0.0),
+
63 LowerBound(0.0),
+
64 NumberOfVariables(0),
+
65 NumberOfConstraints(0),
+
66 NumberOfSoS(0),
+
67 NumberOfQConstrains(0),
+
68 NumberOfGenConstrains(0),
+
69 NumberOfNZs(0),
+
70 NumberOfIntVars(0),
+
71 NumberOfBinaryVars(0)
+
72 {}
+
73
+
74 inline static void Header ( std::ostream & os ) {
+
75 os
+
76 << "NameOfProblem" << ",\t"
+
77 << "Name" << ",\t"
+
78
+
79 << "NumberOfVertices" << ",\t"
+
80 << "NumberOfEdges" << ",\t"
+
81
+
82 << "Solution" << ",\t"
+
83 << "OptimizationRuntimeSeconds" << ",\t"
+
84 << "BuildingRuntimeSeconds" << ",\t"
+
85
+
86 << "Status" << ",\t"
+
87 << "MipGap" << ",\t"
+
88 << "UpperBound" << ",\t"
+
89 << "LowerBound" << ",\t"
+
90 << "NumberOfVariables" << ",\t"
+
91 << "NumberOfConstraints" << ",\t"
+
92 << "NumberOfSoS" << ",\t"
+
93 << "NumberOfQConstrains" << ",\t"
+
94 << "NumberOfGenConstrains" << ",\t"
+
95 << "NumberOfNZs" << ",\t"
+
96 << "NumberOfIntVars" << ",\t"
+
97 << "NumberOfBinaryVars" << ""
+
98
+
99 << std::endl;
+
100 }
+
101
+
102 inline void Content ( std::ostream & os ) const {
+
103 os
+
104 << NameOfProblem << ",\t"
+
105 << Name << ",\t"
+
106
+
107 << NumberOfVertices << ",\t"
+
108 << NumberOfEdges << ",\t"
+
109
+
110 << Solution << ",\t"
+
111 << OptimizationRuntimeSeconds << ",\t"
+
112 << BuildingRuntimeSeconds << ",\t"
+
113
+
114 << Status << ",\t"
+
115 << MipGap << ",\t"
+
116 << UpperBound << ",\t"
+
117 << LowerBound << ",\t"
+
118 << NumberOfVariables << ",\t"
+
119 << NumberOfConstraints << ",\t"
+
120 << NumberOfSoS << ",\t"
+
121 << NumberOfQConstrains << ",\t"
+
122 << NumberOfGenConstrains << ",\t"
+
123 << NumberOfNZs << ",\t"
+
124 << NumberOfIntVars << ",\t"
+
125 << NumberOfBinaryVars << ""
+
126
+
127 << std::endl;
+
128 }
+
129
+
130 inline SolverRuntimeRow& operator+= ( const SolverRuntimeRow &rhs ) {
+
131 Solution += rhs.Solution;
+
132 OptimizationRuntimeSeconds += rhs.OptimizationRuntimeSeconds;
+
133 BuildingRuntimeSeconds += rhs.BuildingRuntimeSeconds;
+
134
+
135 MipGap += rhs.MipGap;
+
136 UpperBound += rhs.UpperBound;
+
137 LowerBound += rhs.LowerBound;
+
138 NumberOfVariables += rhs.NumberOfVariables;
+
139 NumberOfConstraints += rhs.NumberOfConstraints;
+
140 NumberOfSoS += rhs.NumberOfSoS;
+
141 NumberOfQConstrains += rhs.NumberOfQConstrains;
+
142 NumberOfGenConstrains += rhs.NumberOfGenConstrains;
+
143 NumberOfNZs += rhs.NumberOfNZs;
+
144 NumberOfIntVars += rhs.NumberOfIntVars;
+
145 NumberOfBinaryVars += rhs.NumberOfBinaryVars;
+
146
+
147 return *this;
+
148 }
+
149
+
150 inline SolverRuntimeRow& operator/= ( int rhs ) {
+
151 Solution /= rhs;
+
152 OptimizationRuntimeSeconds /= rhs;
+
153 BuildingRuntimeSeconds /= rhs;
+
154
+
155 MipGap /= rhs;
+
156 UpperBound /= rhs;
+
157 LowerBound /= rhs;
+
158 NumberOfVariables /= rhs;
+
159 NumberOfConstraints /= rhs;
+
160 NumberOfSoS /= rhs;
+
161 NumberOfQConstrains /= rhs;
+
162 NumberOfGenConstrains /= rhs;
+
163 NumberOfNZs /= rhs;
+
164 NumberOfIntVars /= rhs;
+
165 NumberOfBinaryVars /= rhs;
+
166
+
167 return *this;
+
168 }
+
169
+
170 inline void Min(const SolverRuntimeRow &rhs) {
+
171 Solution = std::min( Solution, rhs.Solution );
+
172 OptimizationRuntimeSeconds= std::min( OptimizationRuntimeSeconds, rhs.OptimizationRuntimeSeconds);
+
173
+
174 MipGap = std::min( MipGap, rhs.MipGap );
+
175 UpperBound = std::min( UpperBound, rhs.UpperBound );
+
176 LowerBound = std::min( LowerBound, rhs.LowerBound );
+
177 NumberOfVariables = std::min( NumberOfVariables, rhs.NumberOfVariables );
+
178 NumberOfConstraints = std::min( NumberOfConstraints, rhs.NumberOfConstraints );
+
179 NumberOfSoS = std::min( NumberOfSoS, rhs.NumberOfSoS );
+
180 NumberOfQConstrains = std::min( NumberOfQConstrains, rhs.NumberOfQConstrains );
+
181 NumberOfGenConstrains = std::min( NumberOfGenConstrains, rhs.NumberOfGenConstrains);
+
182 NumberOfNZs = std::min( NumberOfNZs, rhs.NumberOfNZs );
+
183 NumberOfIntVars = std::min( NumberOfIntVars, rhs.NumberOfIntVars );
+
184 NumberOfBinaryVars = std::min( NumberOfBinaryVars, rhs.NumberOfBinaryVars );
+
185 }
+
186
+
187 inline void Max(const SolverRuntimeRow &rhs) {
+
188 Solution = std::max( Solution, rhs.Solution );
+
189 OptimizationRuntimeSeconds= std::max( OptimizationRuntimeSeconds, rhs.OptimizationRuntimeSeconds);
+
190
+
191 MipGap = std::max( MipGap, rhs.MipGap );
+
192 UpperBound = std::max( UpperBound, rhs.UpperBound );
+
193 LowerBound = std::max( LowerBound, rhs.LowerBound );
+
194 NumberOfVariables = std::max( NumberOfVariables, rhs.NumberOfVariables );
+
195 NumberOfConstraints = std::max( NumberOfConstraints, rhs.NumberOfConstraints );
+
196 NumberOfSoS = std::max( NumberOfSoS, rhs.NumberOfSoS );
+
197 NumberOfQConstrains = std::max( NumberOfQConstrains, rhs.NumberOfQConstrains );
+
198 NumberOfGenConstrains = std::max( NumberOfGenConstrains, rhs.NumberOfGenConstrains);
+
199 NumberOfNZs = std::max( NumberOfNZs, rhs.NumberOfNZs );
+
200 NumberOfIntVars = std::max( NumberOfIntVars, rhs.NumberOfIntVars );
+
201 NumberOfBinaryVars = std::max( NumberOfBinaryVars, rhs.NumberOfBinaryVars );
+
202 }
+
203};
+
+
204
+
205} // namespace egoa::IO
+
206
+
207#endif // EGOA__IO__STATISTICS__GUROBI_INFO_HPP
+
egoa::IO::SolverRuntimeRow
A struct representing one row of the statistics for mathematical models.
Definition SolverRuntimeRow.hpp:23
+ + + + + + + + + + + + + + + + + + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_static_graph_8hpp_source.html b/_static_graph_8hpp_source.html new file mode 100644 index 00000000..9686f16b --- /dev/null +++ b/_static_graph_8hpp_source.html @@ -0,0 +1,966 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/StaticGraph.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
StaticGraph.hpp
+
+
+
1/*
+
2 * StaticGraph.hpp
+
3 *
+
4 * Created on: Nov 04, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__STATIC_GRAPH_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__STATIC_GRAPH_HPP
+
10
+
11#include <algorithm>
+
12#include <tuple>
+
13#include <type_traits>
+
14
+
15#include "Auxiliary/ExecutionPolicy.hpp"
+
16
+
17#include "DataStructures/Iterators/StaticGraphIterators.hpp"
+
18#include "DataStructures/Views/VectorView.hpp"
+
19
+
20#include "Exceptions/Assertions.hpp"
+
21
+
22#include "DataStructures/Graphs/Edges/Edge.hpp"
+
23#include "DataStructures/Graphs/Vertices/Vertex.hpp"
+
24
+
25namespace egoa {
+
26
+
50template< typename VertexProperties
+
51 , typename EdgeProperties>
+
+
52class StaticGraph {
+
53 public:
+
54 // Template type aliasing
+
55 using TGraph = StaticGraph<VertexProperties
+
56 , EdgeProperties>;
+
57 // Vertices
+
58 using TVertexProperties = VertexProperties;
+
59 using TVertex = Vertices::Vertex<TVertexProperties>;
+
60 using TVertexId = Types::vertexId;
+
61 // Edges
+
62 using TEdgeProperties = EdgeProperties;
+
63 using TEdge = Edges::Edge<TEdgeProperties>;
+
64 using TEdgeId = Types::edgeId;
+
65 // Views
+
66 using TVerticesView = VectorView<TVertex, false>;
+
67 using TConstVerticesView = VectorView<TVertex, true>;
+
68 using TEdgesView = VectorView<TEdge, false>;
+
69 using TConstEdgesView = VectorView<TEdge, true>;
+
70
+
73#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
74
+
75 StaticGraph()
+
76 : name_("")
+
77 {}
+
78
+
79 explicit StaticGraph ( Types::name name )
+
80 : name_(std::move(name))
+
81 {}
+
83
+
86#pragma mark GETTER_AND_SETTER
+
87
+
+
93 inline Types::name Name() const
+
94 {
+
95 return name_;
+
96 }
+
+
97
+
+
103 inline Types::count NumberOfVertices() const
+
104 {
+
105 return vertices_.size();
+
106 }
+
+
107
+
+
113 inline Types::count NumberOfEdges() const
+
114 {
+
115 return edges_.size();
+
116 }
+
+
118
+
119
+
122#pragma mark VERTEX_RELATED_METHODS
+
123
+
+
136 inline TVerticesView Vertices()
+
137 {
+
138 return TVerticesView( & vertices_ );
+
139 }
+
+
140
+
+
155 inline TConstVerticesView Vertices() const
+
156 {
+
157 return TConstVerticesView( & vertices_ );
+
158 }
+
+
159
+
+
168 inline bool VertexExists ( Types::vertexId id ) const
+
169 {
+
170 return id < NumberOfVertices();
+
171 }
+
+
172
+
+
182 inline TVertex & VertexAt ( Types::vertexId id )
+
183 {
+
184 USAGE_ASSERT ( VertexExists(id) );
+
185 return vertices_[id];
+
186 }
+
+
187
+
+
197 inline TVertex const & VertexAt ( Types::vertexId id ) const
+
198 {
+
199 USAGE_ASSERT ( VertexExists(id) );
+
200 return vertices_[id];
+
201 }
+
+
202
+
203 // Avoid implicit conversions on non-constructing functions
+
204 inline TVertex & VertexAt ( int id ) = delete;
+
205 inline TVertex & VertexAt ( char id ) = delete;
+
206 inline TVertex const & VertexAt ( int id ) const = delete;
+
207 inline TVertex const & VertexAt ( char id ) const = delete;
+
208
+
+
217 inline Types::vertexId VertexId ( TVertex const & vertex ) const
+
218 {
+
219 return vertex.Identifier();
+
220 }
+
+
221
+
+
229 inline Types::vertexId AddVertex ( TVertexProperties const & properties )
+
230 {
+
231 return AddVertex( TVertexProperties(properties) );
+
232 }
+
+
233
+
+
241 inline Types::vertexId AddVertex ( TVertexProperties && properties )
+
242 {
+
243 Types::vertexId id = vertices_.size();
+
244 vertices_.emplace_back( id, std::move(properties) );
+
245 inEdgeIds_.emplace_back( std::vector<Types::edgeId>() );
+
246 outEdgeIds_.emplace_back( std::vector<Types::edgeId>() );
+
247
+
248 ESSENTIAL_ASSERT ( vertices_.size() == NumberOfVertices() );
+
249 ESSENTIAL_ASSERT ( inEdgeIds_.size() == NumberOfVertices() );
+
250 ESSENTIAL_ASSERT ( outEdgeIds_.size() == NumberOfVertices() );
+
251
+
252 return id;
+
253 }
+
+
254
+
255 // TODO: Write EmplaceVertex?
+
256
+
271 template<typename FUNCTION>
+
+
272 inline auto MapVertices ( FUNCTION function ) const
+
273 -> std::vector<decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()))>
+
274 {
+
275 using TResult = decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()));
+
276 std::vector<TResult> result;
+
277
+
278 for_all_vertex_tuples<ExecutionPolicy::sequential>(
+
279 [&]( Types::vertexId id, const TVertex & vertex )
+
280 {
+
281 result.push_back ( function(id, vertex) );
+
282 }
+
283 );
+
284
+
285 return result;
+
286 }
+
+
287
+
+
300 inline std::vector<Types::vertexId> NeighborsOf ( Types::vertexId id ) const
+
301 {
+
302 USAGE_ASSERT ( VertexExists(id) );
+
303
+
304 std::vector<Types::vertexId> vertexIds;
+
305 NeighborsOf(id, vertexIds);
+
306 return vertexIds;
+
307 }
+
+
308
+
+
323 inline void NeighborsOf ( Types::vertexId id
+
324 , std::vector<Types::vertexId> & vertexIds ) const
+
325 {
+
326 USAGE_ASSERT ( VertexExists(id) );
+
327
+
328 std::vector<bool> vertexVisited(NumberOfVertices(), false);
+
329
+
330 for (Types::edgeId edgeId : OutEdgeIdsAt(id))
+
331 {
+
332 Types::vertexId otherVertex = EdgeAt(edgeId).Target();
+
333 if (!vertexVisited[otherVertex])
+
334 {
+
335 vertexIds.push_back(otherVertex);
+
336 vertexVisited[otherVertex] = true;
+
337 }
+
338 }
+
339 for (Types::edgeId edgeId : InEdgeIdsAt(id))
+
340 {
+
341 Types::vertexId otherVertex = EdgeAt(edgeId).Source();
+
342 if (!vertexVisited[otherVertex])
+
343 {
+
344 vertexIds.push_back(otherVertex);
+
345 vertexVisited[otherVertex] = true;
+
346 }
+
347 }
+
348 }
+
+
349
+
+
359 inline Types::count InDegreeAt ( Types::vertexId id ) const
+
360 {
+
361 USAGE_ASSERT ( VertexExists(id) );
+
362 return InEdgeIdsAt(id).size();
+
363 }
+
+
364
+
+
374 inline Types::count OutDegreeAt ( Types::vertexId id ) const
+
375 {
+
376 USAGE_ASSERT ( VertexExists(id) );
+
377 return OutEdgeIdsAt(id).size();
+
378 }
+
+
379
+
+
389 inline Types::count DegreeAt ( Types::vertexId id ) const
+
390 {
+
391 USAGE_ASSERT ( VertexExists(id) );
+
392 return InDegreeAt(id) + OutDegreeAt(id);
+
393 }
+
+
394
+
+
404 inline std::vector<Types::edgeId> const & InEdgeIdsAt ( Types::vertexId id ) const
+
405 {
+
406 USAGE_ASSERT ( VertexExists(id) );
+
407 return inEdgeIds_[id];
+
408 }
+
+
409
+
+
419 inline std::vector<Types::edgeId> const & OutEdgeIdsAt ( Types::vertexId id ) const
+
420 {
+
421 USAGE_ASSERT ( VertexExists(id) );
+
422 return outEdgeIds_[id];
+
423 }
+
+
424
+
+
435 inline std::vector<Types::edgeId> EdgeIdsAt ( Types::vertexId id ) const
+
436 {
+
437 USAGE_ASSERT ( VertexExists(id) );
+
438
+
439 std::vector<Types::edgeId> edgeIds;
+
440 EdgeIdsAt(id, edgeIds);
+
441 return edgeIds;
+
442 }
+
+
443
+
+
456 inline void EdgeIdsAt ( Types::vertexId id
+
457 , std::vector<Types::edgeId> & edgeIds ) const
+
458 {
+
459 USAGE_ASSERT ( VertexExists(id) );
+
460
+
461 auto & inIds = InEdgeIdsAt(id);
+
462 auto & outIds = OutEdgeIdsAt(id);
+
463 edgeIds.insert( edgeIds.end(), inIds.begin(), inIds.end() );
+
464 edgeIds.insert( edgeIds.end(), outIds.begin(), outIds.end() );
+
465 }
+
+
467
+
470#pragma mark EDGE_RELATED_METHODS
+
471
+
+
486 inline TEdgesView Edges()
+
487 {
+
488 return TEdgesView ( & edges_ );
+
489 }
+
+
490
+
+
505 inline TConstEdgesView Edges() const
+
506 {
+
507 return TConstEdgesView ( & edges_ );
+
508 }
+
+
509
+
+
519 inline bool EdgeExists ( Types::edgeId id ) const
+
520 {
+
521 return id < NumberOfEdges();
+
522 }
+
+
523
+
+
533 inline TEdge & EdgeAt ( Types::edgeId id )
+
534 {
+
535 USAGE_ASSERT ( EdgeExists(id) );
+
536 return edges_[id];
+
537 }
+
+
538
+
+
548 inline TEdge const & EdgeAt ( Types::edgeId id ) const
+
549 {
+
550 USAGE_ASSERT ( EdgeExists(id) );
+
551 return edges_[id];
+
552 }
+
+
553
+
+
569 inline Types::edgeId EdgeId ( Types::vertexId source
+
570 , Types::vertexId target ) const
+
571 {
+
572 USAGE_ASSERT ( VertexExists(source) );
+
573 USAGE_ASSERT ( VertexExists(target) );
+
574
+
575 if ( OutDegreeAt(source) <= InDegreeAt(target) )
+
576 {
+
577 for ( Types::edgeId id : outEdgeIds_[source] )
+
578 {
+
579 if ( EdgeAt(id).Target() == target )
+
580 return id;
+
581 }
+
582 } else {
+
583 for (Types::edgeId id : inEdgeIds_[target])
+
584 {
+
585 if ( EdgeAt(id).Source() == source )
+
586 return id;
+
587 }
+
588 }
+
589
+
590 return Const::NONE;
+
591 }
+
+
592
+
+
606 inline TEdge & Edge ( Types::vertexId source
+
607 , Types::vertexId target )
+
608 {
+
609 USAGE_ASSERT ( VertexExists(source) );
+
610 USAGE_ASSERT ( VertexExists(target) );
+
611 Types::edgeId id = EdgeId( source, target );
+
612 USAGE_ASSERT ( id != Const::NONE );
+
613
+
614 return EdgeAt( id );
+
615 }
+
+
616
+
+
630 inline TEdge const & Edge ( Types::vertexId source
+
631 , Types::vertexId target ) const
+
632 {
+
633 USAGE_ASSERT ( VertexExists(source) );
+
634 USAGE_ASSERT ( VertexExists(target) );
+
635 Types::edgeId id = EdgeId( source, target );
+
636 USAGE_ASSERT ( id != Const::NONE );
+
637
+
638 return EdgeAt ( id );
+
639 }
+
+
640
+
+
652 inline Types::edgeId AddEdge ( Types::vertexId source,
+
653 Types::vertexId target,
+
654 TEdgeProperties const & properties )
+
655 {
+
656 USAGE_ASSERT ( VertexExists(source) );
+
657 USAGE_ASSERT ( VertexExists(target) );
+
658 return AddEdge ( source, target, TEdgeProperties(properties) );
+
659 }
+
+
660
+
+
672 inline Types::edgeId AddEdge ( Types::vertexId source,
+
673 Types::vertexId target,
+
674 TEdgeProperties && properties )
+
675 {
+
676 USAGE_ASSERT ( VertexExists(source) );
+
677 USAGE_ASSERT ( VertexExists(target) );
+
678
+
679 Types::edgeId id = edges_.size();
+
680
+
681 edges_.emplace_back ( id, source, target, std::move(properties) );
+
682
+
683 ESSENTIAL_ASSERT ( target < inEdgeIds_.size() );
+
684 ESSENTIAL_ASSERT ( source < outEdgeIds_.size() );
+
685 inEdgeIds_[target].emplace_back(id);
+
686 outEdgeIds_[source].emplace_back(id);
+
687
+
688 ESSENTIAL_ASSERT ( edges_.size() == NumberOfEdges() );
+
689
+
690 return id;
+
691 }
+
+
692
+
707 template<typename FUNCTION>
+
+
708 inline auto MapEdges ( FUNCTION function ) const
+
709 -> std::vector<decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()))>
+
710 {
+
711 using TResult = decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()));
+
712 std::vector<TResult> result;
+
713
+
714 for_all_edge_tuples<ExecutionPolicy::sequential>(
+
715 [&]( Types::edgeId id, TEdge const & edge )
+
716 {
+
717 result.push_back(function(id, edge));
+
718 }
+
719 );
+
720
+
721 return result;
+
722 }
+
+
723
+
724 // Avoid implicit conversions on non-constructing functions
+
725 inline TEdge & EdgeAt ( int index ) = delete;
+
726 inline TEdge & EdgeAt ( char index ) = delete;
+
727 inline TEdge const & EdgeAt ( int index ) const = delete;
+
728 inline TEdge const & EdgeAt ( char index ) const = delete;
+
729 inline Types::edgeId EdgeId ( int source, int target ) const = delete;
+
730 inline Types::edgeId EdgeId ( char source, char target ) const = delete;
+
731 inline Types::edgeId EdgeId ( int source, char target ) const = delete;
+
732 inline Types::edgeId EdgeId ( char source, int target ) const = delete;
+
733 inline TEdge & Edge ( int source, int target ) = delete;
+
734 inline TEdge & Edge ( char source, char target ) = delete;
+
735 inline TEdge & Edge ( char source, int target ) = delete;
+
736 inline TEdge & Edge ( int source, char target ) = delete;
+
737 inline TEdge const & Edge ( int source, int target ) const = delete;
+
738 inline TEdge const & Edge ( char source, char target ) const = delete;
+
739 inline TEdge const & Edge ( int source, char target ) const = delete;
+
740 inline TEdge const & Edge ( char source, int target ) const = delete;
+
742
+
745#pragma mark GRAPH_PROPERTIES
+
+
758 inline Types::count MinDegree ( Types::vertexId & id ) const
+
759 {
+
760 if (NumberOfVertices() == 0)
+
761 {
+
762 id = Const::NONE;
+
763 return 0;
+
764 }
+
765 auto result = std::min_element( vertices_.begin()
+
766 , vertices_.end()
+
767 , [this]( TVertex const & left, TVertex const & right)
+
768 {
+
769 return DegreeAt(left.Identifier()) < DegreeAt(right.Identifier());
+
770 }
+
771 );
+
772 id = result->Identifier();
+
773 return DegreeAt(id);
+
774 }
+
+
775
+
+
783 inline Types::count MinDegree() const
+
784 {
+
785 Types::vertexId dummy = 0;
+
786 return MinDegree(dummy);
+
787 }
+
+
788
+
+
803 inline Types::count MaxDegree ( Types::vertexId & id ) const
+
804 {
+
805 if (NumberOfVertices() == 0)
+
806 {
+
807 id = Const::NONE;
+
808 return 0;
+
809 }
+
810 auto result = std::max_element ( vertices_.begin()
+
811 , vertices_.end()
+
812 , [this](const TVertex & left, TVertex const & right)
+
813 {
+
814 return DegreeAt(left.Identifier()) < DegreeAt(right.Identifier());
+
815 }
+
816 );
+
817 id = result->Identifier();
+
818 return DegreeAt(id);
+
819 }
+
+
820
+
+
828 inline Types::count MaxDegree() const
+
829 {
+
830 Types::vertexId dummy = 0;
+
831 return MaxDegree(dummy);
+
832 }
+
+
834
+
837#pragma mark OUTPUT
+
838
+
+
844 inline void DumpBuses ( std::ostream & outputStream ) const
+
845 {
+
846 TVertexProperties::Header(outputStream);
+
847 for_all_vertices<ExecutionPolicy::sequential> (
+
848 [&]( TVertex const & u )
+
849 {
+
850 u.Properties().Line( outputStream );
+
851 }
+
852 );
+
853 }
+
+
854
+
+
860 inline void DumpBranches ( std::ostream & outputStream ) const
+
861 {
+
862 TEdgeProperties::Header(outputStream);
+
863 for_all_edges<ExecutionPolicy::sequential>(
+
864 [&]( TEdge const & e )
+
865 {
+
866 e.Properties().Line( outputStream
+
867 , VertexAt(e.Source()).Properties().Name()
+
868 , VertexAt(e.Target()).Properties().Name() );
+
869 }
+
870 );
+
871 }
+
+
872
+
+
881 friend std::ostream & operator<< ( std::ostream & outputStream
+
882 , StaticGraph const & rhs )
+
883 {
+
884 outputStream << std::string('-', 20);
+
885
+
886 outputStream << "\nBuses\n" << std::string(7, '-') << "\n";
+
887 rhs.DumpBuses(outputStream);
+
888
+
889 outputStream << "\nBranches\n" << std::string(9, '-') << "\n";
+
890 rhs.DumpBranches(outputStream);
+
891
+
892 outputStream << "\nMinDegree: " << rhs.MinDegree() << "\n";
+
893 outputStream << "MaxDegree: " << rhs.MaxDegree() << "\n";
+
894
+
895 return outputStream;
+
896 }
+
+
898
+
901#pragma mark VERTEX_LOOPS
+
921 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
922 inline
+ +
928
+
947 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
948 inline
+ +
954
+
973 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
974 inline
+ +
980
+
1001 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1002 inline
+ +
1008
+
1028 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1029 inline
+ +
1036
+
1039#pragma mark EDGE_LOOPS
+
1059 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1060 inline
+ +
1066
+
1085 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1086 inline
+ +
1092
+
1111 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1112 inline
+ +
1118
+
1139 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1140 inline
+ +
1146
+
1167 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1168 inline
+ +
1175
+
1178#pragma mark NEIGHBORHOOD_LOOPS
+
1200 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1201 inline
+ +
1208
+
1230 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1231 inline
+ +
1238
+
1262 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1263 inline
+
+
1264 void for_all_edges_at ( Types::vertexId const vertexId
+
1265 , FUNCTION function )
+
1266 {
+
1267 USAGE_ASSERT( VertexExists(vertexId) );
+
1268 internal::StaticGraphLoopDifferentiation<TGraph, Policy>
+
1269 ::for_all_edges_at ( *this, vertexId, function );
+
1270 }
+
+
1271
+
1296 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1297 inline
+
+
1298 void for_all_edges_at ( Types::vertexId const vertexId
+
1299 , FUNCTION function ) const
+
1300 {
+
1301 USAGE_ASSERT( VertexExists(vertexId) );
+
1302 internal::StaticGraphLoopDifferentiation<TGraph const, Policy>
+
1303 ::for_all_edges_at ( *this, vertexId, function );
+
1304 }
+
+
1305
+
1326 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1327 inline
+ +
1334
+
1355 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1356 inline
+ +
1363
+
1385 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1386 inline
+
+
1387 void for_in_edges_at ( Types::vertexId vertexId
+
1388 , FUNCTION function )
+
1389 {
+
1390 USAGE_ASSERT( VertexExists(vertexId) );
+
1391 internal::StaticGraphLoopDifferentiation<TGraph, Policy>
+
1392 ::for_in_edges_at ( *this, vertexId, function );
+
1393 }
+
+
1394
+
1416 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1417 inline
+
+
1418 void for_in_edges_at ( Types::vertexId vertexId
+
1419 , FUNCTION function ) const
+
1420 {
+
1421 USAGE_ASSERT( VertexExists(vertexId) );
+
1422 internal::StaticGraphLoopDifferentiation<TGraph const, Policy>
+
1423 ::for_in_edges_at ( *this, vertexId, function );
+
1424 }
+
+
1425
+
1445 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1446 inline
+ +
1453
+
1473 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1474 inline
+ +
1481
+
1505 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1506 inline
+
+
1507 void for_out_edges_at( Types::vertexId vertexId
+
1508 , FUNCTION function )
+
1509 {
+
1510 USAGE_ASSERT( VertexExists(vertexId) );
+
1511 internal::StaticGraphLoopDifferentiation<TGraph, Policy>
+
1512 ::for_out_edges_at ( *this, vertexId, function );
+
1513 }
+
+
1514
+
1538 template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION>
+
1539 inline
+
+
1540 void for_out_edges_at( Types::vertexId vertexId
+
1541 , FUNCTION function ) const
+
1542 {
+
1543 USAGE_ASSERT( VertexExists(vertexId) );
+
1544 internal::StaticGraphLoopDifferentiation<TGraph const, Policy>
+
1545 ::for_out_edges_at ( *this, vertexId, function );
+
1546 }
+
+
1548
+
1549#pragma mark MEMBERS
+
1550 private:
+
1551 Types::name name_;
+
1553 std::vector<TVertex> vertices_;
+
1555 std::vector<TEdge> edges_;
+
1557 std::vector< std::vector<Types::edgeId> > inEdgeIds_;
+
1558 std::vector< std::vector<Types::edgeId> > outEdgeIds_;
+
1559};
+
+
1560
+
1561} // namespace egoa
+
1562
+
1563#endif // EGOA__DATA_STRUCTURES__GRAPHS__STATIC_GRAPH_HPP
+
egoa::Edges::Edge
Class for edge.
Definition Edge.hpp:27
+
egoa::StaticGraph
A graph data structure that supports adding vertices and edges.
Definition StaticGraph.hpp:52
+
egoa::StaticGraph::NeighborsOf
void NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const
Neighbors of a vertex.
Definition StaticGraph.hpp:323
+
egoa::StaticGraph::InDegreeAt
Types::count InDegreeAt(Types::vertexId id) const
The indegree of the vertex with identifier id.
Definition StaticGraph.hpp:359
+
egoa::StaticGraph::for_all_vertices
void for_all_vertices(FUNCTION function) const
The for loop over all vertex objects in the graph.
Definition StaticGraph.hpp:975
+
egoa::StaticGraph::EdgeIdsAt
void EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const
All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.
Definition StaticGraph.hpp:456
+
egoa::StaticGraph::Edge
TEdge & Edge(Types::vertexId source, Types::vertexId target)
Searches for an edge .
Definition StaticGraph.hpp:606
+
egoa::StaticGraph::EdgeAt
TEdge & EdgeAt(Types::edgeId id)
The edge with identifier id.
Definition StaticGraph.hpp:533
+
egoa::StaticGraph::for_all_edges_at
void for_all_edges_at(Types::vertexId const vertexId, FUNCTION function)
The for loop over all edges at a vertex.
Definition StaticGraph.hpp:1264
+
egoa::StaticGraph::for_all_vertex_identifiers
void for_all_vertex_identifiers(FUNCTION function) const
The for loop over all vertex identifiers in the graph.
Definition StaticGraph.hpp:923
+
egoa::StaticGraph::for_out_edges_at
void for_out_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all outgoing edges of a vertex.
Definition StaticGraph.hpp:1475
+
egoa::StaticGraph::OutDegreeAt
Types::count OutDegreeAt(Types::vertexId id) const
The outdegree of the vertex with identifier id.
Definition StaticGraph.hpp:374
+
egoa::StaticGraph::NumberOfVertices
Types::count NumberOfVertices() const
Number of vertices .
Definition StaticGraph.hpp:103
+
egoa::StaticGraph::Edge
TEdge const & Edge(Types::vertexId source, Types::vertexId target) const
Searches for an edge .
Definition StaticGraph.hpp:630
+
egoa::StaticGraph::outEdgeIds_
std::vector< std::vector< Types::edgeId > > outEdgeIds_
Definition StaticGraph.hpp:1558
+
egoa::StaticGraph::Name
Types::name Name() const
Name of the graph.
Definition StaticGraph.hpp:93
+
egoa::StaticGraph::inEdgeIds_
std::vector< std::vector< Types::edgeId > > inEdgeIds_
Definition StaticGraph.hpp:1557
+
egoa::StaticGraph::for_all_edges_at
void for_all_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all edges at a vertex object.
Definition StaticGraph.hpp:1232
+
egoa::StaticGraph::InEdgeIdsAt
std::vector< Types::edgeId > const & InEdgeIdsAt(Types::vertexId id) const
The identifiers of all incoming edges.
Definition StaticGraph.hpp:404
+
egoa::StaticGraph::NeighborsOf
std::vector< Types::vertexId > NeighborsOf(Types::vertexId id) const
Neighbors of a vertex.
Definition StaticGraph.hpp:300
+
egoa::StaticGraph::Edges
TEdgesView Edges()
A view on the edges.
Definition StaticGraph.hpp:486
+
egoa::StaticGraph::VertexId
Types::vertexId VertexId(TVertex const &vertex) const
The vertex identifier of a vertex object.
Definition StaticGraph.hpp:217
+
egoa::StaticGraph::vertices_
std::vector< TVertex > vertices_
Definition StaticGraph.hpp:1553
+
egoa::StaticGraph::EdgeId
Types::edgeId EdgeId(Types::vertexId source, Types::vertexId target) const
Searches for the identifier of the edge .
Definition StaticGraph.hpp:569
+
egoa::StaticGraph::OutEdgeIdsAt
std::vector< Types::edgeId > const & OutEdgeIdsAt(Types::vertexId id) const
The identifiers of all outgoing edges.
Definition StaticGraph.hpp:419
+
egoa::StaticGraph::VertexAt
TVertex & VertexAt(Types::vertexId id)
The vertex with identifier id.
Definition StaticGraph.hpp:182
+
egoa::StaticGraph::VertexAt
TVertex const & VertexAt(Types::vertexId id) const
The vertex with identifier id.
Definition StaticGraph.hpp:197
+
egoa::StaticGraph::for_all_edge_tuples
void for_all_edge_tuples(FUNCTION function) const
The for loop over all pairs of edge identifiers and edge objects in the graph.
Definition StaticGraph.hpp:1169
+
egoa::StaticGraph::for_in_edges_at
void for_in_edges_at(TVertex const &vertex, FUNCTION function) const
The for loop over all incoming edges of a vertex.
Definition StaticGraph.hpp:1357
+
egoa::StaticGraph::MinDegree
Types::count MinDegree() const
The minimum degree of the graph .
Definition StaticGraph.hpp:783
+
egoa::StaticGraph::Vertices
TVerticesView Vertices()
A view on the vertices.
Definition StaticGraph.hpp:136
+
egoa::StaticGraph::Edges
TConstEdgesView Edges() const
A view on the edges.
Definition StaticGraph.hpp:505
+
egoa::StaticGraph::EdgeExists
bool EdgeExists(Types::edgeId id) const
Whether an edge with the identifier id exists in the graph.
Definition StaticGraph.hpp:519
+
egoa::StaticGraph::MinDegree
Types::count MinDegree(Types::vertexId &id) const
The minimum degree of the graph .
Definition StaticGraph.hpp:758
+
egoa::StaticGraph::for_all_edges
void for_all_edges(FUNCTION function)
The for loop over all edges in the graph.
Definition StaticGraph.hpp:1087
+
egoa::StaticGraph::MaxDegree
Types::count MaxDegree(Types::vertexId &id) const
The maximum degree of the graph .
Definition StaticGraph.hpp:803
+
egoa::StaticGraph::Vertices
TConstVerticesView Vertices() const
A view on the vertices.
Definition StaticGraph.hpp:155
+
egoa::StaticGraph::for_all_vertex_tuples
void for_all_vertex_tuples(FUNCTION function) const
The for loop over all pairs of vertex identifiers and vertex objects in the graph.
Definition StaticGraph.hpp:1030
+
egoa::StaticGraph::EdgeIdsAt
std::vector< Types::edgeId > EdgeIdsAt(Types::vertexId id) const
All edge identifiers of edges incident to a vertex.
Definition StaticGraph.hpp:435
+
egoa::StaticGraph::operator<<
friend std::ostream & operator<<(std::ostream &outputStream, StaticGraph const &rhs)
Write the static graph to an output stream.
Definition StaticGraph.hpp:881
+
egoa::StaticGraph::for_out_edges_at
void for_out_edges_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all outgoing edges.
Definition StaticGraph.hpp:1507
+
egoa::StaticGraph::NumberOfEdges
Types::count NumberOfEdges() const
Number of edges .
Definition StaticGraph.hpp:113
+
egoa::StaticGraph::for_all_edges_at
void for_all_edges_at(Types::vertexId const vertexId, FUNCTION function) const
The for loop over all edges at a vertex.
Definition StaticGraph.hpp:1298
+
egoa::StaticGraph::AddEdge
Types::edgeId AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)
Adds an edge to the set of edges .
Definition StaticGraph.hpp:652
+
egoa::StaticGraph::for_in_edges_at
void for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all incoming edges of a vertex.
Definition StaticGraph.hpp:1418
+
egoa::StaticGraph::for_all_edge_identifiers
void for_all_edge_identifiers(FUNCTION function) const
The for loop over all identifiers of edges in the graph.
Definition StaticGraph.hpp:1061
+
egoa::StaticGraph::for_all_vertices
void for_all_vertices(FUNCTION function)
The for loop over all vertex objects in the graph.
Definition StaticGraph.hpp:949
+
egoa::StaticGraph::for_all_edge_tuples
void for_all_edge_tuples(FUNCTION function)
The for loop over all pairs of edge identifiers and edge objects in the graph.
Definition StaticGraph.hpp:1141
+
egoa::StaticGraph::edges_
std::vector< TEdge > edges_
Definition StaticGraph.hpp:1555
+ +
egoa::StaticGraph::EdgeAt
TEdge const & EdgeAt(Types::edgeId id) const
The edge with identifier id.
Definition StaticGraph.hpp:548
+
egoa::StaticGraph::VertexExists
bool VertexExists(Types::vertexId id) const
Whether a vertex with identifier id exists in the graph.
Definition StaticGraph.hpp:168
+
egoa::StaticGraph::DumpBranches
void DumpBranches(std::ostream &outputStream) const
Dumps branches.
Definition StaticGraph.hpp:860
+
egoa::StaticGraph::for_out_edges_at
void for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const
The for loop over all outgoing edges.
Definition StaticGraph.hpp:1540
+
egoa::StaticGraph::AddVertex
Types::vertexId AddVertex(TVertexProperties const &properties)
Adds a vertex.
Definition StaticGraph.hpp:229
+
egoa::StaticGraph::for_in_edges_at
void for_in_edges_at(Types::vertexId vertexId, FUNCTION function)
The for loop over all incoming edges of a vertex.
Definition StaticGraph.hpp:1387
+
egoa::StaticGraph::MaxDegree
Types::count MaxDegree() const
The maximum degree of the graph .
Definition StaticGraph.hpp:828
+
egoa::StaticGraph::for_out_edges_at
void for_out_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all outgoing edges of a vertex.
Definition StaticGraph.hpp:1447
+
egoa::StaticGraph::for_in_edges_at
void for_in_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all incoming edges of a vertex.
Definition StaticGraph.hpp:1328
+
egoa::StaticGraph::for_all_edges
void for_all_edges(FUNCTION function) const
The for loop over all edges in the graph.
Definition StaticGraph.hpp:1113
+
egoa::StaticGraph::DumpBuses
void DumpBuses(std::ostream &outputStream) const
Dumps buses.
Definition StaticGraph.hpp:844
+
egoa::StaticGraph::MapVertices
auto MapVertices(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>
Applies function to all vertices and collects the result in a vector.
Definition StaticGraph.hpp:272
+
egoa::StaticGraph::DegreeAt
Types::count DegreeAt(Types::vertexId id) const
The degree of the vertex with identifier id.
Definition StaticGraph.hpp:389
+
egoa::StaticGraph::AddVertex
Types::vertexId AddVertex(TVertexProperties &&properties)
Adds a vertex.
Definition StaticGraph.hpp:241
+
egoa::StaticGraph::for_all_vertex_tuples
void for_all_vertex_tuples(FUNCTION function)
The for loop over all pairs of vertex identifiers and vertex objects in the graph.
Definition StaticGraph.hpp:1003
+
egoa::StaticGraph::AddEdge
Types::edgeId AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)
Adds an edge to the set of edges .
Definition StaticGraph.hpp:672
+
egoa::StaticGraph::for_all_edges_at
void for_all_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all edges at a vertex object.
Definition StaticGraph.hpp:1202
+
egoa::StaticGraph::MapEdges
auto MapEdges(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>
Applies function to all edges and collects the result in a vector.
Definition StaticGraph.hpp:708
+
egoa::VectorView
Provides a restricted view on a vector.
Definition VectorView.hpp:24
+
egoa::Vertices::Vertex
Class for a vertex.
Definition Vertex.hpp:29
+ +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_static_graph_iterators_8hpp_source.html b/_static_graph_iterators_8hpp_source.html new file mode 100644 index 00000000..c4e1ec36 --- /dev/null +++ b/_static_graph_iterators_8hpp_source.html @@ -0,0 +1,418 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators/StaticGraphIterators.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
StaticGraphIterators.hpp
+
+
+
1/*
+
2 * StaticGraphIterators.hpp
+
3 *
+
4 * Created on: Dec 05, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__ITERATORS__STATIC_GRAPH_ITERATORS_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__ITERATORS__STATIC_GRAPH_ITERATORS_HPP
+
10
+
11#ifdef OPENMP_AVAILABLE
+
12 #include <omp.h>
+
13#endif
+
14
+
15#include "Auxiliary/ExecutionPolicy.hpp"
+
16
+
17#include "DataStructures/Iterators/GraphIterators.hpp"
+
18
+
19namespace egoa::internal {
+
20
+
39template<typename GraphType, ExecutionPolicy Policy>
+
+
40class StaticGraphLoopDifferentiation
+
41 : public GraphLoopDifferentiation<GraphType, Policy>
+
42{};
+
+
43
+
49template<typename GraphType>
+
+
50class StaticGraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential>
+
51 : public GraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential> {
+
52
+
53 // Type aliasing
+
54 using TGraph = GraphType;
+
55 using TVertex = typename TGraph::TVertex;
+
56 using TVertexId = typename TGraph::TVertexId;
+
57 using TEdgeId = typename TGraph::TEdgeId;
+
58
+
59 public:
+
62#pragma mark SEQUENTIAL_VERTEX_LOOPS
+
80 template<typename FUNCTION>
+
81 inline static
+
+
82 void for_all_vertex_identifiers ( TGraph & graph
+
83 , FUNCTION function )
+
84 {
+
85 for ( TVertexId vertexId = 0
+
86 ; vertexId < graph.NumberOfVertices()
+
87 ; ++vertexId )
+
88 {
+
89 auto copy = vertexId;
+
90 function( copy );
+
91 }
+
92 }
+
+
93
+
111 template<typename FUNCTION>
+
112 static inline
+
+
113 void for_all_vertex_tuples ( TGraph & graph
+
114 , FUNCTION function )
+
115 {
+
116 for ( TVertexId vertexId = 0
+
117 ; vertexId < graph.NumberOfVertices()
+
118 ; ++vertexId )
+
119 {
+
120 auto copy = vertexId;
+
121 function( copy, graph.VertexAt(vertexId) );
+
122 }
+
123 }
+
+
125
+
128#pragma mark SEQUENTIAL_EDGE_LOOPS
+
129
+
147 template<typename FUNCTION>
+
148 static inline
+
+
149 void for_all_edge_identifiers ( TGraph & graph
+
150 , FUNCTION function )
+
151 {
+
152 for (TEdgeId edgeId = 0
+
153 ; edgeId < graph.NumberOfEdges()
+
154 ; ++edgeId )
+
155 {
+
156 auto copy = edgeId;
+
157 function( copy );
+
158 }
+
159 }
+
+
160
+
178 template<typename FUNCTION>
+
179 static inline
+
+
180 void for_all_edge_tuples ( TGraph & graph
+
181 , FUNCTION function )
+
182 {
+
183 for ( TEdgeId edgeId = 0
+
184 ; edgeId < graph.NumberOfEdges()
+
185 ; ++edgeId )
+
186 {
+
187 auto copy = edgeId;
+
188 function( copy, graph.EdgeAt(edgeId) );
+
189 }
+
190 }
+
+
192};
+
+
193
+
200template<typename GraphType>
+
+
201class StaticGraphLoopDifferentiation<GraphType, ExecutionPolicy::breakable>
+
202 : public GraphLoopDifferentiation<GraphType, ExecutionPolicy::breakable> {
+
203 using TGraph = GraphType;
+
204 using TVertexId = typename GraphType::TVertexId;
+
205 using TVertex = typename GraphType::TVertex;
+
206 using TEdgeId = typename GraphType::TEdgeId;
+
207
+
208 public:
+
211#pragma mark BREAKABLE_VERTEX_LOOPS
+
212
+
232 template<typename FUNCTION>
+
233 static inline
+
+
234 void for_all_vertex_identifiers ( TGraph & graph
+
235 , FUNCTION function )
+
236 {
+
237 bool toContinue = true;
+
238 for ( TVertexId vertexId = 0
+
239 ; vertexId < graph.NumberOfVertices()
+
240 ; ++vertexId )
+
241 {
+
242 auto copy = vertexId;
+
243 toContinue = function( copy );
+
244 if (!toContinue) return;
+
245 }
+
246 }
+
+
247
+
267 template<typename FUNCTION>
+
268 static inline
+
+
269 void for_all_vertex_tuples ( TGraph & graph
+
270 , FUNCTION function )
+
271 {
+
272 bool toContinue = true;
+
273 for ( TVertexId vertexId = 0
+
274 ; vertexId < graph.NumberOfVertices()
+
275 ; ++vertexId )
+
276 {
+
277 auto copy = vertexId;
+
278 toContinue = function( copy, graph.VertexAt(vertexId) );
+
279 if (!toContinue) return;
+
280 }
+
281 }
+
+
283
+
286#pragma mark BREAKABLE_EDGE_LOOPS
+
287
+
309 template<typename FUNCTION>
+
310 static inline
+
+
311 void for_all_edge_identifiers ( TGraph & graph
+
312 , FUNCTION function )
+
313 {
+
314 bool toContinue = true;
+
315 for ( TEdgeId edgeId = 0
+
316 ; edgeId < graph.NumberOfEdges()
+
317 ; ++edgeId )
+
318 {
+
319 auto copy = edgeId;
+
320 toContinue = function( copy );
+
321 if (!toContinue) return;
+
322 }
+
323 }
+
+
324
+
346 template<typename FUNCTION>
+
347 static inline
+
+
348 void for_all_edge_tuples ( TGraph & graph
+
349 , FUNCTION function )
+
350 {
+
351 bool toContinue = true;
+
352 for ( TEdgeId edgeId = 0
+
353 ; edgeId < graph.NumberOfEdges()
+
354 ; ++edgeId )
+
355 {
+
356 auto copy = edgeId;
+
357 toContinue = function( copy, graph.EdgeAt(edgeId) );
+
358 if (!toContinue) return;
+
359 }
+
360 }
+
+
361
+
363};
+
+
364
+
365#ifdef OPENMP_AVAILABLE
+
366
+
372template<typename GraphType>
+
373class StaticGraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel>
+
374 : public GraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel> {
+
375 // Type aliasing
+
376 using TGraph = GraphType;
+
377 using TVertex = typename TGraph::TVertex;
+
378 using TVertexId = typename TGraph::TVertexId;
+
379 using TEdgeId = typename TGraph::TEdgeId;
+
380
+
381 public:
+
384#pragma mark PARALLEL_VERTEX_LOOPS
+
402 template<typename FUNCTION>
+
403 static inline
+
404 void for_all_vertex_identifiers ( TGraph & graph
+
405 , FUNCTION function )
+
406 {
+
407 #pragma omp parallel for
+
408 for ( TVertexId vertexId = 0
+
409 ; vertexId < graph.NumberOfVertices()
+
410 ; ++vertexId )
+
411 {
+
412 TVertexId copy = vertexId;
+
413 function( copy );
+
414 }
+
415 }
+
416
+
434 template<typename FUNCTION>
+
435 static inline
+
436 void for_all_vertices ( TGraph & graph
+
437 , FUNCTION function )
+
438 {
+
439 #pragma omp parallel for
+
440 for ( TVertexId vertexId = 0
+
441 ; vertexId < graph.NumberOfVertices()
+
442 ; ++vertexId )
+
443 {
+
444 function( graph.VertexAt(vertexId) );
+
445 }
+
446 }
+
447
+
465 template<typename FUNCTION>
+
466 static inline
+
467 void for_all_vertex_tuples ( TGraph & graph
+
468 , FUNCTION function )
+
469 {
+
470 #pragma omp parallel for
+
471 for ( TVertexId vertexId = 0
+
472 ; vertexId < graph.NumberOfVertices()
+
473 ; ++vertexId )
+
474 {
+
475 auto copy = vertexId;
+
476 function( copy, graph.VertexAt(vertexId) );
+
477 }
+
478 }
+
480
+
483#pragma mark PARALLEL_EDGE_LOOPS
+
484
+
502 template<typename FUNCTION>
+
503 static inline
+
504 void for_all_edge_identifiers ( TGraph & graph
+
505 , FUNCTION function )
+
506 {
+
507 #pragma omp parallel for
+
508 for ( TEdgeId edgeId = 0
+
509 ; edgeId < graph.NumberOfEdges()
+
510 ; ++edgeId )
+
511 {
+
512 auto copy = edgeId;
+
513 function( copy );
+
514 }
+
515 }
+
516
+
534 template<typename FUNCTION>
+
535 static inline
+
536 void for_all_edges ( TGraph & graph
+
537 , FUNCTION function )
+
538 {
+
539 #pragma omp parallel for
+
540 for ( TEdgeId edgeId = 0
+
541 ; edgeId < graph.NumberOfEdges()
+
542 ; ++edgeId )
+
543 {
+
544 function( graph.EdgeAt(edgeId) );
+
545 }
+
546 }
+
547
+
565 template<typename FUNCTION>
+
566 static inline
+
567 void for_all_edge_tuples ( TGraph & graph
+
568 , FUNCTION function )
+
569 {
+
570 #pragma omp parallel for
+
571 for ( TEdgeId edgeId = 0
+
572 ; edgeId < graph.NumberOfEdges()
+
573 ; ++edgeId )
+
574 {
+
575 auto copy = edgeId;
+
576 function( copy, graph.EdgeAt(edgeId) );
+
577 }
+
578 }
+
580};
+
581
+
582#else // OPENMP_AVAILABLE
+
583
+
590template<typename GraphType>
+
+
591class StaticGraphLoopDifferentiation<GraphType, ExecutionPolicy::parallel>
+
592 : public StaticGraphLoopDifferentiation<GraphType, ExecutionPolicy::sequential> {
+
593};
+
+
594#endif
+
595
+
596} // namespace egoa::internal
+
597
+
598#endif // EGOA__DATA_STRUCTURES__GRAPHS__ITERATORS__STATIC_GRAPH_ITERATORS_HPP
+
egoa::internal::GraphLoopDifferentiation
The base class for for loops for graphs.
Definition GraphIterators.hpp:30
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples
static void for_all_vertex_tuples(TGraph &graph, FUNCTION function)
The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph .
Definition StaticGraphIterators.hpp:269
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all vertex identifiers in the graph .
Definition StaticGraphIterators.hpp:234
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples
static void for_all_edge_tuples(TGraph &graph, FUNCTION function)
The breakable for loop over all pairs of edge identifiers and edge objects in the graph .
Definition StaticGraphIterators.hpp:348
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers
static void for_all_edge_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all identifiers of edges in the graph .
Definition StaticGraphIterators.hpp:311
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples
static void for_all_vertex_tuples(TGraph &graph, FUNCTION function)
The for loop over all pairs of vertex identifiers and vertex tuples in the graph .
Definition StaticGraphIterators.hpp:113
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples
static void for_all_edge_tuples(TGraph &graph, FUNCTION function)
The for loop over all pairs of edge identifiers and edge objects in the graph .
Definition StaticGraphIterators.hpp:180
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers
static void for_all_edge_identifiers(TGraph &graph, FUNCTION function)
The for loop over all indentifiers of edges in the graph .
Definition StaticGraphIterators.hpp:149
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The for loop over all vertex identifiers in the graph .
Definition StaticGraphIterators.hpp:82
+ +
egoa::ExecutionPolicy
ExecutionPolicy
Execution policies for for loops.
Definition ExecutionPolicy.hpp:15
+ + + +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_std_queue_8hpp_source.html b/_std_queue_8hpp_source.html new file mode 100644 index 00000000..08005eaa --- /dev/null +++ b/_std_queue_8hpp_source.html @@ -0,0 +1,193 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues/StdQueue.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
StdQueue.hpp
+
+
+
1/*
+
2 * StdQueue.hpp
+
3 *
+
4 * Created on: Feb 17, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__STD_FIFO_QUEUE_HPP
+
9#define EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__STD_FIFO_QUEUE_HPP
+
10
+
11#include <queue>
+
12
+
13#include "Auxiliary/Types.hpp"
+
14#include "Exceptions/Assertions.hpp"
+
15
+
16namespace egoa {
+
17
+
18//@todo Emplace, Comments
+
19// this queue does not implement loops
+
20template<typename ElementType>
+
+
21class StdQueue {
+
22 public:
+
23 // Type aliasing
+
24 using TElement = ElementType;
+
25 public:
+
26#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
27
+
28 StdQueue ()
+
29 : queue_(){}
+
30
+
31 virtual ~StdQueue() {}
+
32
+
33#pragma mark ELEMENT_ACCESS
+
+
36 virtual inline TElement const & Top () const {
+
37 USAGE_ASSERT ( Size() > 0 );
+
38 return queue_.front();
+
39 }
+
+
41
+
44#pragma mark ADD_ELEMENTS
+
+
45 virtual inline void Push ( TElement const & element ) {
+
46 queue_.push ( element );
+
47 }
+
+
48
+
49 virtual inline void Push ( TElement && element ) {
+
50 queue_.push ( element );
+
51 }
+
52
+
53 //@todo
+
54 virtual inline void Emplace ( TElement const & element ) {
+
55 queue_.emplace ( element );
+
56 }
+
57#pragma mark MODIFIERS
+
58 virtual inline void Pop () {
+
59 USAGE_ASSERT ( Size() > 0 );
+
60 queue_.pop();
+
61 }
+
62
+
63 virtual inline TElement DeleteTop() {
+
64 USAGE_ASSERT ( Size() > 0 );
+
65
+
66 TElement top = std::move( Top() );
+
67 Pop();
+
68 return top;
+
69 }
+
70
+
71 virtual inline void Clear () {
+
72 std::queue<TElement> empty;
+
73 std::swap( queue_, empty );
+
74 }
+
75
+
76 virtual inline void Swap ( StdQueue & rhs ) {
+
77 queue_.swap( rhs.queue_ );
+
78 }
+
80
+
81#pragma mark CAPACITY
+
+
84 virtual inline bool Empty () const {
+
85 return queue_.empty();
+
86 }
+
+
87
+
88 virtual inline Types::count Size () const {
+
89 return queue_.size();
+
90 }
+
92#pragma mark MEMBERS
+
93 private:
+
94 std::queue<TElement> queue_;
+
95};
+
+
96
+
97} // namespace egoa
+
98
+
99#endif // EGOA__DATA_STRUCTURES__CONTAINER__QUEUE__STD_FIFO_QUEUE_HPP
+ +
egoa::StdQueue::Push
virtual void Push(TElement const &element)
Definition StdQueue.hpp:45
+
egoa::StdQueue::Top
virtual TElement const & Top() const
Definition StdQueue.hpp:36
+
egoa::StdQueue::Empty
virtual bool Empty() const
Definition StdQueue.hpp:84
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_stroke_8hpp_source.html b/_stroke_8hpp_source.html new file mode 100644 index 00000000..c1062af7 --- /dev/null +++ b/_stroke_8hpp_source.html @@ -0,0 +1,168 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Appearance/Stroke.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Stroke.hpp
+
+
+
1/*
+
2 * Stroke.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__IO__STROKE_HPP
+
9#define EGOA__IO__STROKE_HPP
+
10
+
11#include "Auxiliary/Auxiliary.hpp"
+
12
+
13namespace egoa {
+
14
+
+
24class Stroke {
+
25 public:
+
26 enum class Name {
+
27 solid
+
28 , dashed
+
29 , dotted
+
30 , dasheddotted
+
31 , bold
+
32 , none
+
33 };
+
34 public:
+
37#pragma mark CONSTRUCTORS_AND_DESTRUCTOR
+
+
43 Stroke( Stroke::Name name )
+
44 : stroke_(static_cast<Types::count>(name)) {}
+
+
45
+
+
49 Stroke()
+
50 : stroke_( static_cast<Types::count>(Name::solid) ) {}
+
+
51
+
52 ~Stroke() {}
+
54
+
57#pragma mark OPERATORS
+
58 bool operator== ( const Stroke& rhs )
+
59 {
+
60 return stroke_ == rhs.stroke_;
+
61 }
+
62
+
63 bool operator!= ( const Stroke& rhs )
+
64 {
+
65 return !operator==(rhs);
+
66 }
+
68
+
69 Types::count Type() const { return stroke_; }
+
70
+
73#pragma mark OUTPUT
+
74 friend std::ostream & operator<< ( std::ostream & outputStream, Name stroke )
+
75 {
+
76 switch ( stroke )
+
77 {
+
78 case Name::solid: outputStream << "solid"; break;
+
79 case Name::dashed: outputStream << "dashed"; break;
+
80 case Name::dotted: outputStream << "dotted"; break;
+
81 case Name::dasheddotted: outputStream << "dasheddotted"; break;
+
82 case Name::bold: outputStream << "bold"; break;
+
83 case Name::none: outputStream << "invis"; break;
+
84 }
+
85 return outputStream;
+
86 }
+
88 private:
+
89 Types::count stroke_;
+
90};
+
+
91
+
92} // namespace egoa
+
93
+
94#endif // EGOA__IO__STROKE_HPP
+ +
egoa::Stroke::Stroke
Stroke()
Constructs a new instance.
Definition Stroke.hpp:49
+
egoa::Stroke::Stroke
Stroke(Stroke::Name name)
Constructs a new instance.
Definition Stroke.hpp:43
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_subgraph_8hpp_source.html b/_subgraph_8hpp_source.html new file mode 100644 index 00000000..a9f3fe4e --- /dev/null +++ b/_subgraph_8hpp_source.html @@ -0,0 +1,208 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Subgraph.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Subgraph.hpp
+
+
+
1
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__SUBGRAPH_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__SUBGRAPH_HPP
+
10
+
11#include <algorithm>
+
12#include <ostream>
+
13#include <vector>
+
14
+
15#include "DataStructures/Views/VectorView.hpp"
+
16
+
17#include "Exceptions/Assertions.hpp"
+
18
+
19
+
20namespace egoa {
+
21
+
27template< typename GraphType>
+
+
28class Subgraph {
+
29public:
+
31 using TUnderlyingGraph = GraphType;
+
32 using TVertexId = typename TUnderlyingGraph::TVertexId;
+
33 using TEdgeId = typename TUnderlyingGraph::TEdgeId;
+
34 using TVerticesView = VectorView<TVertexId, true>;
+
35 using TEdgesView = VectorView<TEdgeId, true>;
+
36
+
+
47 Subgraph(TUnderlyingGraph * graph,
+
48 std::vector<TVertexId> vertices,
+
49 std::vector<TEdgeId> edges)
+
50 : underlyingGraph_(graph),
+
51 vertices_(std::move(vertices)),
+
52 edges_(std::move(edges))
+
53 {
+
54 USAGE_ASSERT(std::all_of(vertices_.begin(), vertices_.end(),
+
55 [this](TVertexId id) {
+
56 return underlyingGraph_->VertexExists(id);
+
57 }));
+
58 USAGE_ASSERT(std::all_of(edges_.begin(), edges_.end(),
+
59 [this](TEdgeId id) {
+
60 return underlyingGraph_->EdgeExists(id);
+
61 }));
+
62
+
63 std::sort(vertices_.begin(), vertices_.end());
+
64 std::sort(edges_.begin(), edges_.end());
+
65 }
+
+
66
+
+
72 TUnderlyingGraph & UnderlyingGraph() {
+
73 return *underlyingGraph_;
+
74 }
+
+
75
+
+
81 TUnderlyingGraph const & UnderlyingGraph() const {
+
82 return *underlyingGraph_;
+
83 }
+
+
84
+
+
90 TVerticesView Vertices() const {
+
91 return TVerticesView(&vertices_);
+
92 }
+
+
93
+
+
99 TEdgesView Edges() const {
+
100 return TEdgesView(&edges_);
+
101 }
+
+
102
+
103 friend bool operator==(Subgraph const & lhs, Subgraph const & rhs) {
+
104 return lhs.underlyingGraph_ == rhs.underlyingGraph_ &&
+
105 lhs.vertices_ == rhs.vertices_ &&
+
106 lhs.edges_ == rhs.edges_;
+
107 }
+
108
+
109 friend bool operator!=(Subgraph const & lhs, Subgraph const & rhs) {
+
110 return !(lhs == rhs);
+
111 }
+
112
+
113private:
+
114
+
121 TUnderlyingGraph * underlyingGraph_;
+
125 std::vector<TVertexId> vertices_;
+
129 std::vector<TEdgeId> edges_;
+
130
+
131};
+
+
132
+
133template<typename GraphType>
+
134inline std::ostream & operator<<(std::ostream & os,
+
135 Subgraph<GraphType> const & subgraph) {
+
136 os << "[G="
+
137 << subgraph.UnderlyingGraph().Name()
+
138 << ", V="
+
139 << subgraph.Vertices()
+
140 << ", E="
+
141 << subgraph.Edges()
+
142 << "]";
+
143 return os;
+
144}
+
145
+
146} // namespace egoa
+
147
+
148#endif // EGOA__DATA_STRUCTURES__GRAPHS__SUBGRAPH_HPP
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
egoa::Subgraph::UnderlyingGraph
TUnderlyingGraph & UnderlyingGraph()
The underlying graph.
Definition Subgraph.hpp:72
+
egoa::Subgraph::vertices_
std::vector< TVertexId > vertices_
The identifiers of the vertices belonging to the subgraph.
Definition Subgraph.hpp:125
+
egoa::Subgraph::TUnderlyingGraph
GraphType TUnderlyingGraph
The type of the underlying graph.
Definition Subgraph.hpp:31
+
egoa::Subgraph::UnderlyingGraph
TUnderlyingGraph const & UnderlyingGraph() const
The underlying graph.
Definition Subgraph.hpp:81
+
egoa::Subgraph::Edges
TEdgesView Edges() const
A view on the identifiers of the edges in the subgraph.
Definition Subgraph.hpp:99
+
egoa::Subgraph::underlyingGraph_
TUnderlyingGraph * underlyingGraph_
A pointer to the underlying graph.
Definition Subgraph.hpp:121
+
egoa::Subgraph::edges_
std::vector< TEdgeId > edges_
The identifiers of the edges belong to the subgraph.
Definition Subgraph.hpp:129
+
egoa::Subgraph::Subgraph
Subgraph(TUnderlyingGraph *graph, std::vector< TVertexId > vertices, std::vector< TEdgeId > edges)
The constructor.
Definition Subgraph.hpp:47
+
egoa::Subgraph::Vertices
TVerticesView Vertices() const
A view on the identifiers of the vertices in the subgraph.
Definition Subgraph.hpp:90
+
egoa::VectorView
Provides a restricted view on a vector.
Definition VectorView.hpp:24
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_susceptance_norm_label_8hpp_source.html b/_susceptance_norm_label_8hpp_source.html new file mode 100644 index 00000000..67a7ef6d --- /dev/null +++ b/_susceptance_norm_label_8hpp_source.html @@ -0,0 +1,375 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Labels/SusceptanceNormLabel.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SusceptanceNormLabel.hpp
+
+
+
1/*
+
2 * SusceptanceNormLabel.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__LABELS__SUSCEPTANCE_NORM_LABEL_HPP
+
9#define EGOA__DATA_STRUCTURES__LABELS__SUSCEPTANCE_NORM_LABEL_HPP
+
10
+
11#include "Label.hpp"
+
12
+
13namespace egoa {
+
14
+
41template< typename ElementType = Edges::Edge<Edges::ElectricalProperties>
+
42 , typename VertexSetContainer = std::unordered_set<Types::vertexId>
+
43 , typename PointerType = Types::vertexId >
+
+
44class SusceptanceNormLabel : public Label<ElementType, VertexSetContainer, PointerType> {
+
45 public:
+
46 // Type aliasing
+
47 using typename Label<ElementType,VertexSetContainer, PointerType>::TLabel;
+
48 using typename TLabel::TVertexId;
+
49 using typename TLabel::TElement;
+
50 using typename TLabel::TVertexSet;
+
51
+
52 public:
+
55#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
56
+
+
66 SusceptanceNormLabel ()
+
67 : SusceptanceNormLabel ( Const::NONE, Const::REAL_INFTY )
+
68 {}
+
+
69
+
+
79 SusceptanceNormLabel ( Types::vertexId vertexId )
+
80 : SusceptanceNormLabel ( vertexId, Const::REAL_INFTY )
+
81 {}
+
+
82
+
+
92 SusceptanceNormLabel ( Types::vertexId vertexId
+
93 , Types::real susceptanceNorm )
+
94 : SusceptanceNormLabel ( vertexId, susceptanceNorm, TVertexSet() )
+
95 {}
+
+
96
+
+
107 SusceptanceNormLabel ( Types::vertexId vertexId
+
108 , Types::real susceptanceNorm
+
109 , TVertexSet vertexSet )
+
110 : TLabel ( vertexId )
+
111 , susceptanceNorm_ ( susceptanceNorm )
+
112 , vertexSet_ ( vertexSet )
+
113 {}
+
+
114
+
121 SusceptanceNormLabel ( SusceptanceNormLabel const & label ) = default;
+
122
+
126 ~SusceptanceNormLabel () {}
+
128
+
+
136 inline static SusceptanceNormLabel SourceLabel ( Types::vertexId vertexId )
+
137 {
+
138 return SusceptanceNormLabel ( vertexId, 0.0, TVertexSet ( {{vertexId}} ) );
+
139 }
+
+
140
+
143#pragma mark GETTER_AND_SETTER
+
144
+
+
150 inline TVertexSet const & VertexSet() const
+
151 {
+
152 return vertexSet_;
+
153 }
+
+
154
+
+
160 inline TVertexSet & VertexSet()
+
161 {
+
162 return vertexSet_;
+
163 }
+
+
165
+
168#pragma mark DOMINATION_OPERATORS
+
169
+
+
177 inline bool operator< ( SusceptanceNormLabel const & rhs ) const
+
178 {
+
179 return this->SusceptanceNorm() < rhs.SusceptanceNorm();
+
180 }
+
+
181
+
+
189 inline bool operator<= ( SusceptanceNormLabel const & rhs ) const
+
190 {
+
191 return !(*this > rhs);
+
192 }
+
+
193
+
+
201 inline bool operator> ( SusceptanceNormLabel const & rhs ) const
+
202 {
+
203 return rhs < *this;
+
204 }
+
+
205
+
+
213 inline bool operator>= ( SusceptanceNormLabel const & rhs ) const
+
214 {
+
215 return !(rhs > *this);
+
216 }
+
+
218
+
221#pragma mark COMPARISON_OPERATORS
+
222
+
+
230 inline bool operator== ( SusceptanceNormLabel const & rhs ) const
+
231 {
+
232 return this->SusceptanceNorm() == rhs.SusceptanceNorm();
+
233 }
+
+
234
+
+
242 inline bool operator!= ( SusceptanceNormLabel const & rhs ) const
+
243 {
+
244 return !(*this==rhs);
+
245 }
+
+
247
+
250#pragma mark CONCATENATION_OPERATORS
+
251
+
+
263 friend inline bool operator+( SusceptanceNormLabel const & lhs
+
264 , TVertexId const & vertexId )
+
265 {
+
266 USAGE_ASSERT ( lhs.SusceptanceNorm() != Const::NONE );
+
267 USAGE_ASSERT ( vertexId != Const::NONE );
+
268
+
269 bool isInsert = false;
+
270 std::tie( std::ignore, isInsert ) = lhs.VertexSet().emplace( vertexId );
+
271 return isInsert;
+
272 }
+
+
273
+
+
284 friend inline std::pair<TVertexSet, bool> operator+( TVertexId const & vertexId
+
285 , SusceptanceNormLabel const & rhs )
+
286 {
+
287 USAGE_ASSERT ( rhs.SusceptanceNorm() != Const::NONE );
+
288 USAGE_ASSERT ( vertexId != Const::NONE );
+
289
+
290 bool isInsert = false;
+
291 TVertexSet newSet = rhs.VertexSet();
+
292
+
293 std::tie( std::ignore, isInsert ) = newSet.emplace( vertexId );
+
294
+
295 return std::make_pair ( newSet, isInsert );
+
296 }
+
+
297
+
+
308 friend inline std::pair<SusceptanceNormLabel, bool> operator+( TElement const & edge
+
309 , SusceptanceNormLabel const & rhs )
+
310 {
+
311 USAGE_ASSERT ( rhs.SusceptanceNorm() != Const::NONE );
+
312 USAGE_ASSERT ( edge.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0 );
+
313
+
314 bool isInsert = false;
+
315 SusceptanceNormLabel newLabel = rhs;
+
316
+
317 newLabel += edge;
+
318 TVertexId vertexId = edge.Other( rhs.Vertex() );
+
319
+
320 ESSENTIAL_ASSERT ( vertexId == newLabel.Vertex() );
+
321
+
322 std::tie( newLabel.VertexSet(), isInsert ) = vertexId + rhs;
+
323
+
324 return std::make_pair( newLabel, isInsert );
+
325 }
+
+
326
+
+
337 friend inline std::pair<SusceptanceNormLabel, bool> operator+( SusceptanceNormLabel const & lhs
+
338 , TElement const & edge )
+
339 {
+
340 USAGE_ASSERT ( lhs.SusceptanceNorm() != Const::NONE );
+
341 USAGE_ASSERT ( edge.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0 );
+
342
+
343 return edge + lhs;
+
344 }
+
+
345
+
+
353 inline SusceptanceNormLabel & operator+= ( TElement const & rhs )
+
354 {
+
355 USAGE_ASSERT ( SusceptanceNorm() != Const::NONE );
+
356 USAGE_ASSERT ( rhs.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0 ); // TODO: Check for >0?
+
357
+
358 SusceptanceNorm() += fabs( 1 / rhs.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() );
+
359 TLabel::Vertex() = rhs.Other( TLabel::Vertex() );
+
360
+
361 return *this;
+
362 }
+
+
364
+
367#pragma mark GETTER_AND_SETTER
+
368
+
+
376 inline Types::real SusceptanceNorm() const
+
377 {
+
378 return susceptanceNorm_;
+
379 }
+
+
380
+
+
388 inline Types::real & SusceptanceNorm()
+
389 {
+
390 return susceptanceNorm_;
+
391 }
+
+
392
+
+
401 inline Types::real Value() const
+
402 {
+
403 return SusceptanceNorm();
+
404 }
+
+
406
+
407#pragma mark OUTPUT
+
+
416 friend std::ostream & operator<< ( std::ostream & os
+
417 , SusceptanceNormLabel const & rhs )
+
418 {
+
419 return os << rhs.SusceptanceNorm();
+
420 }
+
+
421
+
422#pragma mark MEMBERS
+
423 private:
+
424 Types::real susceptanceNorm_;
+
425 TVertexSet vertexSet_;
+
426};
+
+
427
+
428} // namespace egoa
+
429
+
430#endif // EGOA__DATA_STRUCTURES__LABELS__SUSCEPTANCE_NORM_LABEL_HPP
+
egoa::Label
Interface for label.
Definition Label.hpp:34
+
egoa::Label::TVertexSet
VertexSetContainer TVertexSet
Definition Label.hpp:40
+
egoa::Label::TVertexId
Types::vertexId TVertexId
Definition Label.hpp:37
+
egoa::Label::TElement
ElementType TElement
Definition Label.hpp:39
+
egoa::Label::Vertex
Types::vertexId Vertex() const
Getter for the value of the label.
Definition Label.hpp:191
+
egoa::SusceptanceNormLabel
Class for Susceptance norm label.
Definition SusceptanceNormLabel.hpp:44
+
egoa::SusceptanceNormLabel::operator+
friend std::pair< SusceptanceNormLabel, bool > operator+(SusceptanceNormLabel const &lhs, TElement const &edge)
Addition operators testing for cycles.
Definition SusceptanceNormLabel.hpp:337
+
egoa::SusceptanceNormLabel::VertexSet
TVertexSet & VertexSet()
Getter of the set of all visited vertices from the source.
Definition SusceptanceNormLabel.hpp:160
+
egoa::SusceptanceNormLabel::Value
Types::real Value() const
Susceptance norm label value.
Definition SusceptanceNormLabel.hpp:401
+
egoa::SusceptanceNormLabel::SusceptanceNormLabel
SusceptanceNormLabel(Types::vertexId vertexId)
Constructs the Susceptance Norm label object.
Definition SusceptanceNormLabel.hpp:79
+
egoa::SusceptanceNormLabel::SusceptanceNormLabel
SusceptanceNormLabel(SusceptanceNormLabel const &label)=default
Copy constructor.
+
egoa::SusceptanceNormLabel::TVertexSet
VertexSetContainer TVertexSet
Definition Label.hpp:40
+
egoa::SusceptanceNormLabel::operator<=
bool operator<=(SusceptanceNormLabel const &rhs) const
Weak domination using less or equal than.
Definition SusceptanceNormLabel.hpp:189
+
egoa::SusceptanceNormLabel::SusceptanceNormLabel
SusceptanceNormLabel()
Constructs the Susceptance Norm label object.
Definition SusceptanceNormLabel.hpp:66
+
egoa::SusceptanceNormLabel::operator+=
SusceptanceNormLabel & operator+=(TElement const &rhs)
In place addition.
Definition SusceptanceNormLabel.hpp:353
+
egoa::SusceptanceNormLabel::SusceptanceNorm
Types::real SusceptanceNorm() const
Getter and setter for the susceptance norm.
Definition SusceptanceNormLabel.hpp:376
+
egoa::SusceptanceNormLabel::TVertexId
Types::vertexId TVertexId
Definition Label.hpp:37
+
egoa::SusceptanceNormLabel::VertexSet
TVertexSet const & VertexSet() const
Getter of the set of all visited vertices from the source.
Definition SusceptanceNormLabel.hpp:150
+ +
egoa::SusceptanceNormLabel::SusceptanceNormLabel
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm)
Constructs the Susceptance Norm label object.
Definition SusceptanceNormLabel.hpp:92
+
egoa::SusceptanceNormLabel::operator<
bool operator<(SusceptanceNormLabel const &rhs) const
Strict domination using less than.
Definition SusceptanceNormLabel.hpp:177
+
egoa::SusceptanceNormLabel::SourceLabel
static SusceptanceNormLabel SourceLabel(Types::vertexId vertexId)
Generate source label.
Definition SusceptanceNormLabel.hpp:136
+
egoa::SusceptanceNormLabel::operator>=
bool operator>=(SusceptanceNormLabel const &rhs) const
Weak domination using greater or equal than.
Definition SusceptanceNormLabel.hpp:213
+
egoa::SusceptanceNormLabel::operator!=
bool operator!=(SusceptanceNormLabel const &rhs) const
Inequality check.
Definition SusceptanceNormLabel.hpp:242
+ +
egoa::SusceptanceNormLabel::SusceptanceNormLabel
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)
Constructs the Susceptance Norm label object.
Definition SusceptanceNormLabel.hpp:107
+
egoa::SusceptanceNormLabel::SusceptanceNorm
Types::real & SusceptanceNorm()
Getter and setter for the susceptance norm.
Definition SusceptanceNormLabel.hpp:388
+
egoa::SusceptanceNormLabel::~SusceptanceNormLabel
~SusceptanceNormLabel()
Destroys the susceptance norm label object.
Definition SusceptanceNormLabel.hpp:126
+
egoa::SusceptanceNormLabel::operator==
bool operator==(SusceptanceNormLabel const &rhs) const
Equality check.
Definition SusceptanceNormLabel.hpp:230
+
egoa::SusceptanceNormLabel::operator+
friend bool operator+(SusceptanceNormLabel const &lhs, TVertexId const &vertexId)
Addition operators testing for cycles.
Definition SusceptanceNormLabel.hpp:263
+ +
egoa::SusceptanceNormLabel::operator+
friend std::pair< SusceptanceNormLabel, bool > operator+(TElement const &edge, SusceptanceNormLabel const &rhs)
Addition operators testing for cycles.
Definition SusceptanceNormLabel.hpp:308
+
egoa::SusceptanceNormLabel::operator+
friend std::pair< TVertexSet, bool > operator+(TVertexId const &vertexId, SusceptanceNormLabel const &rhs)
Addition operators testing for cycles.
Definition SusceptanceNormLabel.hpp:284
+
egoa::SusceptanceNormLabel::operator>
bool operator>(SusceptanceNormLabel const &rhs) const
Strict domination using greater than.
Definition SusceptanceNormLabel.hpp:201
+
egoa::SusceptanceNormLabel::operator<<
friend std::ostream & operator<<(std::ostream &os, SusceptanceNormLabel const &rhs)
Output stream.
Definition SusceptanceNormLabel.hpp:416
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_timer_8hpp_source.html b/_timer_8hpp_source.html new file mode 100644 index 00000000..f3276450 --- /dev/null +++ b/_timer_8hpp_source.html @@ -0,0 +1,343 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary/Timer.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Timer.hpp
+
+
+
1/*
+
2 * Timer.hpp
+
3 *
+
4 * Created on: Jan 29, 2019
+
5 * Author: Franziska Wegner
+
6 *
+
7 * Sources of discussion:
+
8 * * https://blog.habets.se/2010/09/gettimeofday-should-never-be-used-to-measure-time.html
+
9 * * https://linux.die.net/man/2/clock_gettime
+
10 * * https://svn.boost.org/trac10/ticket/7719
+
11 * * stackoverflow.com/q/13478093/175849
+
12 * * www.opensource.apple.com/source/xnu/xnu-1486.2.11/osfmk/man/clock_get_time.html
+
13 * * https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/ia-32-ia-64-benchmark-code-execution-paper.pdf
+
14 */
+
15
+
16#ifndef EGOA__AUXILIARY__TIMER_HPP
+
17#define EGOA__AUXILIARY__TIMER_HPP
+
18
+
19#include "Constants.hpp"
+
20#include "Types.hpp"
+
21
+
22// Linux operation systems such as Debian, Ubuntu, Gentoo, Fedora, openSUSE, RedHat, or Centos
+
23#if defined (__linux__)
+
24 #include <time.h>
+
25 #include <sys/time.h>
+
26// Apple and iOS
+
27#elif defined(__APPLE__) && defined(__MACH__)
+
28 #include <mach/mach_time.h>
+
29 #include <mach/clock.h>
+
30 #include <mach/mach.h>
+
31#endif
+
32
+
33namespace egoa::Auxiliary {
+
34
+
+
57class Timer {
+
58 public:
+
59 Timer() { TimeStamp(); }
+
60
+
61 inline void Restart () { TimeStamp(); }
+
62
+
63 inline Types::largeReal ElapsedMilliseconds() {
+
64 return ElapsedMillisecondsOS();
+
65 }
+
66
+
67 private:
+
72#if defined (__linux__)
+
77#ifdef EGOA_TIMER_CLOCK_REALTIME
+
78 clockid_t linuxClockId = CLOCK_REALTIME;
+
83#elif defined(EGOA_TIMER_CLOCK_REALTIME_COARSE)
+
84 clockid_t linuxClockId = CLOCK_REALTIME_COARSE;
+
91#elif defined(EGOA_TIMER_CLOCK_MONOTONIC)
+
92 clockid_t linuxClockId = CLOCK_MONOTONIC;
+
97#elif defined(EGOA_TIMER_CLOCK_MONOTONIC_COARSE)
+
98 clockid_t linuxClockId = CLOCK_MONOTONIC_COARSE;
+
103#elif defined(EGOA_TIMER_CLOCK_MONOTONIC_RAW)
+
104 clockid_t linuxClockId = CLOCK_MONOTONIC_RAW;
+
111#elif defined(EGOA_TIMER_CLOCK_BOOTTIME)
+
112 clockid_t linuxClockId = CLOCK_BOOTTIME;
+
116#elif defined(EGOA_TIMER_CLOCK_PROCESS_CPUTIME_ID)
+
117 clockid_t linuxClockId = CLOCK_PROCESS_CPUTIME_ID;
+
121#elif defined(EGOA_TIMER_CLOCK_THREAD_CPUTIME_ID)
+
122 clockid_t linuxClockId = CLOCK_THREAD_CPUTIME_ID;
+
123 // inline void GetTime( struct timespec * ts ) {
+
124 // clock_gettime(CLOCK_THREAD_CPUTIME_ID, ts);
+
125 // }
+
126#else
+
127 clockid_t linuxClockId = CLOCK_MONOTONIC_RAW;
+
128#endif // Specified clock measurement
+
129 struct timespec start_;
+
130
+
137 inline void TimeStamp( struct timespec * timeStamp ) {
+
138 clock_gettime( linuxClockId, timeStamp );
+
139 }
+
140
+
144 inline void TimeStamp() {
+
145 clock_gettime( linuxClockId, & start_ );
+
146 }
+
147
+
156 inline void ElapsedTime( struct timespec * elapsedTime ) {
+
157 TimeStamp( elapsedTime );
+
158 elapsedTime->tv_sec = elapsedTime->tv_sec - start_.tv_sec;
+
159 elapsedTime->tv_nsec = elapsedTime->tv_nsec - start_.tv_nsec;
+
160 }
+
161
+
170 inline Types::largeReal ElapsedMillisecondsOS() {
+
171 struct timespec elapsedTime;
+
172 ElapsedTime( & elapsedTime );
+
173 return TimespecToMilliseconds( & elapsedTime );
+
174 }
+
175
+
184 inline Types::posInteger GetClockResolution() {
+
185 struct timespec res;
+
186 return clock_getres(linuxClockId, &res);
+
187 }
+
188
+
194 inline void MillisecondsToTimespec ( Types::largeReal milliseconds
+
195 , struct timespec * ts )
+
196 {
+
197 Types::largeReal seconds = milliseconds / Const::MILLISEC_PER_SEC;
+
198 Types::largeReal remainder = milliseconds - seconds * Const::MILLISEC_PER_SEC;
+
199 ts->tv_sec = seconds;
+
200 ts->tv_nsec = std::llround(remainder * Const::NSEC_PER_MILLISEC);
+
201 }
+
202
+
203 inline void TimespecToMilliseconds ( struct timespec * ts
+
204 , Types::largeReal & milliseconds )
+
205 {
+
206 milliseconds = ts->tv_sec * Const::MILLISEC_PER_SEC;
+
207 milliseconds += static_cast<Types::largeReal>( ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
208 }
+
209
+
210 inline Types::largeReal TimespecToMilliseconds ( struct timespec * ts ) {
+
211 return static_cast<Types::largeReal>( ts->tv_sec * Const::MILLISEC_PER_SEC + ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
212 }
+
214// end of defined (__linux__)
+
215#elif defined(__APPLE__) && defined(__MACH__) // Apple and iOS
+
216 Types::posInteger start_;
+
217
+
224 inline void TimeStamp( Types::posInteger * timeStamp ) {
+
225 (*timeStamp) = mach_absolute_time();
+
226 }
+
227
+
231 inline void TimeStamp() {
+
232 start_ = mach_absolute_time();
+
233 }
+
234
+
243 inline void ElapsedTime( Types::posInteger * elapsedTime ) {
+
244 TimeStamp( elapsedTime );
+
245 (*elapsedTime) = (*elapsedTime) - start_;
+
246 }
+
247
+
256 inline Types::largeReal ElapsedMillisecondsOS() {
+
257 Types::posInteger elapsedTime;
+
258 ElapsedTime( &elapsedTime );
+
259
+
260 mach_timebase_info_data_t info;
+
261 assert( mach_timebase_info (&info) == KERN_SUCCESS); // Check if mach_timebase_info failed
+
262
+
263 // nanosecs = elapsedTime * info.numer / info.denom;
+
264 // millisecs = nanosecs / Const::NSEC_PER_MILLISEC;
+
265 // seconds = nanosecs / Const::NSEC_PER_SEC;
+
266 return static_cast<Types::largeReal>( elapsedTime * info.numer / info.denom ) / Const::NSEC_PER_MILLISEC;
+
267 }
+
268
+
277 inline Types::posInteger GetClockResolution() {
+
278 return 1;
+
279 }
+
280// #elif defined(__unix__)
+
281#elif defined (_WIN32)
+
282 // #error "Windows 32-bit operation system"
+
283 struct timespec start_;
+
284
+
291 inline void TimeStamp( struct timespec * timeStamp ) {
+
292 GetSystemTime( timeStamp );
+
293 }
+
294
+
298 inline void TimeStamp() {
+
299 GetSystemTime( & start_ );
+
300 }
+
301
+
310 inline void ElapsedTime( struct timespec * elapsedTime ) {
+
311 TimeStamp( elapsedTime );
+
312 elapsedTime->tv_sec = elapsedTime->tv_sec - start_.tv_sec;
+
313 elapsedTime->tv_nsec = elapsedTime->tv_nsec - start_.tv_nsec;
+
314 }
+
315
+
324 inline Types::largeReal ElapsedMillisecondsOS() {
+
325 struct timespec elapsedTime;
+
326 ElapsedTime( & elapsedTime );
+
327 return TimespecToMilliseconds( & elapsedTime );
+
328 }
+
329
+
338 inline Types::posInteger GetClockResolution() {
+
339 struct timespec res;
+
340 return clock_getres(linuxClockId, &res);
+
341 }
+
342
+
348 inline void MillisecondsToTimespec ( Types::largeReal milliseconds
+
349 , struct timespec * ts )
+
350 {
+
351 Types::largeReal seconds = milliseconds / Const::MILLISEC_PER_SEC;
+
352 Types::largeReal remainder = milliseconds - seconds * Const::MILLISEC_PER_SEC;
+
353 ts->tv_sec = seconds;
+
354 ts->tv_nsec = std::llround(remainder * Const::NSEC_PER_MILLISEC);
+
355 }
+
356
+
357 inline void TimespecToMilliseconds ( struct timespec * ts
+
358 , Types::largeReal & milliseconds )
+
359 {
+
360 milliseconds = ts->tv_sec * Const::MILLISEC_PER_SEC;
+
361 milliseconds += static_cast<Types::largeReal>( ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
362 }
+
363
+
364 inline Types::largeReal TimespecToMilliseconds ( struct timespec * ts ) {
+
365 return static_cast<Types::largeReal>( ts->tv_sec * Const::MILLISEC_PER_SEC + ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
366 }
+
367#elif defined (_WIN64)
+
368// #error "Windows 64-bit operation system"
+
369 struct timespec start_;
+
370
+
377 inline void TimeStamp( struct timespec * timeStamp ) {
+
378 GetSystemTime( timeStamp );
+
379 }
+
380
+
384 inline void TimeStamp() {
+
385 GetSystemTime( & start_ );
+
386 }
+
387
+
396 inline void ElapsedTime( struct timespec * elapsedTime ) {
+
397 TimeStamp( elapsedTime );
+
398 elapsedTime->tv_sec = elapsedTime->tv_sec - start_.tv_sec;
+
399 elapsedTime->tv_nsec = elapsedTime->tv_nsec - start_.tv_nsec;
+
400 }
+
401
+
410 inline Types::largeReal ElapsedMillisecondsOS() {
+
411 struct timespec elapsedTime;
+
412 ElapsedTime( & elapsedTime );
+
413 return TimespecToMilliseconds( & elapsedTime );
+
414 }
+
415
+
424 inline Types::posInteger GetClockResolution() {
+
425 struct timespec res;
+
426 return clock_getres(linuxClockId, &res);
+
427 }
+
428
+
434 inline void MillisecondsToTimespec ( Types::largeReal milliseconds
+
435 , struct timespec * ts )
+
436 {
+
437 Types::largeReal seconds = milliseconds / Const::MILLISEC_PER_SEC;
+
438 Types::largeReal remainder = milliseconds - seconds * Const::MILLISEC_PER_SEC;
+
439 ts->tv_sec = seconds;
+
440 ts->tv_nsec = std::llround(remainder * Const::NSEC_PER_MILLISEC);
+
441 }
+
442
+
443 inline void TimespecToMilliseconds ( struct timespec * ts
+
444 , Types::largeReal & milliseconds )
+
445 {
+
446 milliseconds = ts->tv_sec * Const::MILLISEC_PER_SEC;
+
447 milliseconds += static_cast<Types::largeReal>( ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
448 }
+
449
+
450 inline Types::largeReal TimespecToMilliseconds ( struct timespec * ts ) {
+
451 return static_cast<Types::largeReal>( ts->tv_sec * Const::MILLISEC_PER_SEC + ts->tv_nsec ) / Const::NSEC_PER_MILLISEC;
+
452 }
+
453#endif
+
454};
+
+
455
+
456} // namespace egoa::Auxiliary
+
457
+
458#endif // EGOA__AUXILIARY__TIMER_HPP
+ +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_traversal_8hpp_source.html b/_traversal_8hpp_source.html new file mode 100644 index 00000000..cecd49f4 --- /dev/null +++ b/_traversal_8hpp_source.html @@ -0,0 +1,354 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal/Traversal.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Traversal.hpp
+
+
+
1/*
+
2 * Traversal.hpp
+
3 *
+
4 * Created on: Feb 18, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7#ifndef EGOA__ALGORITHMS__GRAPH_TRAVERSAL__TRAVERSAL__HPP
+
8#define EGOA__ALGORITHMS__GRAPH_TRAVERSAL__TRAVERSAL__HPP
+
9
+
10#include <vector>
+
11
+
12#include "Auxiliary/Constants.hpp"
+
13#include "Auxiliary/ExecutionPolicy.hpp"
+
14
+
15#include "Exceptions/Assertions.hpp"
+
16
+
17namespace egoa{
+
18
+
19namespace internal {
+
20
+
21template< typename GraphType, bool IsDirected >
+
22class GraphTypeLoopDifferentiation;
+
23
+
24} // namespace internal
+
25
+
34template< typename GraphType,
+
35 bool IsDirected = false >
+
+
36class Traversal {
+
37 public:
+
38 using TGraph = GraphType;
+
39 using TVertexId = typename GraphType::TVertexId;
+
40
+
43#pragma mark CONSTRUCTOR_AND_DESTRUCTOR
+
44
+
+
51 Traversal ( TGraph const & graph, TVertexId source )
+
52 : graph_ ( graph )
+
53 , source_ ( source )
+
54 , visited_ ( std::vector<bool>( graph.NumberOfVertices(), false ) )
+
55 , processed_( std::vector<bool>( graph.NumberOfVertices(), false ) )
+
56 , parent_ ( std::vector<TVertexId>( graph.NumberOfVertices(), Const::NONE ) ) {}
+
+
57
+
58 virtual ~Traversal() {}
+
60
+
61#pragma mark GETTER_AND_SETTER
+
68 inline TVertexId Source() const { return source_; }
+
69 inline TVertexId & Source() { return source_; }
+
71
+
72#pragma mark RESULT_EXTRACTION
+
73 virtual inline void Result ( std::vector<TVertexId> parent )
+
74 {
+
75 // @todo Implement, see MST
+
76 throw std::runtime_error("Not implemented yet!");
+
77 }
+
78
+
79 protected:
+
80
+
83#pragma mark VERTEX_VISITED_METHODS
+
+
89 inline void SetVertexVisitedAt ( TVertexId vertexId )
+
90 {
+
91 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
92 visited_[vertexId] = true;
+
93 }
+
+
94
+
+
104 inline bool VisitedVertexAt ( TVertexId vertexId ) const
+
105 {
+
106 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
107 return visited_[vertexId];
+
108 }
+
+
110
+
113#pragma mark VERTEX_PROCESSED_METHODS
+
+
119 inline void SetVertexProcessedAt ( TVertexId vertexId )
+
120 {
+
121 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
122 processed_[vertexId] = true;
+
123 }
+
+
124
+
+
135 inline bool ProcessedVertexAt ( TVertexId vertexId ) const
+
136 {
+
137 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
138 return processed_[vertexId];
+
139 }
+
+
141
+
142 public:
+
143#pragma mark PARENT_METHODS
+
+
152 inline TVertexId & ParentOf ( TVertexId vertexId )
+
153 {
+
154 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
155 return parent_[vertexId];
+
156 }
+
+
157
+
158 inline TVertexId ParentOf ( TVertexId vertexId ) const
+
159 {
+
160 USAGE_ASSERT ( graph_.VertexExists ( vertexId ) );
+
161 return parent_[vertexId];
+
162 }
+
164
+
167#pragma mark FURTHER_PROCESSING
+
168
+
169 // virtual inline void PreprocessingVertexWith ( TVertexId vertex ) = 0;
+
170 // virtual inline void PostprocessingVertexWith ( TVertexId vertex ) = 0;
+
171 // virtual inline void ProcessingEdgeWith ( TVertexId source,
+
172 // TVertexId target,
+
173 // Types::edgeId edgeId ) = 0;
+
175
+
176 protected:
+
177#pragma mark OTHER_METHODS
+
+
181 inline void Clear ()
+
182 {
+
183 visited_.clear ();
+
184 visited_.resize ( graph_.NumberOfVertices(), false );
+
185
+
186 processed_.clear ();
+
187 processed_.resize ( graph_.NumberOfVertices(), false );
+
188
+
189 parent_.clear ();
+
190 parent_.resize ( graph_.NumberOfVertices(), Const::NONE );
+
191 }
+
+
192
+
193 inline bool VertexExists ( TVertexId vertexId )
+
194 {
+
195 return graph_.VertexExists ( vertexId );
+
196 }
+
197
+
198 inline bool NumberOfVertices()
+
199 {
+
200 return graph_.NumberOfVertices ( );
+
201 }
+
202
+
210#pragma mark LOOPS
+
230 template<typename FUNCTION>
+
+
231 inline void breakable_for_all_edges_at ( TVertexId const & vertexId
+
232 , FUNCTION function ) const
+
233 {
+
234 internal::GraphTypeLoopDifferentiation<TGraph, IsDirected>
+
235 ::breakable_for_all_edges_at ( graph_, vertexId, function );
+
236 }
+
+
237
+
256 template<typename FUNCTION>
+
+
257 inline void for_all_edges_at ( TVertexId const & vertexId
+
258 , FUNCTION function ) const
+
259 {
+
260 internal::GraphTypeLoopDifferentiation<TGraph, IsDirected>
+
261 ::for_all_edges_at ( graph_, vertexId, function );
+
262 }
+
+
264#pragma mark FRIEND
+
265 private:
+
266 friend class internal::GraphTypeLoopDifferentiation<TGraph, true>;
+
267 friend class internal::GraphTypeLoopDifferentiation<TGraph, false>;
+
268
+
269#pragma mark MEMBERS
+
270 private:
+
271 TGraph const & graph_;
+
273 TVertexId source_;
+
274 std::vector<bool> visited_;
+
275 std::vector<bool> processed_;
+
276 std::vector<TVertexId> parent_;
+
277};
+
+
278
+
279namespace internal {
+
280
+
281#pragma mark DIRECTED_GRAPH_LOOP
+
282
+
283template<typename GraphType>
+
+
284class GraphTypeLoopDifferentiation< GraphType, true > {
+
285 // Type aliasing
+
286 using TGraph = GraphType;
+
287 using TVertexId = typename GraphType::TVertexId;
+
288
+
289 public:
+
290 template<typename FUNCTION>
+
291 static inline
+
292 void breakable_for_all_edges_at ( TGraph const & graph
+
293 , TVertexId const & vertex
+
294 , FUNCTION function )
+
295 {
+
296 graph.template for_out_edges_at<ExecutionPolicy::breakable> ( vertex, function );
+
297 }
+
298
+
299 template<typename FUNCTION>
+
300 static inline
+
301 void for_all_edges_at ( TGraph const & graph
+
302 , TVertexId const & vertex
+
303 , FUNCTION function )
+
304 {
+
305 graph.template for_out_edges_at<ExecutionPolicy::sequential> ( vertex, function );
+
306 }
+
307};
+
+
308
+
309#pragma mark UNDIRECTED_GRAPH_LOOP
+
310
+
311template<typename GraphType>
+
+
312class GraphTypeLoopDifferentiation< GraphType, false > {
+
313 // Type aliasing
+
314 using TGraph = GraphType;
+
315 using TVertexId = typename GraphType::TVertexId;
+
316
+
317 public:
+
318 template<typename FUNCTION>
+
319 static inline
+
320 void breakable_for_all_edges_at ( TGraph const & graph
+
321 , TVertexId const & vertex
+
322 , FUNCTION function )
+
323 {
+
324 graph.template for_all_edges_at<ExecutionPolicy::breakable> ( vertex, function );
+
325 }
+
326
+
327 template<typename FUNCTION>
+
328 static inline
+
329 void for_all_edges_at ( TGraph & graph
+
330 , TVertexId const & vertex
+
331 , FUNCTION function )
+
332 {
+
333 graph.template for_all_edges_at<ExecutionPolicy::sequential> ( vertex, function );
+
334 }
+
335};
+
+
336
+
337} // namespace internal
+
338
+
339} // namespace Traversal
+
340
+
341
+
342#endif // EGOA__ALGORITHMS__GRAPH_TRAVERSAL__TRAVERSAL__HPP
+
egoa::Traversal
Interface for graph traversal.
Definition Traversal.hpp:36
+
egoa::Traversal::breakable_for_all_edges_at
void breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges that is breakable.
Definition Traversal.hpp:231
+
egoa::Traversal::Clear
void Clear()
Clear and resize all vectors.
Definition Traversal.hpp:181
+
egoa::Traversal::SetVertexProcessedAt
void SetVertexProcessedAt(TVertexId vertexId)
Sets the vertex at vertexId to processed.
Definition Traversal.hpp:119
+
egoa::Traversal::processed_
std::vector< bool > processed_
Definition Traversal.hpp:275
+
egoa::Traversal::Traversal
Traversal(TGraph const &graph, TVertexId source)
Constructs a new instance.
Definition Traversal.hpp:51
+
egoa::Traversal::ProcessedVertexAt
bool ProcessedVertexAt(TVertexId vertexId) const
Getter and setter to access the process field.
Definition Traversal.hpp:135
+
egoa::Traversal::parent_
std::vector< TVertexId > parent_
Definition Traversal.hpp:276
+
egoa::Traversal::visited_
std::vector< bool > visited_
Definition Traversal.hpp:274
+
egoa::Traversal::VisitedVertexAt
bool VisitedVertexAt(TVertexId vertexId) const
Getter and setter to access the visited field.
Definition Traversal.hpp:104
+
egoa::Traversal::ParentOf
TVertexId & ParentOf(TVertexId vertexId)
Getter and setter for the parent relation.
Definition Traversal.hpp:152
+
egoa::Traversal::graph_
TGraph const & graph_
Definition Traversal.hpp:271
+
egoa::Traversal::SetVertexVisitedAt
void SetVertexVisitedAt(TVertexId vertexId)
Sets the vertex at vertexId to visited.
Definition Traversal.hpp:89
+
egoa::Traversal::source_
TVertexId source_
Definition Traversal.hpp:273
+
egoa::Traversal::Source
TVertexId Source() const
Getter and setter for the source vertex.
Definition Traversal.hpp:68
+
egoa::Traversal::for_all_edges_at
void for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges.
Definition Traversal.hpp:257
+ +
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_type_8hpp_source.html b/_type_8hpp_source.html new file mode 100644 index 00000000..e90ab73b --- /dev/null +++ b/_type_8hpp_source.html @@ -0,0 +1,119 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Type.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Type.hpp
+
+
+
1/*
+
2 * Type.hpp
+
3 *
+
4 * Created on: May 22, 2019
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__TYPE_HPP
+
9#define EGOA__DATA_STRUCTURES__TYPE_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12#include "DataStructures/Graphs/Vertices/Type.hpp"
+
13
+
14namespace egoa {
+
15
+
18#pragma mark POWER_GRID_CONVERSION_METHODS
+
19 inline Types::string BoundTypeToString ( Vertices::BoundType const & boundType )
+
20 {
+
21 if ( Vertices::BoundType::exact == boundType ) return "exact";
+
22 else if ( Vertices::BoundType::bounded == boundType ) return "bounded";
+
23 else if ( Vertices::BoundType::unbounded == boundType ) return "unbounded";
+
24 else if ( Vertices::BoundType::pureunbounded == boundType ) return "pureunbounded" ;
+
25 return "unknown";
+
26 }
+
28
+
29} // namespace egoa
+
30
+
31#endif // EGOA__DATA_STRUCTURES__TYPE_HPP
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_union_find_8hpp_source.html b/_union_find_8hpp_source.html new file mode 100644 index 00000000..093ea97f --- /dev/null +++ b/_union_find_8hpp_source.html @@ -0,0 +1,205 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/UnionFind.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
UnionFind.hpp
+
+
+
1/*
+
2 * UnionFind.hpp
+
3 *
+
4 * Created on: Nov 20, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__CONTAINER__UNION_FIND_HPP
+
9#define EGOA__CONTAINER__UNION_FIND_HPP
+
10
+
11#include "Auxiliary/Auxiliary.hpp"
+
12#include "Exceptions/Assertions.hpp"
+
13
+
14namespace egoa {
+
15
+
+
19class UnionFind {
+
20 public:
+
21 UnionFind( Types::count numberOfVertices )
+
22 : parent_( numberOfVertices, 0 )
+
23 , numberOfVerticesInSubtree_( numberOfVertices, 1 )
+
24 , numberOfVertices_( numberOfVertices )
+
25 {
+
26 // Every vertex has itself as parent
+
27 for ( Types::count counter = 0
+
28 ; counter < NumberOfVertices()
+
29 ; ++counter )
+
30 {
+
31 Parent ( counter ) = counter;
+
32 }
+
33 }
+
34
+
+
44 inline Types::vertexId Find ( Types::vertexId vertex )
+
45 {
+
46 if ( Parent(vertex) == vertex ) return vertex;
+
47 else return Find ( Parent(vertex) );
+
48 }
+
+
49
+
+
57 inline void Union ( Types::vertexId u, Types::vertexId v )
+
58 {
+
59 Types::vertexId root1 = Find(u);
+
60 Types::vertexId root2 = Find(v);
+
61
+
62 if ( root1 == root2 ) return;
+
63
+
64 if ( SubtreeSize(root1) > SubtreeSize(root2) )
+
65 {
+
66 SubtreeSize(root1) += SubtreeSize(root2);
+
67 Parent(root2) = root1;
+
68 } else {
+
69 SubtreeSize(root2) += SubtreeSize(root1);
+
70 Parent(root1) = root2;
+
71 }
+
72 }
+
+
73
+
+
82 inline bool InSameComponent ( Types::vertexId u, Types::vertexId v )
+
83 {
+
84 return Find(u) == Find(v);
+
85 }
+
+
86
+
+
89 inline Types::count NumberOfVertices()
+
90 {
+
91 return numberOfVertices_;
+
92 }
+
+
93
+
94 inline Types::vertexId & Parent ( Types::vertexId vertex )
+
95 {
+
96 USAGE_ASSERT ( vertex < numberOfVertices_
+
97 || vertex == Const::NONE );
+
98 return parent_[vertex];
+
99 }
+
100
+
101 inline Types::vertexId Parent ( Types::vertexId vertex ) const
+
102 {
+
103 USAGE_ASSERT ( vertex < numberOfVertices_
+
104 || vertex == Const::NONE );
+
105 return parent_[vertex];
+
106 }
+
107
+
108 inline Types::count & SubtreeSize ( Types::vertexId vertex )
+
109 {
+
110 USAGE_ASSERT ( vertex < numberOfVertices_ );
+
111 return numberOfVerticesInSubtree_[vertex];
+
112 }
+
113
+
114 inline Types::count SubtreeSize ( Types::vertexId vertex ) const
+
115 {
+
116 USAGE_ASSERT ( vertex < numberOfVertices_ );
+
117 return numberOfVerticesInSubtree_[vertex];
+
118 }
+
120
+
121 private:
+
122 std::vector<Types::vertexId> parent_; /*< Parent pointer */
+
123 std::vector<Types::count> numberOfVerticesInSubtree_; /*< Number of vertices in subtree i */
+
124 Types::count numberOfVertices_; /*< Number of vertices */
+
125};
+
+
126
+
127} // namespace egoa
+
128
+
129#endif // EGOA__CONTAINER__UNION_FIND_HPP
+
egoa::UnionFind
This class describes an union find.
Definition UnionFind.hpp:19
+
egoa::UnionFind::Union
void Union(Types::vertexId u, Types::vertexId v)
Merges the two subtrees—if exist—of both components together.
Definition UnionFind.hpp:57
+
egoa::UnionFind::NumberOfVertices
Types::count NumberOfVertices()
Definition UnionFind.hpp:89
+
egoa::UnionFind::InSameComponent
bool InSameComponent(Types::vertexId u, Types::vertexId v)
Are both vertices in the same component.
Definition UnionFind.hpp:82
+
egoa::UnionFind::Find
Types::vertexId Find(Types::vertexId vertex)
Find the root of the vertex @detail Find the tree root of element vertex and return the root's identi...
Definition UnionFind.hpp:44
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_vector_view_8hpp_source.html b/_vector_view_8hpp_source.html new file mode 100644 index 00000000..0a0dadaf --- /dev/null +++ b/_vector_view_8hpp_source.html @@ -0,0 +1,159 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Views/VectorView.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
VectorView.hpp
+
+
+
1
+
8#ifndef EGOA__DATA_STRUCTURES__VIEWS__VECTOR_VIEW_HPP
+
9#define EGOA__DATA_STRUCTURES__VIEWS__VECTOR_VIEW_HPP
+
10
+
11#include <ostream>
+
12
+
13#include "Auxiliary/Types.hpp"
+
14
+
15namespace egoa {
+
16
+
23template<typename ElementType, bool Const>
+
+
24class VectorView {
+
25 using TElement = ElementType;
+
26 using TVector = typename std::conditional<Const,
+
27 std::vector<TElement> const,
+
28 std::vector<TElement>
+
29 >::type;
+
30 public:
+
31 using TIterator = typename std::conditional<Const,
+
32 typename TVector::const_iterator,
+
33 typename TVector::iterator
+
34 >::type;
+
35 using TReverseIterator = typename std::conditional<Const,
+
36 typename TVector::const_reverse_iterator,
+
37 typename TVector::reverse_iterator
+
38 >::type;
+
39 using TReference = typename std::conditional<Const,
+
40 TElement const &,
+
41 TElement &
+
42 >::type;
+
43
+
44 explicit VectorView(TVector * vector) : vector_(vector) {}
+
45
+
46 TIterator begin() const noexcept { return vector_->begin(); }
+
47 TIterator end() const noexcept { return vector_->end(); }
+
48 TReverseIterator rbegin() const noexcept { return vector_->rbegin(); }
+
49 TReverseIterator rend() const noexcept { return vector_->rend(); }
+
50 bool empty() const noexcept { return vector_->empty(); }
+
51 Types::count size() const noexcept { return vector_->size(); }
+
52 TReference operator[](Types::index index) const { return (*vector_)[index]; }
+
53
+
54 private:
+
55 TVector * vector_;
+
56};
+
+
57
+
66template<typename ElementType, bool Const>
+
+
67inline std::ostream & operator<<(std::ostream & os,
+
68 VectorView<ElementType, Const> const & view) {
+
69 os << "[";
+
70 auto first = view.begin();
+
71 for (auto it = first; it != view.end(); ++it) {
+
72 if (it != first) {
+
73 os << ", ";
+
74 }
+
75 os << *it;
+
76 }
+
77 os << "]";
+
78 return os;
+
79}
+
+
80
+
81} // namespace egoa
+
82
+
83#endif // EGOA__DATA_STRUCTURES__VIEWS__VECTOR_VIEW_HPP
+
egoa::VectorView
Provides a restricted view on a vector.
Definition VectorView.hpp:24
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_vertex_8hpp_source.html b/_vertex_8hpp_source.html new file mode 100644 index 00000000..05ed9cb5 --- /dev/null +++ b/_vertex_8hpp_source.html @@ -0,0 +1,179 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices/Vertex.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vertex.hpp
+
+
+
1/*
+
2 * Vertex.hpp
+
3 *
+
4 * Created on: Sep 06, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__VERTEX_HPP
+
9#define EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__VERTEX_HPP
+
10
+
11#include "Type.hpp"
+
12
+
13namespace egoa {
+
14 template<typename, typename>
+
15 class DynamicGraph;
+
16}
+
17
+
18namespace egoa::Vertices {
+
19
+
28template<class PropertyType>
+
+
29class Vertex {
+
30
+
31 public:
+
32 // Template type aliasing
+
33 using TProperties = PropertyType;
+
35 public:
+
38#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
39
+
+
46 Vertex ( Types::vertexId identifier, TProperties properties )
+
47 : identifier_(identifier)
+
48 , properties_(properties)
+
49 {}
+
+
51
+
+
58 friend void swap ( Vertex & lhs, Vertex & rhs )
+
59 { // Necessary for the copy and swap idiom
+
60 using std::swap; // enable ADL
+
61 swap( lhs.identifier_, rhs.identifier_ );
+
62 swap( lhs.properties_, rhs.properties_ );
+
63 }
+
+
64
+
67#pragma mark COMPARATORS
+
68
+
+
77 friend bool operator==( Vertex const & lhs, Vertex const & rhs )
+
78 {
+
79 return ( lhs.Identifier() == rhs.Identifier() )
+
80 && ( lhs.Properties() == rhs.Properties() );
+
81 }
+
+
82
+
+
91 friend bool operator!=( Vertex const & lhs, Vertex const & rhs )
+
92 {
+
93 return !(lhs == rhs);
+
94 }
+
+
96
+
99#pragma mark SETTER_AND_GETTER
+
100 inline Types::vertexId Identifier() const { return identifier_; }
+
101
+
102 inline TProperties & Properties() { return properties_; }
+
103 inline TProperties const & Properties() const { return properties_; }
+
105
+
106 private:
+
107 template<typename, typename> friend class egoa::DynamicGraph;
+
109#pragma mark MEMBER
+
110 Types::vertexId identifier_;
+
111 TProperties properties_;
+
113};
+
+
114
+
115} // namespace egoa::Vertices
+
116
+
117#endif // EGOA__DATA_STRUCTURES__GRAPHS__VERTICES__VERTEX_HPP
+
egoa::DynamicGraph
A graph data structure that supports adding and removing vertices and edges.
Definition DynamicGraph.hpp:50
+
egoa::Vertices::Vertex
Class for a vertex.
Definition Vertex.hpp:29
+
egoa::Vertices::Vertex::TProperties
PropertyType TProperties
Definition Vertex.hpp:33
+
egoa::Vertices::Vertex::operator==
friend bool operator==(Vertex const &lhs, Vertex const &rhs)
Compares two vertices for equality.
Definition Vertex.hpp:77
+
egoa::Vertices::Vertex::swap
friend void swap(Vertex &lhs, Vertex &rhs)
Swapping the members of two Vertex.
Definition Vertex.hpp:58
+
egoa::Vertices::Vertex::properties_
TProperties properties_
Definition Vertex.hpp:111
+
egoa::Vertices::Vertex::operator!=
friend bool operator!=(Vertex const &lhs, Vertex const &rhs)
Compares two vertices for inequality.
Definition Vertex.hpp:91
+
egoa::Vertices::Vertex::identifier_
Types::vertexId identifier_
Definition Vertex.hpp:110
+
egoa::Vertices::Vertex::Vertex
Vertex(Types::vertexId identifier, TProperties properties)
Constructs the vertex object.
Definition Vertex.hpp:46
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_vertices_2_electrical_properties_8hpp_source.html b/_vertices_2_electrical_properties_8hpp_source.html new file mode 100644 index 00000000..eb750a52 --- /dev/null +++ b/_vertices_2_electrical_properties_8hpp_source.html @@ -0,0 +1,663 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices/ElectricalProperties.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ElectricalProperties.hpp
+
+
+
1/*
+
2 * ElectricalProperties.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__VERTICES__ELECTRICAL_PROPERTIES_HPP
+
9#define EGOA__DATA_STRUCTURES__VERTICES__ELECTRICAL_PROPERTIES_HPP
+
10
+
11#include <iomanip>
+
12#include <ostream>
+
13#include <string>
+
14
+
15#include "Auxiliary/Constants.hpp"
+
16
+
17#include "DataStructures/Graphs/Vertices/Type.hpp"
+
18#include "DataStructures/Bound.hpp"
+
19
+
20namespace egoa::Vertices {
+
21
+
27template<class VertexType = Vertices::IeeeBusType>
+
+
28class ElectricalProperties {
+
29 public: // Template type aliasing
+
30 // Vertex electrical type
+
31 using TVertexType = VertexType;
+
32 using TProperties = ElectricalProperties<TVertexType>;
+
33 private:
+
34 using TBound = Bound<Types::real>;
+
35
+
36 public:
+
39#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
40
+
+
45 ElectricalProperties()
+
46 : name_("")
+
47 , type_(TVertexType::unknown)
+
48 , xCoordinate_(0.0)
+
49 , yCoordinate_(0.0)
+
50 // admittance
+
51 , shuntSusceptance_(0.0)
+
52 , shuntConductance_(0.0)
+
53 // voltage
+
54 , nominalVoltage_(1.0)
+
55 , voltageAngle_(0.0)
+
56 , voltageMagnitude_(1.0)
+
57 , voltageMagnitudeSq_(1.0)
+
58 // , realVoltage_(0.0)
+
59 // , imaginaryVoltage_(0.0)
+
60 , voltageBound_( TBound(0.0, Const::REAL_INFTY) )
+
61 // location
+
62 , country_("")
+
63 , area_(0)
+
64 , zone_(0)
+
65 , control_(Vertices::ControlType::PQ)
+
66 , carrier_(EnergyCarrier::AC)
+
67 // Status
+
68 , status_(Vertices::BusStatus::active)
+
69 {}
+
+
70
+
+
74 inline void Reset ()
+
75 {
+
76 // BasicVertex specifics
+
77 Name () = "";
+
78 Type () = TVertexType::unknown;
+
79 X () = 0.0;
+
80 Y () = 0.0;
+
81
+
82 // Admittance specifics
+
83 ShuntSusceptance () = 0.0;
+
84 ShuntConductance () = 0.0;
+
85
+
86 // Voltage specifics
+
87 NominalVoltage() = 1.0;
+
88 VoltageAngle() = 0.0;
+
89 VoltageMagnitude () = 1.0;
+
90 voltageMagnitudeSq_ = 1.0;
+
91 // realVoltage_ = 0.0;
+
92 // imaginaryVoltage_ = 0.0;
+
93 voltageBound_ = TBound ( 0.0, Const::REAL_INFTY );
+
94
+
95 // Location specifics
+
96 Country () = "";
+
97 Area () = 0;
+
98 Zone () = 0;
+
99 Control () = Vertices::ControlType::PQ;
+
100 Carrier () = EnergyCarrier::AC;
+
101
+
102 // Status specifics
+
103 Status() = Vertices::BusStatus::active;
+
104 }
+
+
106
+
109#pragma mark COMPARATORS
+
+
118 inline bool operator!=( ElectricalProperties const & rhs ) const
+
119 {
+
120 return !(this == rhs);
+
121 }
+
+
122
+
+
131 inline bool operator==( ElectricalProperties const & rhs ) const
+
132 {
+
133 if ( Name() != rhs.Name() ) return false;
+
134 if ( Type() != rhs.Type() ) return false;
+
135 if ( X() != rhs.X() ) return false;
+
136 if ( Y() != rhs.Y() ) return false;
+
137 if ( ShuntSusceptance() != rhs.ShuntSusceptance() ) return false;
+
138 if ( ShuntConductance() != rhs.ShuntConductance() ) return false;
+
139 if ( NominalVoltage() != rhs.NominalVoltage() ) return false;
+
140 if ( VoltageAngle() != rhs.VoltageAngle() ) return false;
+
141 if ( VoltageMagnitude() != rhs.VoltageMagnitude() ) return false;
+
142 if ( voltageMagnitudeSq_ != rhs.voltageMagnitudeSq_ ) return false;
+
143 if ( voltageBound_ != rhs.voltageBound_ ) return false;
+
144 if ( Area() != rhs.Area() ) return false;
+
145 if ( Zone() != rhs.Zone() ) return false;
+
146 if ( Control() != rhs.Control() ) return false;
+
147 if ( Carrier() != rhs.Carrier() ) return false;
+
148 if ( Status() != rhs.Status() ) return false;
+
149 }
+
+
151
+
154#pragma mark COPY_AND_SWAP_IDIOM
+
+
161 friend void swap ( ElectricalProperties & lhs
+
162 , ElectricalProperties & rhs )
+
163 { // Necessary for the copy and swap idiom
+
164 using std::swap; // enable ADL
+
165 // Basic vertex
+
166 swap(lhs.name_, rhs.name_ );
+
167 swap(lhs.type_, rhs.type_ );
+
168 swap(lhs.xCoordinate_, rhs.xCoordinate_ );
+
169 swap(lhs.yCoordinate_, rhs.yCoordinate_ );
+
170 // Admittance
+
171 swap(lhs.shuntSusceptance_, rhs.shuntSusceptance_ );
+
172 swap(lhs.shuntConductance_, rhs.shuntConductance_ );
+
173 // Voltage
+
174 swap(lhs.nominalVoltage_, rhs.nominalVoltage_ );
+
175 swap(lhs.voltageAngle_, rhs.voltageAngle_ );
+
176 swap(lhs.voltageMagnitude_, rhs.voltageMagnitude_ );
+
177 swap(lhs.voltageMagnitudeSq_, rhs.voltageMagnitudeSq_ );
+
178 // swap(lhs.realVoltage_, rhs.realVoltage_ );
+
179 // swap(lhs.imaginaryVoltage_, rhs.imaginaryVoltage_ );
+
180 swap(lhs.voltageBound_, rhs.voltageBound_ );
+
181 // Location
+
182 swap(lhs.area_, rhs.area_ );
+
183 swap(lhs.zone_, rhs.zone_ );
+
184 swap(lhs.control_, rhs.control_ );
+
185 swap(lhs.carrier_, rhs.carrier_ );
+
186 // Status
+
187 swap(lhs.status_, rhs.status_ );
+
188 }
+
+
190
+
193#pragma mark BASIC_PROPERTIES
+
194
+
195 inline Types::name Name() const { return name_; }
+
196 inline Types::name & Name() { return name_; }
+
197
+
198 inline TVertexType Type() const { return type_; }
+
199 inline TVertexType & Type() { return type_; }
+
200
+
201 inline Types::real X() const { return xCoordinate_; }
+
202 inline Types::real & X() { return xCoordinate_; }
+
203
+
204 inline Types::real Y() const { return yCoordinate_; }
+
205 inline Types::real & Y() { return yCoordinate_; }
+
207
+
210#pragma mark ADMITTANCE
+
211
+
+
222 inline Types::real ShuntSusceptance() const
+
223 {
+
224 return shuntSusceptance_;
+
225 }
+
+
226
+
+
243 inline Types::real & ShuntSusceptance()
+
244 {
+
245 return shuntSusceptance_;
+
246 }
+
+
247
+
+
258 inline Types::real ShuntConductance() const
+
259 {
+
260 return shuntConductance_;
+
261 }
+
+
262
+
+
278 inline Types::real & ShuntConductance ()
+
279 {
+
280 return shuntConductance_;
+
281 }
+
+
283
+
286#pragma mark VOLTAGE
+
+
293 inline Types::real NominalVoltage () const
+
294 {
+
295 return nominalVoltage_;
+
296 }
+
+
297
+
+
304 inline Types::real & NominalVoltage ()
+
305 {
+
306 return nominalVoltage_;
+
307 }
+
+
308
+
+
317 inline Types::real VoltageMagnitude () const
+
318 {
+
319 return voltageMagnitude_;
+
320 }
+
+
321
+
+
331 inline Types::real & VoltageMagnitude ()
+
332 {
+
333 return voltageMagnitude_;
+
334 }
+
+
335
+
+
348 inline Types::real VoltageAngle () const
+
349 {
+
350 return voltageAngle_;
+
351 }
+
+
352
+
+
370 inline Types::real & VoltageAngle ()
+
371 {
+
372 return voltageAngle_;
+
373 }
+
+
374
+
+
383 inline Types::real MinimumVoltage () const
+
384 {
+
385 return voltageBound_.Minimum();
+
386 }
+
+
387
+
+
401 inline Types::real & MinimumVoltage ()
+
402 {
+
403 return voltageBound_.Minimum();
+
404 }
+
+
405
+
+
414 inline Types::real MaximumVoltage () const
+
415 {
+
416 return voltageBound_.Maximum();
+
417 }
+
+
418
+
+
431 inline Types::real & MaximumVoltage ()
+
432 {
+
433 return voltageBound_.Maximum();
+
434 }
+
+
436
+
439#pragma mark TYPE_SPECIFIC_INFORMATION
+
440
+
+
448 inline Types::name Country () const
+
449 {
+
450 return country_;
+
451 }
+
+
452
+
+
460 inline Types::name & Country ()
+
461 {
+
462 return country_;
+
463 }
+
+
464
+
+
480 inline Types::index Area () const
+
481 {
+
482 return area_;
+
483 }
+
+
484
+
+
505 inline Types::index & Area ()
+
506 {
+
507 return area_;
+
508 }
+
+
509
+
+
519 inline Types::index Zone () const
+
520 {
+
521 return zone_;
+
522 }
+
+
523
+
+
538 inline Types::index & Zone ()
+
539 {
+
540 return zone_;
+
541 }
+
+
542
+
+
553 inline Vertices::ControlType Control () const
+
554 {
+
555 return control_;
+
556 }
+
+
557
+
+
574 inline Vertices::ControlType & Control ()
+
575 {
+
576 return control_;
+
577 }
+
+
578
+
+
588 inline Vertices::EnergyCarrier Carrier () const
+
589 {
+
590 return carrier_;
+
591 }
+
+
592
+
+
609 inline Vertices::EnergyCarrier & Carrier ()
+
610 {
+
611 return carrier_;
+
612 }
+
+
614
+
617#pragma mark STATUS
+
618
+
+
626 inline bool IsActive () const
+
627 {
+
628 return Vertices::BusStatus::active == Status();
+
629 }
+
+
630
+
+
638 inline Vertices::BusStatus & Status ()
+
639 {
+
640 return status_;
+
641 }
+
+
642
+
+
650 inline Vertices::BusStatus const & Status () const
+
651 {
+
652 return status_;
+
653 }
+
+
655
+
658#pragma mark OUTPUT_METHODS
+
+
665 static void HeaderLong ( std::ostream & outputStream )
+
666 {
+
667 outputStream
+
668 << std::setw(6) << "ID"
+
669 << std::setw(6) << "Type"
+
670 // << std::setw(10) << "RealPowerLoad"
+
671 // << std::setw(20) << "ReactivePowerLoad"
+
672 << std::setw(20) << "ShuntSusceptance"
+
673 << std::setw(20) << "ShuntConductance"
+
674 << std::setw(6) << "Area"
+
675 << std::setw(10) << "VoltageMagnitude"
+
676 << std::setw(10) << "VoltageAngle"
+
677 << std::setw(10) << "BaseKV"
+
678 << std::setw(6) << "Zone"
+
679 << std::setw(20) << "MaximumVoltage"
+
680 << std::setw(20) << "MinimumVoltage"
+
681 << std::endl;
+
682 }
+
+
683
+
+
690 static inline void Header ( std::ostream & outputStream )
+
691 {
+
692 outputStream
+
693 << std::setw(6) << "bus_i"
+
694 << std::setw(6) << "type"
+
695 // << std::setw(10) << "Pd"
+
696 // << std::setw(10) << "Qd"
+
697 << std::setw(10) << "Gs"
+
698 << std::setw(10) << "Bs"
+
699 << std::setw(6) << "area"
+
700 << std::setw(10) << "Vm"
+
701 << std::setw(10) << "Va"
+
702 << std::setw(10) << "baseKV"
+
703 << std::setw(6) << "zone"
+
704 << std::setw(10) << "Vmax"
+
705 << std::setw(10) << "Vmin"
+
706 << std::endl;
+
707 }
+
+
708
+
+
716 inline void Line ( std::ostream & outputStream
+
717 , Types::real baseMva = 1 ) const
+
718 {
+
719 outputStream
+
720 << std::setprecision(2)
+
721 << std::fixed
+
722 << std::setw(6) << Name()
+
723 << std::setw(6) << Vertices::to_underlying( Type() )
+
724 << std::setw(10) << ShuntConductance() * baseMva
+
725 << std::setw(10) << ShuntSusceptance() * baseMva
+
726 << std::setw(6) << Area()
+
727 << std::setw(10) << VoltageMagnitude()
+
728 << std::setw(10) << VoltageAngle()
+
729 << std::setw(10) << NominalVoltage()
+
730 << std::setw(6) << Zone()
+
731 << std::setw(10) << MaximumVoltage()
+
732 << std::setw(10) << MinimumVoltage()
+
733 << std::endl;
+
734 }
+
+
735
+
+
744 inline void Line ( std::ostream & outputStream
+
745 , Types::vertexId identifier
+
746 , Types::real baseMva = 1 ) const
+
747 {
+
748 outputStream
+
749 << std::setprecision(2)
+
750 << std::fixed
+
751 << std::setw(6) << identifier
+
752 << std::setw(15) << Name()
+
753 << std::setw(6) << Vertices::to_underlying( Type() )
+
754 // << std::setw(10) << RealPowerLoad() * baseMva
+
755 // << std::setw(10) << ReactivePowerLoad() * baseMva
+
756 << std::setw(10) << ShuntConductance() * baseMva
+
757 << std::setw(10) << ShuntSusceptance() * baseMva
+
758 << std::setw(6) << Area()
+
759 << std::setw(10) << VoltageMagnitude()
+
760 << std::setw(10) << VoltageAngle()
+
761 << std::setw(10) << NominalVoltage()
+
762 << std::setw(6) << Zone()
+
763 << std::setw(10) << MaximumVoltage()
+
764 << std::setw(10) << MinimumVoltage()
+
765 << std::endl;
+
766 }
+
+
767
+
+
776 friend std::ostream & operator<< ( std::ostream & outputStream
+
777 , TProperties const & rhs )
+
778 {
+
779 outputStream
+
780 << std::setprecision(2)
+
781 << std::fixed
+
782 << std::endl
+
783 << "Bus " << rhs.Name() << std::endl
+
784 << std::string(20, '-') << std::endl
+
785 << std::setw(30) << "ID: " << std::setw(10) << rhs.Name()
+
786 // << std::setw(20) << "load: " << std::setw(10) << rhs.RealPowerLoad() << std::setw(25) << " p.u. (real, MW), "
+
787 // << std::setw(10) << rhs.ReactivePowerLoad() << std::setw(25) << " p.u. (reactive, MVar), " << std::endl
+
788 << std::setw(20) << "shunt: " << std::setw(10) << rhs.ShuntSusceptance() << std::setw(25) << " p.u. (susceptance), "
+
789 << std::setw(10) << rhs.ShuntConductance() << std::setw(25) << " p.u. (conductance), " << std::endl
+
790 << std::setw(20) << "voltage bounds: " << std::setw(10) << rhs.MinimumVoltage() << std::setw(25) << " p.u. (vmin, V), "
+
791 << std::setw(10) << rhs.MaximumVoltage() << std::setw(25) << " p.u. (vmax, V), " << std::endl
+
792 << std::setw(20) << "voltage snapshot: " << std::setw(10) << rhs.VoltageMagnitude() << std::setw(25) << " (Vm, V), "
+
793 << std::setw(20) << "area: " << std::setw(10) << rhs.Area() << std::setw(25) << "" << std::endl
+
794 << std::setw(20) << "zone: " << std::setw(10) << rhs.Zone() << std::setw(25) << "" << std::endl
+
795 << std::setw(20) << "type: " << std::setw(10) << rhs.Type() << std::setw(25) << "" << std::endl;
+
796 return outputStream;
+
797 }
+
+
799
+
800 private:
+
801
+
802#pragma mark MEMBERS
+
805 Types::name name_;
+
806 TVertexType type_;
+
807 Types::real xCoordinate_;
+
808 Types::real yCoordinate_;
+
810
+
813 Types::real shuntSusceptance_;
+
814 Types::real shuntConductance_;
+
816
+
819 Types::real nominalVoltage_;
+
822 Types::real voltageAngle_;
+
826 Types::real voltageMagnitude_;
+
830 Types::real voltageMagnitudeSq_;
+
831 // Types::real realVoltage_; /**< Real voltage */
+
832 // Types::real imaginaryVoltage_; /**< Imaginary voltage */
+
833 TBound voltageBound_;
+
837
+
840 Types::name country_;
+
841 Types::index area_;
+
851 Types::index zone_;
+
854 Vertices::ControlType control_;
+
855 Vertices::EnergyCarrier carrier_;
+
857
+
860 Vertices::BusStatus status_;
+
862};
+
+
863
+
864} // namespace egoa::Vertices
+
865
+
866#endif // EGOA__DATA_STRUCTURES__VERTICES__ELECTRICAL_PROPERTIES_HPP
+ +
egoa::Bound::Minimum
TBound Minimum() const
Getter of the minimum of the bound.
Definition Bound.hpp:61
+
egoa::Bound::Maximum
TBound Maximum() const
Getter of the maximum of the bound.
Definition Bound.hpp:85
+
egoa::Vertices::ElectricalProperties
Class for electrical properties.
Definition ElectricalProperties.hpp:28
+
egoa::Vertices::ElectricalProperties::Carrier
Vertices::EnergyCarrier Carrier() const
Getter for the energy carrier type.
Definition ElectricalProperties.hpp:588
+
egoa::Vertices::ElectricalProperties::Control
Vertices::ControlType & Control()
Getter and setter for the bus control type strategy.
Definition ElectricalProperties.hpp:574
+
egoa::Vertices::ElectricalProperties::HeaderLong
static void HeaderLong(std::ostream &outputStream)
Header out stream.
Definition ElectricalProperties.hpp:665
+
egoa::Vertices::ElectricalProperties::VoltageAngle
Types::real & VoltageAngle()
Getter for the voltage angle .
Definition ElectricalProperties.hpp:370
+ + +
egoa::Vertices::ElectricalProperties::Area
Types::index & Area()
Getter and setter for the bus area number.
Definition ElectricalProperties.hpp:505
+ + +
egoa::Vertices::ElectricalProperties::Header
static void Header(std::ostream &outputStream)
Header out stream.
Definition ElectricalProperties.hpp:690
+ +
egoa::Vertices::ElectricalProperties::Zone
Types::index & Zone()
Getter and setter for the loss zone.
Definition ElectricalProperties.hpp:538
+ + +
egoa::Vertices::ElectricalProperties::Zone
Types::index Zone() const
Getter for the loss zone.
Definition ElectricalProperties.hpp:519
+
egoa::Vertices::ElectricalProperties::Country
Types::name Country() const
Getter for the country.
Definition ElectricalProperties.hpp:448
+
egoa::Vertices::ElectricalProperties::Area
Types::index Area() const
Getter for the bus area number.
Definition ElectricalProperties.hpp:480
+
egoa::Vertices::ElectricalProperties::ShuntConductance
Types::real & ShuntConductance()
Getter and setter for the shunt conductance .
Definition ElectricalProperties.hpp:278
+
egoa::Vertices::ElectricalProperties::VoltageMagnitude
Types::real VoltageMagnitude() const
Getter for the voltage magnitude .
Definition ElectricalProperties.hpp:317
+ +
egoa::Vertices::ElectricalProperties::IsActive
bool IsActive() const
Determines if the electrical vertex is active.
Definition ElectricalProperties.hpp:626
+ +
egoa::Vertices::ElectricalProperties::operator<<
friend std::ostream & operator<<(std::ostream &outputStream, TProperties const &rhs)
Write the electrical property to an output stream.
Definition ElectricalProperties.hpp:776
+
egoa::Vertices::ElectricalProperties::ShuntSusceptance
Types::real & ShuntSusceptance()
Getter and setter for the shunt susceptance .
Definition ElectricalProperties.hpp:243
+
egoa::Vertices::ElectricalProperties::Reset
void Reset()
Reset values to default.
Definition ElectricalProperties.hpp:74
+
egoa::Vertices::ElectricalProperties::operator==
bool operator==(ElectricalProperties const &rhs) const
Equality comparator.
Definition ElectricalProperties.hpp:131
+
egoa::Vertices::ElectricalProperties::ShuntSusceptance
Types::real ShuntSusceptance() const
Getter for the shunt susceptance .
Definition ElectricalProperties.hpp:222
+
egoa::Vertices::ElectricalProperties::MinimumVoltage
Types::real & MinimumVoltage()
Getter and setter for the minimum voltage magnitude .
Definition ElectricalProperties.hpp:401
+
egoa::Vertices::ElectricalProperties::Country
Types::name & Country()
Getter and setter for the country.
Definition ElectricalProperties.hpp:460
+
egoa::Vertices::ElectricalProperties::MaximumVoltage
Types::real MaximumVoltage() const
Getter for the maximum voltage magnitude .
Definition ElectricalProperties.hpp:414
+
egoa::Vertices::ElectricalProperties::Carrier
Vertices::EnergyCarrier & Carrier()
Getter and setter for the energy carrier type.
Definition ElectricalProperties.hpp:609
+
egoa::Vertices::ElectricalProperties::NominalVoltage
Types::real NominalVoltage() const
Getter for the nominal voltage (also known as base voltage; in kV).
Definition ElectricalProperties.hpp:293
+
egoa::Vertices::ElectricalProperties::ShuntConductance
Types::real ShuntConductance() const
Getter for the shunt conductance .
Definition ElectricalProperties.hpp:258
+
egoa::Vertices::ElectricalProperties::NominalVoltage
Types::real & NominalVoltage()
Getter and setter for the nominal voltage (also known as base voltage; in kV).
Definition ElectricalProperties.hpp:304
+ +
egoa::Vertices::ElectricalProperties::Control
Vertices::ControlType Control() const
Getter for the bus control type strategy.
Definition ElectricalProperties.hpp:553
+
egoa::Vertices::ElectricalProperties::MaximumVoltage
Types::real & MaximumVoltage()
Getter and setter for the maximum voltage magnitude .
Definition ElectricalProperties.hpp:431
+
egoa::Vertices::ElectricalProperties::operator!=
bool operator!=(ElectricalProperties const &rhs) const
Inequality comparator.
Definition ElectricalProperties.hpp:118
+
egoa::Vertices::ElectricalProperties::ElectricalProperties
ElectricalProperties()
Default constructs the object.
Definition ElectricalProperties.hpp:45
+ + +
egoa::Vertices::ElectricalProperties::Line
void Line(std::ostream &outputStream, Types::real baseMva=1) const
Line out stream.
Definition ElectricalProperties.hpp:716
+
egoa::Vertices::ElectricalProperties::VoltageMagnitude
Types::real & VoltageMagnitude()
Getter and setter for the voltage magnitude .
Definition ElectricalProperties.hpp:331
+
egoa::Vertices::ElectricalProperties::Status
Vertices::BusStatus const & Status() const
Status of the electrical vertex.
Definition ElectricalProperties.hpp:650
+ +
egoa::Vertices::ElectricalProperties::MinimumVoltage
Types::real MinimumVoltage() const
Getter for the minimum voltage magnitude .
Definition ElectricalProperties.hpp:383
+ +
egoa::Vertices::ElectricalProperties::Status
Vertices::BusStatus & Status()
Status of the electrical vertex.
Definition ElectricalProperties.hpp:638
+ +
egoa::Vertices::ElectricalProperties::Line
void Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const
Writes the electrical property as a line.
Definition ElectricalProperties.hpp:744
+ +
egoa::Vertices::ElectricalProperties::VoltageAngle
Types::real VoltageAngle() const
Getter for the voltage angle .
Definition ElectricalProperties.hpp:348
+
egoa::Vertices::ElectricalProperties::swap
friend void swap(ElectricalProperties &lhs, ElectricalProperties &rhs)
Swapping the members of two ElectricalVertices.
Definition ElectricalProperties.hpp:161
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_vertices_2_type_8hpp_source.html b/_vertices_2_type_8hpp_source.html new file mode 100644 index 00000000..e6d2af5c --- /dev/null +++ b/_vertices_2_type_8hpp_source.html @@ -0,0 +1,488 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices/Type.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Type.hpp
+
+
+
1/*
+
2 * Type.hpp
+
3 *
+
4 * Created on: Sep 07, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__VERTICES__TYPE_HPP
+
9#define EGOA__DATA_STRUCTURES__VERTICES__TYPE_HPP
+
10
+
11#include "Auxiliary/Types.hpp"
+
12
+
13namespace egoa::Vertices {
+
14
+
15#pragma mark VERTEX_TYPES
+
19enum class BasicVertexType {
+
20 sink = 0,
+
21 source = 1,
+
22 intermediate = 4,
+
23 unknown = 99
+
24};
+
25
+
29enum class CdfBusType {
+
30 load = 0,
+
31 mvar = 1,
+
32 voltage = 2,
+
33 slack = 3,
+
34 unknown = 99
+
35};
+
36
+
40enum class IeeeBusType {
+
41 load = 1,
+
42 generator = 2,
+
43 slack = 3,
+
44 isolated = 4,
+
45 unknown = 99
+
46};
+
47
+
51enum class EnergyCarrier {
+
52 AC = 0,
+
53 DC = 1,
+
54 heat = 2,
+
55 gas = 3,
+
56 unknown = 99
+
57};
+
58
+
64enum class ControlType {
+
65 PQ = 0,
+
66 PV = 1,
+
67 slack = 2,
+
68 unknown = 99
+
69};
+
70
+
71
+
72#pragma mark BOUND_TYPES
+
76enum class BoundType {
+
77 unbounded = 0,
+
78 bounded = 1,
+
79 exact = 2,
+
80 pureunbounded = 3,
+
84 unknown = 99
+
85};
+
86
+
87#pragma mark GENERATOR_TYPES
+
91enum class GeneratorType {
+
92 coal = 0,
+
93 browncoal = 1,
+
94 hardcoal = 2,
+
95 nuclear = 3,
+
96 oil = 4,
+
97 // renewables
+
98 solar = 10,
+
99 onwind = 11,
+
100 offwind = 12,
+
101 ror = 13,
+
102 ccgt = 14,
+
103 ocgt = 15,
+
104 biomass = 16,
+
105 battery = 17,
+
106 // ...
+
107 unknown = 99
+
108};
+
109
+
110enum class GenerationStrategyDifferentiationType {
+
111 totalVertexPowerGenerationPerSnapshot = 0,
+
112 unknown = 99
+
113};
+
114
+
115#pragma mark VERTEX_STATUS
+
116
+
120enum class BusStatus {
+
121 inactive = 0
+
122 , active = 1
+
123 , unknown = 99
+
124};
+
125
+
126enum class PowerSign {
+
127 positive = 0
+
128 , negative = 1
+
129 , unknown = 99
+
130};
+
131
+
134#pragma mark CONVERSION_METHODS
+
135
+
143 inline BasicVertexType StringToBasicVertexType ( Types::string const & type )
+
144 {
+
145 if ( "sink" == type ) {
+
146 return Vertices::BasicVertexType::sink;
+
147 } else if ( "source" == type ) {
+
148 return Vertices::BasicVertexType::source;
+
149 } else if ( "intermediate" == type ) {
+
150 return Vertices::BasicVertexType::intermediate;
+
151 } else {
+
152 return Vertices::BasicVertexType::unknown;
+
153 }
+
154 }
+
155
+
163 inline CdfBusType StringToCdfBusType ( Types::string const & type )
+
164 {
+
165 if ( "load" == type ) {
+
166 return Vertices::CdfBusType::load;
+
167 } else if ( "mvar" == type ) {
+
168 return Vertices::CdfBusType::mvar;
+
169 } else if ( "voltage" == type ) {
+
170 return Vertices::CdfBusType::voltage;
+
171 } else if ( "slack" == type ) {
+
172 return Vertices::CdfBusType::slack;
+
173 } else {
+
174 return Vertices::CdfBusType::unknown;
+
175 }
+
176 }
+
177
+
185 inline IeeeBusType StringToIeeeBusType ( Types::string const & type )
+
186 {
+
187 if ( "load" == type ) {
+
188 return Vertices::IeeeBusType::load;
+
189 } else if ( "generator" == type ) {
+
190 return Vertices::IeeeBusType::generator;
+
191 } else if ( "slack" == type ) {
+
192 return Vertices::IeeeBusType::slack;
+
193 } else if ( "isolated" == type ) {
+
194 return Vertices::IeeeBusType::isolated;
+
195 } else {
+
196 return Vertices::IeeeBusType::unknown;
+
197 }
+
198 }
+
199
+
207 inline BoundType StringToBoundType ( Types::string const & type )
+
208 {
+
209 if ( "unbounded" == type ) {
+
210 return Vertices::BoundType::unbounded;
+
211 } else if ( "bounded" == type ) {
+
212 return Vertices::BoundType::bounded;
+
213 } else if ( "exact" == type ) {
+
214 return Vertices::BoundType::exact;
+
215 } else if ( "pureunbounded" == type ) {
+
216 return Vertices::BoundType::pureunbounded;
+
217 } else {
+
218 return Vertices::BoundType::unknown;
+
219 }
+
220 }
+
221
+
229 inline GeneratorType StringToGeneratorType ( Types::string const & type )
+
230 {
+
231 if ( "coal" == type ) {
+
232 return GeneratorType::coal;
+
233 } else if ( "browncoal" == type ) {
+
234 return GeneratorType::browncoal;
+
235 } else if ( "hardcoal" == type ) {
+
236 return GeneratorType::hardcoal;
+
237 } else if ( "nuclear" == type ) {
+
238 return GeneratorType::nuclear;
+
239 } else if ( "oil" == type ) {
+
240 return GeneratorType::oil;
+
241 } else if ( "solar" == type ) {
+
242 return GeneratorType::solar;
+
243 } else if ( "onwind" == type ) {
+
244 return GeneratorType::onwind;
+
245 } else if ( "offwind" == type ) {
+
246 return GeneratorType::offwind;
+
247 } else if ( "ror" == type ) {
+
248 return GeneratorType::ror;
+
249 } else if ( "ccgt" == type ) {
+
250 return GeneratorType::ccgt;
+
251 } else if ( "ocgt" == type ) {
+
252 return GeneratorType::ocgt;
+
253 } else if ( "biomass" == type ) {
+
254 return GeneratorType::biomass;
+
255 } else if ( "battery" == type ) {
+
256 return GeneratorType::battery;
+
257 } else {
+
258 return GeneratorType::unknown;
+
259 }
+
260 }
+
261
+
269 inline BusStatus StringToBusStatus ( Types::string const & type )
+
270 {
+
271 if ( "inactive" == type ) {
+
272 return Vertices::BusStatus::inactive;
+
273 } else if ( "active" == type ) {
+
274 return Vertices::BusStatus::active;
+
275 } else {
+
276 return Vertices::BusStatus::unknown;
+
277 }
+
278 }
+
279
+
287 inline bool BusStatusToBoolean ( BusStatus const & type )
+
288 {
+
289 if ( Vertices::BusStatus::inactive == type ) {
+
290 return false;
+
291 } else if ( Vertices::BusStatus::active == type ) {
+
292 return true;
+
293 } else {
+
294 return false;
+
295 }
+
296 }
+
297
+
305 inline PowerSign StringToPowerSign ( Types::string const & type )
+
306 {
+
307 if ( "positive" == type ) {
+
308 return Vertices::PowerSign::positive;
+
309 } else if ( "negative" == type ) {
+
310 return Vertices::PowerSign::negative;
+
311 } else {
+
312 return Vertices::PowerSign::unknown;
+
313 }
+
314 }
+
315
+
323 inline Types::integer PowerSignToInteger ( PowerSign const & type )
+
324 {
+
325 if ( Vertices::PowerSign::positive == type ) {
+
326 return 1;
+
327 } else if ( Vertices::PowerSign::negative == type ) {
+
328 return -1;
+
329 } else {
+
330 return 1;
+
331 }
+
332 }
+
333
+
341 inline EnergyCarrier StringToEnergyCarrier ( Types::string const & type )
+
342 {
+
343 if ( "AC" == type ) {
+
344 return Vertices::EnergyCarrier::AC;
+
345 } else if ( "DC" == type ) {
+
346 return Vertices::EnergyCarrier::DC;
+
347 } else if ( "heat" == type ) {
+
348 return Vertices::EnergyCarrier::heat;
+
349 } else if ( "gas" == type ) {
+
350 return Vertices::EnergyCarrier::gas;
+
351 } else {
+
352 return Vertices::EnergyCarrier::unknown;
+
353 }
+
354 }
+
355
+
363 inline ControlType StringToControlType ( Types::string const & type )
+
364 {
+
365 if ( "PQ" == type ) {
+
366 return Vertices::ControlType::PQ;
+
367 } else if ( "PV" == type ) {
+
368 return Vertices::ControlType::PV;
+
369 } else if ( "slack" == type ) {
+
370 return Vertices::ControlType::slack;
+
371 } else {
+
372 return Vertices::ControlType::unknown;
+
373 }
+
374 }
+
376
+
379#pragma mark OUTPUT_OPERATOR
+
380
+
381 inline std::ostream & operator<< ( std::ostream & os
+
382 , BasicVertexType const & rhs )
+
383 {
+
384 if ( rhs == BasicVertexType::sink ){ os << "sink"; }
+
385 else if ( rhs == BasicVertexType::source ){ os << "source"; }
+
386 else if ( rhs == BasicVertexType::intermediate ){ os << "intermediate"; }
+
387 else { os << "unknown"; }
+
388 return os;
+
389 }
+
390
+
391 inline std::ostream & operator<< ( std::ostream & os
+
392 , CdfBusType const & rhs )
+
393 {
+
394 if ( rhs == CdfBusType::load ){ os << "load bus (Type 0)"; }
+
395 else if ( rhs == CdfBusType::mvar ){ os << "Mvar generator (Type 1)"; }
+
396 else if ( rhs == CdfBusType::voltage ){ os << "voltage bus (Type 2)"; }
+
397 else if ( rhs == CdfBusType::slack ){ os << "slack bus (Type 3)"; }
+
398 else { os << "unknown"; }
+
399 return os;
+
400 }
+
401
+
402 inline std::ostream & operator<< ( std::ostream & os
+
403 , IeeeBusType const & rhs )
+
404 {
+
405 if ( rhs == IeeeBusType::load ){ os << "load bus (Type 1)"; }
+
406 else if ( rhs == IeeeBusType::generator ){ os << "generator (Type 2)"; }
+
407 else if ( rhs == IeeeBusType::slack ){ os << "slack bus (Type 3)"; }
+
408 else { os << "unknown"; }
+
409 return os;
+
410 }
+
411
+
412 inline std::ostream & operator<< ( std::ostream & os
+
413 , BoundType const & rhs )
+
414 {
+
415 if ( rhs == BoundType::unbounded ){ os << "unbounded"; }
+
416 else if ( rhs == BoundType::bounded ){ os << "bounded"; }
+
417 else if ( rhs == BoundType::exact ){ os << "exact"; }
+
418 else if ( rhs == BoundType::pureunbounded ){ os << "pure_unbounded";}
+
419 else { os << "unknown"; }
+
420 return os;
+
421 }
+
422
+
423 inline std::ostream & operator<< ( std::ostream & os
+
424 , BusStatus const & rhs )
+
425 {
+
426 if ( rhs == Vertices::BusStatus::inactive ){ os << "inactive"; }
+
427 else if ( rhs == Vertices::BusStatus::active ){ os << "active"; }
+
428 else { os << "unknown"; }
+
429 return os;
+
430 }
+
431
+
432 inline std::ostream & operator<< ( std::ostream & os
+
433 , EnergyCarrier const & rhs )
+
434 {
+
435 if ( rhs == Vertices::EnergyCarrier::AC ){ os << "AC"; }
+
436 else if ( rhs == Vertices::EnergyCarrier::DC ){ os << "DC"; }
+
437 else if ( rhs == Vertices::EnergyCarrier::heat ){ os << "heat"; }
+
438 else if ( rhs == Vertices::EnergyCarrier::gas ){ os << "gas"; }
+
439 else { os << "unknown"; }
+
440 return os;
+
441 }
+
442
+
443 inline std::ostream & operator<< ( std::ostream & os
+
444 , ControlType const & rhs )
+
445 {
+
446 if ( rhs == Vertices::ControlType::PQ ){ os << "PQ"; }
+
447 else if ( rhs == Vertices::ControlType::PV ){ os << "PV"; }
+
448 else if ( rhs == Vertices::ControlType::slack ){ os << "slack"; }
+
449 else { os << "unknown"; }
+
450 return os;
+
451 }
+
452
+
453 inline std::ostream & operator<< ( std::ostream & os
+
454 , GeneratorType const & rhs )
+
455 {
+
456 if ( GeneratorType::coal == rhs ) {
+
457 os << "coal" ;
+
458 } else if ( GeneratorType::browncoal == rhs ) {
+
459 os << "browncoal" ;
+
460 } else if ( GeneratorType::hardcoal == rhs ) {
+
461 os << "hardcoal" ;
+
462 } else if ( GeneratorType::nuclear == rhs ) {
+
463 os << "nuclear" ;
+
464 } else if ( GeneratorType::oil == rhs ) {
+
465 os << "oil" ;
+
466 } else if ( GeneratorType::solar == rhs ) {
+
467 os << "solar" ;
+
468 } else if ( GeneratorType::onwind == rhs ) {
+
469 os << "onwind" ;
+
470 } else if ( GeneratorType::offwind == rhs ) {
+
471 os << "offwind" ;
+
472 } else if ( GeneratorType::ror == rhs ) {
+
473 os << "ror" ;
+
474 } else if ( GeneratorType::ccgt == rhs ) {
+
475 os << "ccgt" ;
+
476 } else if ( GeneratorType::ocgt == rhs ) {
+
477 os << "ocgt" ;
+
478 } else if ( GeneratorType::biomass == rhs ) {
+
479 os << "biomass" ;
+
480 } else if ( GeneratorType::battery == rhs ) {
+
481 os << "battery" ;
+
482 } else {
+
483 os << "unknown" ;
+
484 }
+
485 return os;
+
486 }
+
488
+
491#pragma mark ENUM_CONVERSION
+
492
+
496 template <typename E>
+
497 constexpr auto to_underlying(E e) noexcept
+
498 {
+
499 return static_cast<std::underlying_type_t<E>>(e);
+
500 }
+
501
+
502 template< typename E , typename T>
+
503 constexpr
+
504 inline
+
505 typename
+
506 std::enable_if< std::is_enum<E>::value && std::is_integral<T>::value,
+
507 E
+
508 >::type
+
509 to_enum( T value ) noexcept {
+
510 return static_cast<E>( value );
+
511 }
+
513
+
514} // namespace egoa::Vertices
+
515
+
516#endif // EGOA__DATA_STRUCTURES__VERTICES__TYPE_HPP
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/_voltage_angle_difference_label_8hpp_source.html b/_voltage_angle_difference_label_8hpp_source.html new file mode 100644 index 00000000..de7ad74e --- /dev/null +++ b/_voltage_angle_difference_label_8hpp_source.html @@ -0,0 +1,390 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Labels/VoltageAngleDifferenceLabel.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
VoltageAngleDifferenceLabel.hpp
+
+
+
1/*
+
2 * VoltageAngleDifferenceLabel.hpp
+
3 *
+
4 * Created on: Nov 15, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifndef EGOA__DATA_STRUCTURES__LABELS__DOMINATING_THETA_PATH_LABEL_HPP
+
9#define EGOA__DATA_STRUCTURES__LABELS__DOMINATING_THETA_PATH_LABEL_HPP
+
10
+
11#include "SusceptanceNormLabel.hpp"
+
12
+
13namespace egoa {
+
14
+
39template< typename ElementType = Edges::Edge<Edges::ElectricalProperties>
+
40 , typename VertexSetContainer = std::unordered_set<Types::vertexId>
+
41 , typename PointerType = Types::vertexId >
+
+
42class VoltageAngleDifferenceLabel : public SusceptanceNormLabel<ElementType, VertexSetContainer, PointerType> {
+
43 public:
+
44 // Type aliasing
+
45 using TLabel = SusceptanceNormLabel<ElementType, VertexSetContainer, PointerType>;
+
46 using typename TLabel::TVertexId;
+
47 using typename TLabel::TElement;
+
48 using typename TLabel::TVertexSet;
+
49
+
50 public:
+
53#pragma mark CONSTRUCTORS_AND_DESTRUCTORS
+
54
+
+
67 VoltageAngleDifferenceLabel ()
+
68 : VoltageAngleDifferenceLabel ( Const::NONE )
+
69 {}
+
+
70
+
+
82 VoltageAngleDifferenceLabel ( Types::vertexId vertexId )
+
83 : VoltageAngleDifferenceLabel ( vertexId, 0.0, Const::REAL_INFTY )
+
84 {}
+
+
85
+
+
96 VoltageAngleDifferenceLabel ( Types::vertexId vertexId
+
97 , Types::real susceptanceNorm
+
98 , Types::real minimumCapacity )
+
99 : TLabel ( vertexId, susceptanceNorm )
+
100 , minimumCapacity_ ( minimumCapacity )
+
101 {}
+
+
102
+
+
114 VoltageAngleDifferenceLabel ( Types::vertexId vertexId
+
115 , Types::real susceptanceNorm
+
116 , Types::real minimumCapacity
+
117 , TVertexSet vertexSet )
+
118 : TLabel ( vertexId, susceptanceNorm, vertexSet )
+
119 , minimumCapacity_ ( minimumCapacity )
+
120 {}
+
+
121
+
127 VoltageAngleDifferenceLabel( VoltageAngleDifferenceLabel const & label ) = default;
+
128
+
132 ~VoltageAngleDifferenceLabel() {}
+
134
+
+
142 inline static VoltageAngleDifferenceLabel SourceLabel ( Types::vertexId vertexId )
+
143 {
+
144 return VoltageAngleDifferenceLabel ( vertexId
+
145 , 0.0
+
146 , Const::REAL_INFTY
+
147 , TVertexSet ( {{vertexId}} ) );
+
148 }
+
+
149
+
152#pragma mark DOMINATION_OPERATORS
+
153
+
+
161 inline bool operator<( VoltageAngleDifferenceLabel const & rhs ) const
+
162 {
+
163 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
164 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
165
+
166 return ( *this <= rhs ) // Weak domination w.r.t. <=
+
167 && ( *this != rhs ); // Only false if both elements are equal
+
168 }
+
+
169
+
+
177 inline bool operator<=( VoltageAngleDifferenceLabel const & rhs ) const
+
178 {
+
179 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
180 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
181
+
182 return ( TLabel::SusceptanceNorm() <= rhs.TLabel::SusceptanceNorm() )
+
183 && ( MinimumCapacity() <= rhs.MinimumCapacity() );
+
184 }
+
+
185
+
+
193 inline bool operator> ( VoltageAngleDifferenceLabel const & rhs ) const
+
194 {
+
195 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
196 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
197
+
198 return ( *this >= rhs ) // Weak domination w.r.t. >=
+
199 && ( *this != rhs ); // Only false if both elements are equal
+
200 }
+
+
201
+
+
209 inline bool operator>=( VoltageAngleDifferenceLabel const & rhs ) const
+
210 {
+
211 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
212 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
213
+
214 return ( TLabel::SusceptanceNorm() >= rhs.TLabel::SusceptanceNorm() )
+
215 && ( MinimumCapacity() >= rhs.MinimumCapacity() );
+
216 }
+
+
218
+
221#pragma mark COMPARISON_OPERATORS
+
222
+
+
230 inline bool operator==( VoltageAngleDifferenceLabel const & rhs ) const
+
231 {
+
232 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
233 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
234
+
235 return ( Auxiliary::EQ ( TLabel::SusceptanceNorm(), rhs.TLabel::SusceptanceNorm() ) )
+
236 && ( Auxiliary::EQ ( MinimumCapacity(), rhs.MinimumCapacity() ) );
+
237 }
+
+
238
+
+
246 inline bool operator!=( VoltageAngleDifferenceLabel const & rhs ) const
+
247 {
+
248 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
249 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
250
+
251 return !( *this == rhs );
+
252 }
+
+
254
+
257#pragma mark CONCATENATION_OPERATORS
+
258
+
+
270 friend inline bool operator+( VoltageAngleDifferenceLabel const & lhs
+
271 , TVertexId const & vertexId )
+
272 {
+
273 USAGE_ASSERT ( lhs.SusceptanceNorm() != Const::NONE );
+
274 USAGE_ASSERT ( lhs.MinimumCapacity() != Const::NONE );
+
275 USAGE_ASSERT ( vertexId != Const::NONE );
+
276
+
277 bool isInsert = false;
+
278 std::tie( std::ignore, isInsert ) = lhs.VertexSet().emplace( vertexId );
+
279 return isInsert;
+
280 }
+
+
281
+
+
292 friend inline std::pair<TVertexSet, bool> operator+( TVertexId const & vertexId
+
293 , VoltageAngleDifferenceLabel const & rhs )
+
294 {
+
295 USAGE_ASSERT ( rhs.SusceptanceNorm() != Const::NONE );
+
296 USAGE_ASSERT ( rhs.MinimumCapacity() != Const::NONE );
+
297 USAGE_ASSERT ( vertexId != Const::NONE );
+
298
+
299 bool isInsert = false;
+
300 TVertexSet newSet = rhs.VertexSet();
+
301
+
302 std::tie( std::ignore, isInsert ) = newSet.emplace( vertexId );
+
303
+
304 return std::make_pair ( newSet, isInsert );
+
305 }
+
+
306
+
+
317 friend inline std::pair<VoltageAngleDifferenceLabel, bool> operator+( TElement const & edge
+
318 , VoltageAngleDifferenceLabel const & rhs )
+
319 {
+
320 USAGE_ASSERT ( rhs.SusceptanceNorm() != Const::NONE );
+
321 USAGE_ASSERT ( rhs.MinimumCapacity() != Const::NONE );
+
322 USAGE_ASSERT ( edge.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0 );
+
323
+
324 bool isInsert = false;
+
325 VoltageAngleDifferenceLabel newLabel = rhs;
+
326
+
327 newLabel += edge;
+
328 TVertexId vertexId = edge.Other( rhs.Vertex() );
+
329
+
330 ESSENTIAL_ASSERT ( vertexId == newLabel.Vertex() );
+
331
+
332 std::tie( newLabel.VertexSet(), isInsert ) = vertexId + newLabel;
+
333
+
334 return std::make_pair( newLabel, isInsert );
+
335 }
+
+
336
+
+
347 friend inline std::pair<VoltageAngleDifferenceLabel, bool> operator+( VoltageAngleDifferenceLabel const & lhs
+
348 , TElement const & edge )
+
349 {
+
350 USAGE_ASSERT ( lhs.SusceptanceNorm() != Const::NONE );
+
351 USAGE_ASSERT ( lhs.MinimumCapacity() != Const::NONE );
+
352 USAGE_ASSERT ( edge.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0 );
+
353
+
354 return edge + lhs;
+
355 }
+
+
356
+
+
364 inline VoltageAngleDifferenceLabel & operator+=( TElement const & rhs )
+
365 {
+
366 USAGE_ASSERT ( TLabel::SusceptanceNorm() != Const::NONE );
+
367 USAGE_ASSERT ( MinimumCapacity() != Const::NONE );
+
368 USAGE_ASSERT ( rhs.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() != 0);
+
369
+
370 TLabel::SusceptanceNorm() += fabs( 1 / rhs.Properties().template Susceptance<Edges::CarrierDifferentiationType::DC>() );
+
371 MinimumCapacity() = std::min( MinimumCapacity(), rhs.Properties().ThermalLimit() );
+
372 TLabel::Vertex() = rhs.Other( TLabel::Vertex() );
+
373 return *this;
+
374 }
+
+
376
+
379#pragma mark GETTER_AND_SETTER
+
380
+
+
386 inline Types::real MinimumCapacity() const
+
387 {
+
388 return minimumCapacity_;
+
389 }
+
+
390
+
+
396 inline Types::real & MinimumCapacity()
+
397 {
+
398 return minimumCapacity_;
+
399 }
+
+
400
+
+
416 inline Types::real Value() const
+
417 {
+
418 return ( TLabel::SusceptanceNorm() * MinimumCapacity() );
+
419 }
+
+
421
+
422#pragma mark OUTPUT
+
+
431 friend std::ostream& operator<< ( std::ostream & os
+
432 , VoltageAngleDifferenceLabel const & rhs )
+
433 {
+
434 return os << "(" << rhs.SusceptanceNorm() << "," << rhs.MinimumCapacity() << ")";
+
435 }
+
+
436
+
437#pragma mark MEMBERS
+
438 private:
+
439 Types::real minimumCapacity_;
+
440};
+
+
441
+
442} // namespace egoa
+
443
+
444#endif // EGOA__DATA_STRUCTURES__LABELS__DOMINATING_THETA_PATH_LABEL_HPP
+
egoa::Label::Vertex
Types::vertexId Vertex() const
Getter for the value of the label.
Definition Label.hpp:191
+
egoa::SusceptanceNormLabel
Class for Susceptance norm label.
Definition SusceptanceNormLabel.hpp:44
+
egoa::SusceptanceNormLabel::TVertexSet
VertexSetContainer TVertexSet
Definition Label.hpp:40
+
egoa::SusceptanceNormLabel::SusceptanceNorm
Types::real SusceptanceNorm() const
Getter and setter for the susceptance norm.
Definition SusceptanceNormLabel.hpp:376
+
egoa::SusceptanceNormLabel::TVertexId
Types::vertexId TVertexId
Definition Label.hpp:37
+
egoa::SusceptanceNormLabel::VertexSet
TVertexSet const & VertexSet() const
Getter of the set of all visited vertices from the source.
Definition SusceptanceNormLabel.hpp:150
+ +
egoa::VoltageAngleDifferenceLabel
Class for Voltage Angle Difference label.
Definition VoltageAngleDifferenceLabel.hpp:42
+
egoa::VoltageAngleDifferenceLabel::MinimumCapacity
Types::real MinimumCapacity() const
Getter for the minimum capacity.
Definition VoltageAngleDifferenceLabel.hpp:386
+
egoa::VoltageAngleDifferenceLabel::Value
Types::real Value() const
Voltage angle difference value.
Definition VoltageAngleDifferenceLabel.hpp:416
+
egoa::VoltageAngleDifferenceLabel::MinimumCapacity
Types::real & MinimumCapacity()
Setter for the minimum capacity.
Definition VoltageAngleDifferenceLabel.hpp:396
+
egoa::VoltageAngleDifferenceLabel::operator>=
bool operator>=(VoltageAngleDifferenceLabel const &rhs) const
Weak domination using greater or equal than.
Definition VoltageAngleDifferenceLabel.hpp:209
+
egoa::VoltageAngleDifferenceLabel::operator==
bool operator==(VoltageAngleDifferenceLabel const &rhs) const
Equality check.
Definition VoltageAngleDifferenceLabel.hpp:230
+
egoa::VoltageAngleDifferenceLabel::operator>
bool operator>(VoltageAngleDifferenceLabel const &rhs) const
Strict domination using greater than.
Definition VoltageAngleDifferenceLabel.hpp:193
+
egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel
VoltageAngleDifferenceLabel(Types::vertexId vertexId)
Constructs the voltage angle difference label object.
Definition VoltageAngleDifferenceLabel.hpp:82
+
egoa::VoltageAngleDifferenceLabel::TVertexSet
VertexSetContainer TVertexSet
Definition Label.hpp:40
+
egoa::VoltageAngleDifferenceLabel::operator+
friend std::pair< TVertexSet, bool > operator+(TVertexId const &vertexId, VoltageAngleDifferenceLabel const &rhs)
Addition operators testing for cycles.
Definition VoltageAngleDifferenceLabel.hpp:292
+
egoa::VoltageAngleDifferenceLabel::operator!=
bool operator!=(VoltageAngleDifferenceLabel const &rhs) const
Inequality check.
Definition VoltageAngleDifferenceLabel.hpp:246
+ + +
egoa::VoltageAngleDifferenceLabel::SourceLabel
static VoltageAngleDifferenceLabel SourceLabel(Types::vertexId vertexId)
Generate source label.
Definition VoltageAngleDifferenceLabel.hpp:142
+ + +
egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel
VoltageAngleDifferenceLabel(VoltageAngleDifferenceLabel const &label)=default
Copy constructor.
+
egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel
VoltageAngleDifferenceLabel()
Constructs the voltage angle difference label object.
Definition VoltageAngleDifferenceLabel.hpp:67
+
egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel
VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity)
Constructs the voltage angle difference label object.
Definition VoltageAngleDifferenceLabel.hpp:96
+
egoa::VoltageAngleDifferenceLabel::operator<=
bool operator<=(VoltageAngleDifferenceLabel const &rhs) const
Weak domination using less or equal than.
Definition VoltageAngleDifferenceLabel.hpp:177
+
egoa::VoltageAngleDifferenceLabel::operator<
bool operator<(VoltageAngleDifferenceLabel const &rhs) const
Strict domination using less than.
Definition VoltageAngleDifferenceLabel.hpp:161
+
egoa::VoltageAngleDifferenceLabel::operator+
friend std::pair< VoltageAngleDifferenceLabel, bool > operator+(VoltageAngleDifferenceLabel const &lhs, TElement const &edge)
Addition operators testing for cycles.
Definition VoltageAngleDifferenceLabel.hpp:347
+
egoa::VoltageAngleDifferenceLabel::operator+
friend std::pair< VoltageAngleDifferenceLabel, bool > operator+(TElement const &edge, VoltageAngleDifferenceLabel const &rhs)
Addition operators testing for cycles.
Definition VoltageAngleDifferenceLabel.hpp:317
+
egoa::VoltageAngleDifferenceLabel::operator<<
friend std::ostream & operator<<(std::ostream &os, VoltageAngleDifferenceLabel const &rhs)
Output stream.
Definition VoltageAngleDifferenceLabel.hpp:431
+
egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel
VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity, TVertexSet vertexSet)
Constructs the voltage angle difference label object.
Definition VoltageAngleDifferenceLabel.hpp:114
+
egoa::VoltageAngleDifferenceLabel::operator+=
VoltageAngleDifferenceLabel & operator+=(TElement const &rhs)
In place addition.
Definition VoltageAngleDifferenceLabel.hpp:364
+
egoa::VoltageAngleDifferenceLabel::operator+
friend bool operator+(VoltageAngleDifferenceLabel const &lhs, TVertexId const &vertexId)
Addition operators testing for cycles.
Definition VoltageAngleDifferenceLabel.hpp:270
+
egoa
Definition Color.cpp:15
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/annotated.html b/annotated.html new file mode 100644 index 00000000..79b87daf --- /dev/null +++ b/annotated.html @@ -0,0 +1,198 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class List
+
+
+
Here are the classes, structs, unions and interfaces with brief descriptions:
+
[detail level 1234]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼Negoa
 ►NAuxiliary
 ►NEdges
 ►Ninternal
 ►NIO
 ►Nio
 ►NVertices
 CArticulationVertexDetectionClass to find articulation vertices
 CBetweennessCentralityClass for betweenness centrality
 CBFSClass for the Breadth-First Search (BFS)
 ►CBinaryHeapClass for binary heap data structure
 ►CBlockCutTreeA block-cut tree
 CBlockCutTreeTraversalTraverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited
 CBoundClass for bounds
 CBoundMismatch
 CBucketClass for bucket data structure
 CBucketElementClass representing the minimal bucket element
 CCallbackEmpty
 CColor
 CDepthFirstSearchClass for the Depth-First Search (DFS)
 CDominatingThetaPathClass for dominating theta path
 ►CDynamicGraphA graph data structure that supports adding and removing vertices and edges
 CGurobiSolver
 CIeeeCdfMatlabParser
 CKruskalAn implementation of Kruskal's algorithm for finding minimum spanning trees
 CLabelInterface for label
 CMappingBinaryHeapClass for binary heap data structure, in which elements are sorted by keys
 CMSTBase class for minimum spanning tree algorithms
 COmittingIteratorAn iterator that omits elements of a range if another range of bool indicates that the element is invalid
 CPowerGrid
 CPowerGridIOClass for power grid io
 CPrimAn implementation of Prim's algorithm for finding minimum spanning trees
 CPriorityQueue
 CPyPsaParser
 CQueue
 CStaticGraphA graph data structure that supports adding vertices and edges
 CStdQueue
 CStroke
 CSubgraphA subgraph of an existing graph
 CSusceptanceNormLabelClass for Susceptance norm label
 CTraversalInterface for graph traversal
 CUnionFindThis class describes an union find
 CVectorBasedComparatorA comparator that compares based on elements in the vector
 CVectorViewProvides a restricted view on a vector
 CVoltageAngleDifferenceLabelClass for Voltage Angle Difference label
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/bc_s.png b/bc_s.png new file mode 100644 index 00000000..224b29aa Binary files /dev/null and b/bc_s.png differ diff --git a/bc_sd.png b/bc_sd.png new file mode 100644 index 00000000..31ca888d Binary files /dev/null and b/bc_sd.png differ diff --git a/classegoa_1_1_articulation_vertex_detection-members.html b/classegoa_1_1_articulation_vertex_detection-members.html new file mode 100644 index 00000000..c4ed73ed --- /dev/null +++ b/classegoa_1_1_articulation_vertex_detection-members.html @@ -0,0 +1,143 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::ArticulationVertexDetection< GraphType, IsDirected > Member List
+
+
+ +

This is the complete list of members for egoa::ArticulationVertexDetection< GraphType, IsDirected >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ArticulationVertexDetection(TGraph const &graph, TVertexId source) (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >inline
breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
Clear()egoa::Traversal< GraphType, IsDirected >inlineprotected
DepthFirstSearch(TGraph const &graph, TVertexId source)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
entryTime_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
EntryTimeAt(TVertexId vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
exitTime_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
ExitTimeAt(TVertexId const vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
graph_egoa::Traversal< GraphType, IsDirected >private
isArticulationVertex_egoa::ArticulationVertexDetection< GraphType, IsDirected >private
IsArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inline
IsBridgeArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inline
IsParentArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inline
IsRoot(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inline
IsRootArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inline
NumberOfVertices() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
parent_egoa::Traversal< GraphType, IsDirected >private
ParentOf(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inline
ParentOf(TVertexId vertexId) const (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) overrideegoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotectedvirtual
PostprocessingVertexWith(TVertexId vertexId) overrideegoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotectedvirtual
PreprocessingVertexWith(TVertexId const vertex) overrideegoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotectedvirtual
processed_egoa::Traversal< GraphType, IsDirected >private
ProcessedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
ProcessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) overrideegoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotectedvirtual
Result(std::vector< TVertexId > parent) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
Run() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
SetTerminate() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
SetVertexProcessedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
SetVertexVisitedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
Source() constegoa::Traversal< GraphType, IsDirected >inline
Source() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
source_egoa::Traversal< GraphType, IsDirected >private
Terminate() constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
terminate_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
TGraph typedef (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >
Time() constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlineprivate
Time() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlineprivate
time_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
TimeOfOldestReachableAncestor(TVertexId vertex) (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotected
timeOfOldestReachableAncestor_egoa::ArticulationVertexDetection< GraphType, IsDirected >private
Traversal(TGraph const &graph, TVertexId source)egoa::Traversal< GraphType, IsDirected >inline
TreeOutDegree(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotected
TreeOutDegree(TVertexId const vertex) (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >inlineprotected
treeOutDegree_egoa::ArticulationVertexDetection< GraphType, IsDirected >private
TTime typedef (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >private
TVertexId typedef (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >
TypifyEdge(TVertexId source, TVertexId target)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
VertexExists(TVertexId vertexId) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
visited_egoa::Traversal< GraphType, IsDirected >private
VisitedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
~ArticulationVertexDetection() (defined in egoa::ArticulationVertexDetection< GraphType, IsDirected >)egoa::ArticulationVertexDetection< GraphType, IsDirected >inlinevirtual
~DepthFirstSearch() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
~Traversal() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_articulation_vertex_detection.html b/classegoa_1_1_articulation_vertex_detection.html new file mode 100644 index 00000000..8a4f1db7 --- /dev/null +++ b/classegoa_1_1_articulation_vertex_detection.html @@ -0,0 +1,1001 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::ArticulationVertexDetection< GraphType, IsDirected > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Member Functions | +Private Types | +Private Attributes | +List of all members
+
egoa::ArticulationVertexDetection< GraphType, IsDirected > Class Template Reference
+
+
+ +

Class to find articulation vertices. + More...

+ +

#include <ArticulationVertexDetection.hpp>

+
+Inheritance diagram for egoa::ArticulationVertexDetection< GraphType, IsDirected >:
+
+
+ + +egoa::DepthFirstSearch< GraphType, IsDirected, Recursive > +egoa::Traversal< GraphType, IsDirected > + +
+ + + + + + + + + + + + + + + + + + +

+Public Types

using TGraph = GraphType
 
using TVertexId = typename TGraph::TVertexId
 
- Public Types inherited from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >
 
 
 
- Public Types inherited from egoa::Traversal< GraphType, IsDirected >
using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 ArticulationVertexDetection (TGraph const &graph, TVertexId source)
 
bool IsRootArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex is a root articulation vertex .
 
bool IsParentArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex is a parent articulation vertex .
 
std::pair< bool, bool > IsBridgeArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex and thus, its parent is a bridge articulation vertex .
 
bool IsArticulationVertexAt (TVertexId const vertex) const
 Whether the vertex is an articulation vertex.
 
bool IsRoot (TVertexId const vertex) const
 Determines if vertex is a root.
 
- Public Member Functions inherited from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >
 
 Determine DFS edge type.
 
 Terminate the DFS.
 
 
 { function_description }
 
 Returns the exit time of a vertex.
 
 Constructs a new DFS instance.
 
- Public Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
virtual void Result (std::vector< TVertexId > parent)
 
 Traversal (TGraph const &graph, TVertexId source)
 Constructs a new instance.
 
TVertexId Source () const
 Getter and setter for the source vertex.
 
TVertexId & Source ()
 
TVertexId & ParentOf (TVertexId vertexId)
 Getter and setter for the parent relation.
 
TVertexId ParentOf (TVertexId vertexId) const
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

TTime & TimeOfOldestReachableAncestor (TVertexId vertex)
 
virtual void PreprocessingVertexWith (TVertexId const vertex) override
 Preprocessing vertex with vertexId.
 
virtual void ProcessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId) override
 Update the oldest reachable ancestor.
 
virtual void PostprocessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId) override
 Post processing the edge with edgeId.
 
virtual void PostprocessingVertexWith (TVertexId vertexId) override
 Decide which vertices are articulation vertices.
 
Types::count TreeOutDegree (TVertexId const vertex) const
 Accessors for the tree out degree.
 
Types::count & TreeOutDegree (TVertexId const vertex)
 
- Protected Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
void Clear ()
 Clear and resize all vectors.
 
bool VertexExists (TVertexId vertexId)
 
bool NumberOfVertices ()
 
void SetVertexVisitedAt (TVertexId vertexId)
 Sets the vertex at vertexId to visited.
 
bool VisitedVertexAt (TVertexId vertexId) const
 Getter and setter to access the visited field.
 
void SetVertexProcessedAt (TVertexId vertexId)
 Sets the vertex at vertexId to processed.
 
bool ProcessedVertexAt (TVertexId vertexId) const
 Getter and setter to access the process field.
 
template<typename FUNCTION >
void breakable_for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges that is breakable.
 
template<typename FUNCTION >
void for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges.
 
+ + + +

+Private Types

using TTime = typename DepthFirstSearch< GraphType, IsDirected >::TTime
 
+ + + + + + + +

+Private Attributes

std::vector< TTime > timeOfOldestReachableAncestor_
 
std::vector< Types::count > treeOutDegree_
 
std::vector< bool > isArticulationVertex_
 
+

Detailed Description

+
template<typename GraphType, bool IsDirected = false>
+class egoa::ArticulationVertexDetection< GraphType, IsDirected >

Class to find articulation vertices.

+

Key thing of the DFS is that it distinguish the edges into tree edges and back edges.

+
Template Parameters
+ + + +
GraphTypeThe graph should at least provide the same interface as the StaticGraph().
IsDirectedIf true the graph is treated as a directed graph, if false the graph is treated as an undirected graph.
+
+
+ +

Definition at line 26 of file ArticulationVertexDetection.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + +
using egoa::ArticulationVertexDetection< GraphType, IsDirected >::TGraph = GraphType
+
+ +

Definition at line 29 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ TTime

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
using egoa::ArticulationVertexDetection< GraphType, IsDirected >::TTime = typename DepthFirstSearch<GraphType, IsDirected>::TTime
+ 		+private
+
+ +

Definition at line 27 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + +
using egoa::ArticulationVertexDetection< GraphType, IsDirected >::TVertexId = typename TGraph::TVertexId
+
+ +

Definition at line 30 of file ArticulationVertexDetection.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ArticulationVertexDetection()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::ArticulationVertexDetection< GraphType, IsDirected >::ArticulationVertexDetection (TGraph const & graph,
TVertexId source 
)
+ 		+inline
+
+ +

Definition at line 33 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ ~ArticulationVertexDetection()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
virtual egoa::ArticulationVertexDetection< GraphType, IsDirected >::~ArticulationVertexDetection ()
+ 		+inlinevirtual
+
+ +

Definition at line 40 of file ArticulationVertexDetection.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ IsArticulationVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsArticulationVertexAt (TVertexId const vertex) const
+ 		+inline
+
+ +

Whether the vertex is an articulation vertex.

+
Parameters
+ + +
[in]vertexThe identifier of the vertex.
+
+
+
Returns
true if it is an articulation vertex, false otherwise.
+ +

Definition at line 218 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::isArticulationVertex_.

+ +
+
+ +

◆ IsBridgeArticulationVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
std::pair< bool, bool > egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsBridgeArticulationVertexAt (TVertexId const vertex) const
+ 		+inline
+
+ +

Determines if vertex and thus, its parent is a bridge articulation vertex .

+

If the oldest reachable vertex from vertex is the vertex itself, the edge (ParentOf(vertex), vertex) is a bridge unless vertex is a leaf. If it is a bridge both vertices are articulation vertices.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
(True, True) if the vertex's parent and vertex are bridge articulation vertex, (True, False) if the parent is articulation vertex and vertex is a leaf, False otherwise.
+ +

Definition at line 199 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree().

+ +
+
+ +

◆ IsParentArticulationVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsParentArticulationVertexAt (TVertexId const vertex) const
+ 		+inline
+
+ +

Determines if vertex is a parent articulation vertex .

+

If the oldest reachable vertex of vertex is the parent and the parent is not a root, i.e., the parent of vertex is an articulation vertex.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
True if vertex is a parent articulation vertex, False otherwise.
+ +

Definition at line 174 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRoot(), and egoa::Traversal< GraphType, IsDirected >::ParentOf().

+ +
+
+ +

◆ IsRoot()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRoot (TVertexId const vertex) const
+ 		+inline
+
+ +

Determines if vertex is a root.

+

Note that infty represents the non-existence of a parent.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
True if vertex is a root, False otherwise.
+ +

Definition at line 231 of file ArticulationVertexDetection.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::ParentOf().

+ +
+
+ +

◆ IsRootArticulationVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRootArticulationVertexAt (TVertexId const vertex) const
+ 		+inline
+
+ +

Determines if vertex is a root articulation vertex .

+

If the root has two or more vertices it is—by the definition of DFS—an articulation vertex. Note that for undirected graphs there can be know crossing edge connecting two subtrees of G.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
True if vertex is a root articulation vertex, False otherwise.
+ +

Definition at line 152 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRoot(), and egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree().

+ +
+
+ +

◆ PostprocessingEdgeWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void egoa::ArticulationVertexDetection< GraphType, IsDirected >::PostprocessingEdgeWith (TVertexId source,
TVertexId target,
Types::edgeId edgeId 
)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Post processing the edge with edgeId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for the vertexId, e.g., a lambda function.
+
+
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for the edge identifiers edgeId.
+
+
+ +

Reimplemented from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >.

+ +

Definition at line 100 of file ArticulationVertexDetection.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::EntryTimeAt(), egoa::ArticulationVertexDetection< GraphType, IsDirected >::isArticulationVertex_, egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRoot(), and egoa::Traversal< GraphType, IsDirected >::ParentOf().

+ +
+
+ +

◆ PostprocessingVertexWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
virtual void egoa::ArticulationVertexDetection< GraphType, IsDirected >::PostprocessingVertexWith (TVertexId vertexId)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Decide which vertices are articulation vertices.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Reimplemented from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >.

+ +

Definition at line 131 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::isArticulationVertex_, egoa::ArticulationVertexDetection< GraphType, IsDirected >::IsRoot(), and egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree().

+ +
+
+ +

◆ PreprocessingVertexWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
virtual void egoa::ArticulationVertexDetection< GraphType, IsDirected >::PreprocessingVertexWith (TVertexId const vertex)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Preprocessing vertex with vertexId.

+

Sets the time of the oldest reachable vertex to the current entry time.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+ +

Reimplemented from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >.

+ +

Definition at line 69 of file ArticulationVertexDetection.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::EntryTimeAt().

+ +
+
+ +

◆ ProcessingEdgeWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void egoa::ArticulationVertexDetection< GraphType, IsDirected >::ProcessingEdgeWith (TVertexId source,
TVertexId target,
Types::edgeId edgeId 
)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Update the oldest reachable ancestor.

+

The oldest reachable ancestor is updated whenever a backward edge is detected that goes to a older vertex than the previous detected one. Note that the age can be easily determined by the time counter.

+
Parameters
+ + + +
[in]sourceThe source identifier.
[in]targetThe target identifier.
+
+
+ +

Reimplemented from egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >.

+ +

Definition at line 84 of file ArticulationVertexDetection.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::ParentOf(), egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree(), and egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TypifyEdge().

+ +
+
+ +

◆ TimeOfOldestReachableAncestor()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
TTime & egoa::ArticulationVertexDetection< GraphType, IsDirected >::TimeOfOldestReachableAncestor (TVertexId vertex)
+ 		+inlineprotected
+
+ +

Definition at line 56 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ TreeOutDegree() [1/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
Types::count & egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree (TVertexId const vertex)
+ 		+inlineprotected
+
+ +

Definition at line 53 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ TreeOutDegree() [2/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
Types::count egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree (TVertexId const vertex) const
+ 		+inlineprotected
+
+ +

Accessors for the tree out degree.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
+
Todo:
description
+ +

Definition at line 52 of file ArticulationVertexDetection.hpp.

+ +

References egoa::ArticulationVertexDetection< GraphType, IsDirected >::treeOutDegree_.

+ +
+
+

Member Data Documentation

+ +

◆ isArticulationVertex_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<bool> egoa::ArticulationVertexDetection< GraphType, IsDirected >::isArticulationVertex_
+ 		+private
+
+

Whether the vertex is an articulation vertex

+ +

Definition at line 241 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ timeOfOldestReachableAncestor_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<TTime> egoa::ArticulationVertexDetection< GraphType, IsDirected >::timeOfOldestReachableAncestor_
+ 		+private
+
+

Oldest reachable ancestor representing the vertex closest to the root

+ +

Definition at line 239 of file ArticulationVertexDetection.hpp.

+ +
+
+ +

◆ treeOutDegree_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<Types::count> egoa::ArticulationVertexDetection< GraphType, IsDirected >::treeOutDegree_
+ 		+private
+
+

Number of outgoing DFS tree edges per vertex

+ +

Definition at line 240 of file ArticulationVertexDetection.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_articulation_vertex_detection.png b/classegoa_1_1_articulation_vertex_detection.png new file mode 100644 index 00000000..b94067d4 Binary files /dev/null and b/classegoa_1_1_articulation_vertex_detection.png differ diff --git a/classegoa_1_1_auxiliary_1_1_timer-members.html b/classegoa_1_1_auxiliary_1_1_timer-members.html new file mode 100644 index 00000000..dcc48153 --- /dev/null +++ b/classegoa_1_1_auxiliary_1_1_timer-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Auxiliary::Timer Member List
+
+
+ +

This is the complete list of members for egoa::Auxiliary::Timer, including all inherited members.

+ + + + +
ElapsedMilliseconds() (defined in egoa::Auxiliary::Timer)egoa::Auxiliary::Timerinline
Restart() (defined in egoa::Auxiliary::Timer)egoa::Auxiliary::Timerinline
Timer() (defined in egoa::Auxiliary::Timer)egoa::Auxiliary::Timerinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_auxiliary_1_1_timer.html b/classegoa_1_1_auxiliary_1_1_timer.html new file mode 100644 index 00000000..e297e22c --- /dev/null +++ b/classegoa_1_1_auxiliary_1_1_timer.html @@ -0,0 +1,201 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Auxiliary::Timer Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
egoa::Auxiliary::Timer Class Reference
+
+
+ +

#include <Timer.hpp>

+ + + + + + +

+Public Member Functions

void Restart ()
 
Types::largeReal ElapsedMilliseconds ()
 
+

Detailed Description

+

The timer class provides an interface to measure the performance of the code. If not other set/stated the interface provides the most robust and accurate timer for the underlying operation system.

+
#include <chrono> // just for sleep
+
#include <thread> // just for sleep
+
+
int main(int argc, char *argv[]) {
+
egoa::Auxiliary::Timer timer = egoa::Auxiliary::Timer();
+
+
// Do something
+
...
+
std::this_thread::sleep_for(std::chrono::milliseconds(9999)); // sleep 9999 ms
+
+
std::cout << "Timer: " << timer.ElapsedMilliseconds() << std::endl;
+
}
+ +
+

Definition at line 57 of file Timer.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Timer()

+ +
+
+ + + + + +
+ + + + + + + +
egoa::Auxiliary::Timer::Timer ()
+ 		+inline
+
+ +

Definition at line 59 of file Timer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ ElapsedMilliseconds()

+ +
+
+ + + + + +
+ + + + + + + +
Types::largeReal egoa::Auxiliary::Timer::ElapsedMilliseconds ()
+ 		+inline
+
+ +

Definition at line 63 of file Timer.hpp.

+ +
+
+ +

◆ Restart()

+ +
+
+ + + + + +
+ + + + + + + +
void egoa::Auxiliary::Timer::Restart ()
+ 		+inline
+
+ +

Definition at line 61 of file Timer.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_b_f_s-members.html b/classegoa_1_1_b_f_s-members.html new file mode 100644 index 00000000..b0d4efa1 --- /dev/null +++ b/classegoa_1_1_b_f_s-members.html @@ -0,0 +1,121 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BFS< GraphType, QueueType, IsDirected > Member List
+
+
+ +

This is the complete list of members for egoa::BFS< GraphType, QueueType, IsDirected >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BFS(TGraph const &graph, TVertex source) (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >inline
breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprivate
Clear()egoa::Traversal< GraphType, IsDirected >inlineprivate
DequeueVertex()egoa::BFS< GraphType, QueueType, IsDirected >inlineprivate
EnqueueVertexWith(TVertex vertexId)egoa::BFS< GraphType, QueueType, IsDirected >inlineprivate
for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprivate
graph_egoa::Traversal< GraphType, IsDirected >private
NumberOfVertices() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivate
parent_egoa::Traversal< GraphType, IsDirected >private
ParentOf(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
ParentOf(TVertexId vertexId) const (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivate
PostprocessingVertexWith(TVertex vertexId) override (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >inlineprivatevirtual
PreprocessingVertexWith(TVertex vertexId) override (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >inlineprivatevirtual
processed_egoa::Traversal< GraphType, IsDirected >private
ProcessedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprivate
ProcessingEdgeWith(TVertex sourceId, TVertex targetId) override (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >inlineprivatevirtual
queue_egoa::BFS< GraphType, QueueType, IsDirected >private
Result(std::vector< TVertexId > parent) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivatevirtual
Run()egoa::BFS< GraphType, QueueType, IsDirected >inlinevirtual
SetVertexProcessedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
SetVertexVisitedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
Source() constegoa::Traversal< GraphType, IsDirected >inlineprivate
Source() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivate
source_egoa::Traversal< GraphType, IsDirected >private
TGraph typedef (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >private
TQueue typedef (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >
Traversal(TGraph const &graph, TVertexId source)egoa::Traversal< GraphType, IsDirected >inlineprivate
TVertexId typedef (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >private
VertexExists(TVertexId vertexId) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivate
visited_egoa::Traversal< GraphType, IsDirected >private
VisitedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprivate
~BFS() (defined in egoa::BFS< GraphType, QueueType, IsDirected >)egoa::BFS< GraphType, QueueType, IsDirected >inlinevirtual
~Traversal() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprivatevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_b_f_s.html b/classegoa_1_1_b_f_s.html new file mode 100644 index 00000000..6d704acd --- /dev/null +++ b/classegoa_1_1_b_f_s.html @@ -0,0 +1,536 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BFS< GraphType, QueueType, IsDirected > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Member Functions | +Private Attributes | +List of all members
+
egoa::BFS< GraphType, QueueType, IsDirected > Class Template Referencefinal
+
+
+ +

Class for the Breadth-First Search (BFS). + More...

+ +

#include <BreadthFirstSearch.hpp>

+
+Inheritance diagram for egoa::BFS< GraphType, QueueType, IsDirected >:
+
+
+ + +egoa::Traversal< GraphType, IsDirected > + +
+ + + + +

+Public Types

using TQueue = QueueType
 
+ + + + + + +

+Public Member Functions

 BFS (TGraph const &graph, TVertex source)
 
virtual void Run ()
 Run Breadth-First search (BFS).
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

void EnqueueVertexWith (TVertex vertexId)
 Add a vertex to the queue.
 
TVertex DequeueVertex ()
 Get the next unprocessed vertex.
 
virtual void PreprocessingVertexWith (TVertex vertexId) override
 
virtual void PostprocessingVertexWith (TVertex vertexId) override
 
virtual void ProcessingEdgeWith (TVertex sourceId, TVertex targetId) override
 
- Private Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
virtual void Result (std::vector< TVertexId > parent)
 
 Traversal (TGraph const &graph, TVertexId source)
 Constructs a new instance.
 
TVertexId Source () const
 Getter and setter for the source vertex.
 
TVertexId & Source ()
 
TVertexId & ParentOf (TVertexId vertexId)
 Getter and setter for the parent relation.
 
TVertexId ParentOf (TVertexId vertexId) const
 
void Clear ()
 Clear and resize all vectors.
 
bool VertexExists (TVertexId vertexId)
 
bool NumberOfVertices ()
 
void SetVertexVisitedAt (TVertexId vertexId)
 Sets the vertex at vertexId to visited.
 
bool VisitedVertexAt (TVertexId vertexId) const
 Getter and setter to access the visited field.
 
void SetVertexProcessedAt (TVertexId vertexId)
 Sets the vertex at vertexId to processed.
 
bool ProcessedVertexAt (TVertexId vertexId) const
 Getter and setter to access the process field.
 
template<typename FUNCTION >
void breakable_for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges that is breakable.
 
template<typename FUNCTION >
void for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges.
 
+ + + +

+Private Attributes

TQueue queue_
 
+ + + + + + +

+Additional Inherited Members

- Private Types inherited from egoa::Traversal< GraphType, IsDirected >
using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+

Detailed Description

+
template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+class egoa::BFS< GraphType, QueueType, IsDirected >

Class for the Breadth-First Search (BFS).

+

BFS uses a queue that processes the vertices in First-in, First-out (FiFo) order. Thus, the traversal of a graph is level-wise. Not that if the graph G=(V,E) is undirected chords (non-tree edges) can only be between vertices on the same level or one level below (as the vertex would have been visited in the next step). For directed graphs, an chord (u,v) in E can only exists if v's level is higher (closer to the source vertex s) than u's.

+

The run time is in O(n + m).

+
Precondition
The queue uses the Type Types::vertexId. Note that the queue does not need to implement the element-wise loops.
+
Template Parameters
+ + + + +
GraphTypeThe graph should at least provide the same interface as the StaticGraph().
QueueTypeThe queue should provide the same interface as Queue().
IsDirectedIf true the graph is treated as a directed graph, if false the graph is treated as an undirected graph.
+
+
+ +

Definition at line 39 of file BreadthFirstSearch.hpp.

+

Member Typedef Documentation

+ +

◆ TQueue

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + +
using egoa::BFS< GraphType, QueueType, IsDirected >::TQueue = QueueType
+
+ +

Definition at line 42 of file BreadthFirstSearch.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BFS()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BFS< GraphType, QueueType, IsDirected >::BFS (TGraph const & graph,
TVertex source 
)
+ 		+inline
+
+ +

Definition at line 46 of file BreadthFirstSearch.hpp.

+ +
+
+ +

◆ ~BFS()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + +
virtual egoa::BFS< GraphType, QueueType, IsDirected >::~BFS ()
+ 		+inlinevirtual
+
+ +

Definition at line 51 of file BreadthFirstSearch.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ DequeueVertex()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + +
TVertex egoa::BFS< GraphType, QueueType, IsDirected >::DequeueVertex ()
+ 		+inlineprivate
+
+ +

Get the next unprocessed vertex.

+

A vertex can only be dequeued if it is was marked as visited.

+
Returns
The next unprocessed but visited vertex.
+ +

Definition at line 110 of file BreadthFirstSearch.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::BFS< GraphType, QueueType, IsDirected >::queue_.

+ +
+
+ +

◆ EnqueueVertexWith()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
void egoa::BFS< GraphType, QueueType, IsDirected >::EnqueueVertexWith (TVertex vertexId)
+ 		+inlineprivate
+
+ +

Add a vertex to the queue.

+
Precondition
Only visited vertices that are unprocessed should be add to the queue.
+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 98 of file BreadthFirstSearch.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::BFS< GraphType, QueueType, IsDirected >::queue_.

+ +
+
+ +

◆ PostprocessingVertexWith()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
virtual void egoa::BFS< GraphType, QueueType, IsDirected >::PostprocessingVertexWith (TVertex vertexId)
+ 		+inlineoverrideprivatevirtual
+
+ +

Definition at line 120 of file BreadthFirstSearch.hpp.

+ +
+
+ +

◆ PreprocessingVertexWith()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
virtual void egoa::BFS< GraphType, QueueType, IsDirected >::PreprocessingVertexWith (TVertex vertexId)
+ 		+inlineoverrideprivatevirtual
+
+ +

Definition at line 119 of file BreadthFirstSearch.hpp.

+ +
+
+ +

◆ ProcessingEdgeWith()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void egoa::BFS< GraphType, QueueType, IsDirected >::ProcessingEdgeWith (TVertex sourceId,
TVertex targetId 
)
+ 		+inlineoverrideprivatevirtual
+
+ +

Definition at line 121 of file BreadthFirstSearch.hpp.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + + + + +
virtual void egoa::BFS< GraphType, QueueType, IsDirected >::Run ()
+ 		+inlinevirtual
+
+ +

Run Breadth-First search (BFS).

+ +

Definition at line 57 of file BreadthFirstSearch.hpp.

+ +

References egoa::BFS< GraphType, QueueType, IsDirected >::DequeueVertex(), egoa::BFS< GraphType, QueueType, IsDirected >::EnqueueVertexWith(), egoa::Traversal< GraphType, IsDirected >::for_all_edges_at(), egoa::Traversal< GraphType, IsDirected >::graph_, egoa::Traversal< GraphType, IsDirected >::ParentOf(), egoa::Traversal< GraphType, IsDirected >::ProcessedVertexAt(), egoa::BFS< GraphType, QueueType, IsDirected >::queue_, egoa::Traversal< GraphType, IsDirected >::SetVertexProcessedAt(), egoa::Traversal< GraphType, IsDirected >::SetVertexVisitedAt(), egoa::Traversal< GraphType, IsDirected >::source_, and egoa::Traversal< GraphType, IsDirected >::VisitedVertexAt().

+ +
+
+

Member Data Documentation

+ +

◆ queue_

+ +
+
+
+template<typename GraphType = StaticGraph<Vertices::ElectricalProperties<>,Edges::ElectricalProperties>, typename QueueType = StdQueue<GraphType::TVertexId>, bool IsDirected = false>
+ + + + + +
+ + + + +
TQueue egoa::BFS< GraphType, QueueType, IsDirected >::queue_
+ 		+private
+
+

The FIFO queue

+ +

Definition at line 126 of file BreadthFirstSearch.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_b_f_s.png b/classegoa_1_1_b_f_s.png new file mode 100644 index 00000000..8fdfd7da Binary files /dev/null and b/classegoa_1_1_b_f_s.png differ diff --git a/classegoa_1_1_betweenness_centrality-members.html b/classegoa_1_1_betweenness_centrality-members.html new file mode 100644 index 00000000..6c3c364a --- /dev/null +++ b/classegoa_1_1_betweenness_centrality-members.html @@ -0,0 +1,118 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType > Member List
+
+
+ +

This is the complete list of members for egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
algo_egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
Algorithm()egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
Algorithm() constegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
BetweennessCentrality(TGraph const &graph)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
Clear()egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
Clear(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inlineprotected
Collection() constegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
Collection()egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
collection_egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
countersSize_ (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
graph_egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
JoinThreadBasedResults(TNumberOfPaths const &numberOfPaths, TRelativeNumberOfPaths const &relativeNumberOfPaths, Types::real const &m_BNormalization)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inlineprotected
Run()egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
TAlgoHandling typedef (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >protected
TAlgorithm typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TEdge typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TEdgeId typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TGraph typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TMeasurementCollection typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TMeasurementRow typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TNumberOfPaths typedef (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >protected
TotalNumberOfPaths() constegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
TotalNumberOfPaths(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inlineprotected
totalNumberOfPaths_ (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
TotalRelativeNumberOfPaths() constegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
totalRelativeNumberOfPaths_ (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >private
TRelativeNumberOfPaths typedef (defined in egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >)egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >protected
TVertex typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
TVertexId typedefegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >
~BetweennessCentrality()egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_betweenness_centrality.html b/classegoa_1_1_betweenness_centrality.html new file mode 100644 index 00000000..790060a9 --- /dev/null +++ b/classegoa_1_1_betweenness_centrality.html @@ -0,0 +1,1115 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Protected Types | +Private Attributes | +List of all members
+
egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType > Class Template Reference
+
+
+ +

Class for betweenness centrality. + More...

+ +

#include <BetweennessCentrality.hpp>

+ + + + + + + + + + + + + + + + + + +

+Public Types

using TGraph = GraphType
 
using TVertex = typename TGraph::TVertex
 
using TVertexId = typename TGraph::TVertexId
 
using TEdge = typename TGraph::TEdge
 
using TEdgeId = typename TGraph::TEdgeId
 
using TAlgorithm = PathFindingAlgorithm
 
using TMeasurementCollection = MeasurementCollection
 
using TMeasurementRow = typename TMeasurementCollection::TRow
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 BetweennessCentrality (TGraph const &graph)
 Constructs the betweenness centrality object.
 
 ~BetweennessCentrality ()
 Destroys the object.
 
Execute the Betweenness Centrality Algorithm
void Run ()
 Run the betweenness centrality.
 
Getter and Setter
std::vector< Types::real > const & TotalRelativeNumberOfPaths () const
 Getter for the total relative number of paths per edge.
 
std::vector< Types::count > const & TotalNumberOfPaths () const
 Getter for the total number of paths per edge.
 
TAlgoHandling & Algorithm ()
 Setter for the algorithm.
 
TAlgoHandling const & Algorithm () const
 Getter for the algorithm.
 
TMeasurementCollection const & Collection () const
 Getter for the measurement collection.
 
TMeasurementCollection & Collection ()
 Setter for the measurement collection.
 
Modifier
void Clear ()
 Clears the measurement collection.
 
+ + + + + + + +

+Protected Types

using TAlgoHandling = TAlgorithm
 
using TNumberOfPaths = std::vector< Types::count >
 
using TRelativeNumberOfPaths = std::vector< Types::real >
 
+ + + + + + + + + + + + +

+Protected Member Functions

Total Number of Paths
void JoinThreadBasedResults (TNumberOfPaths const &numberOfPaths, TRelativeNumberOfPaths const &relativeNumberOfPaths, Types::real const &m_BNormalization)
 Join the thread based result from OpenMP.
 
void TotalNumberOfPaths (TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)
 Total number of paths.
 
Protected Modifiers
void Clear (TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)
 Clear all.
 
+ + + + + + + + + + + + + +

+Private Attributes

Types::count countersSize_
 
TGraph const & graph_
 
TAlgoHandling algo_
 
TMeasurementCollection collection_
 
std::vector< Types::real > totalRelativeNumberOfPaths_
 
std::vector< Types::count > totalNumberOfPaths_
 
+

Detailed Description

+
template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+class egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >

Class for betweenness centrality.

+

This algorithm measures the centrality of a graph based on a path finding algorithm, e.g., the shortest path, or dominating theta path. The $\dtp$ betweenness centrality $c_{\sbc}\colon\edges\to\posreals$ is defined by

+\[ + c_{\sbc} := \frac{1}{m_B}\sum_{\source\in\vertices}\sum_{\sink\in\vertices\setminus\{\source\}} \frac{\sigma_{\dtp}(\source,\sink,\edge)}{\sigma_{\dtp}(\source,\sink)}, + \] +

+

where $\sigma_{\dtp}(\source,\sink,\edge)$ is the number of $\dtp{s}$ between $\source$ and $\sink$ that use the edge $\edge$, $\sigma_{\dtp}(\source,\sink)$ is the total number of $\dtp{\text{s}}$ from the source $\source$ to a sink $\sink$, and $m_B = |\vertices|\cdot(|\vertices|-1)$ is a normalizing constant.

+
Precondition
The template parameter used for GraphType should have an interface similar to StaticGraph or DynamicGraph. However, the minimum requirements on the graph type are
    +
  • for_all_vertex_identifiers<IsParallel>, and
    • +
  • see the minimum requirement of the PathFindingAlgorithm, e.g., DominatingThetaPath.
    • +
+
+
Template Parameters
+ + + + + +
GraphTypeThe graph should at least provide the same interface as the StaticGraph.
PathFindingAlgorithmThe path finding algorithm that is used within the betweenness centrality algorithm such as DTP.
MeasurementCollectionThe collection used for the measurements such as IO::DtpRuntimeCollection.
CentralityCounterTypeThe centrality counter decides whether to count edges or vertices.
+
+
+
See also
StaticGraph
+
+DominatingThetaPath
+
+IO::DtpRuntimeCollection
+
+CentralityCounter < Distinguish between counting edges or vertices.
+ +

Definition at line 67 of file BetweennessCentrality.hpp.

+

Member Typedef Documentation

+ +

◆ TAlgoHandling

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TAlgoHandling = TAlgorithm
+ 		+protected
+
+ +

Definition at line 87 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TAlgorithm

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TAlgorithm = PathFindingAlgorithm
+
+

The path finding algorithm in use for the Betweenness Centrality such as DTP.

+ +

Definition at line 77 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TEdge = typename TGraph::TEdge
+
+

The edge type.

+ +

Definition at line 74 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TEdgeId = typename TGraph::TEdgeId
+
+

The edge identifier type.

+ +

Definition at line 75 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TGraph = GraphType
+
+

The graph type.
+

+ +

Definition at line 71 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TMeasurementCollection

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TMeasurementCollection = MeasurementCollection
+
+

The collection used for the measurements such as IO::DtpRuntimeCollection.

+ +

Definition at line 78 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TMeasurementRow

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TMeasurementRow = typename TMeasurementCollection::TRow
+
+

The row type of the collection used for the measurements.

+ +

Definition at line 79 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TNumberOfPaths

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TNumberOfPaths = std::vector<Types::count>
+ 		+protected
+
+ +

Definition at line 88 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TRelativeNumberOfPaths

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TRelativeNumberOfPaths = std::vector<Types::real>
+ 		+protected
+
+ +

Definition at line 89 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TVertex = typename TGraph::TVertex
+
+

The vertex type.

+ +

Definition at line 72 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + +
using egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TVertexId = typename TGraph::TVertexId
+
+

The vertex identifier type.

+ +

Definition at line 73 of file BetweennessCentrality.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BetweennessCentrality()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + + +
egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::BetweennessCentrality (TGraph const & graph)
+ 		+inline
+
+ +

Constructs the betweenness centrality object.

+
Parameters
+ + +
graphThe const graph.
+
+
+ +

Definition at line 101 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ ~BetweennessCentrality()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::~BetweennessCentrality ()
+ 		+inline
+
+ +

Destroys the object.

+ +

Definition at line 114 of file BetweennessCentrality.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Algorithm() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
TAlgoHandling & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Algorithm ()
+ 		+inline
+
+ +

Setter for the algorithm.

+
Returns
The algorithm.
+ +

Definition at line 211 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::algo_.

+ +
+
+ +

◆ Algorithm() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
TAlgoHandling const & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Algorithm () const
+ 		+inline
+
+ +

Getter for the algorithm.

+
Returns
The algorithm.
+ +

Definition at line 221 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::algo_.

+ +
+
+ +

◆ Clear() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
void egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Clear ()
+ 		+inline
+
+ +

Clears the measurement collection.

+ +

Definition at line 254 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::collection_, and egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::graph_.

+ +
+
+ +

◆ Clear() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Clear (TNumberOfPaths & numberOfPaths,
TRelativeNumberOfPaths & relativeNumberOfPaths 
)
+ 		+inlineprotected
+
+ +

Clear all.

+
Parameters
+ + + +
numberOfPathsThe number of paths.
relativeNumberOfPathsThe relative number of paths.
+
+
+ +

Definition at line 375 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Clear().

+ +
+
+ +

◆ Collection() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
TMeasurementCollection & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Collection ()
+ 		+inline
+
+ +

Setter for the measurement collection.

+
Returns
A vector of measurements.
+ +

Definition at line 241 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::collection_.

+ +
+
+ +

◆ Collection() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
TMeasurementCollection const & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Collection () const
+ 		+inline
+
+ +

Getter for the measurement collection.

+
Returns
A vector of measurements.
+ +

Definition at line 231 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::collection_.

+ +
+
+ +

◆ JoinThreadBasedResults()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::JoinThreadBasedResults (TNumberOfPaths const & numberOfPaths,
TRelativeNumberOfPaths const & relativeNumberOfPaths,
Types::real const & m_BNormalization 
)
+ 		+inlineprotected
+
+ +

Join the thread based result from OpenMP.

+

This method abstracts the usage of OpenMP.

+
Parameters
+ + + + +
numberOfPathsThe number of paths.
relativeNumberOfPathsThe relative number of paths.
m_BNormalizationThe normalization factor, e.g., for the $\SBC$ $\sbc$ the normalization factor is defined by $m_B = |V|\cdot (|V|-1)$.
+
+
+ +

Definition at line 286 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
void egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Run ()
+ 		+inline
+
+ +

Run the betweenness centrality.

+

If OpenMP is available this method will run in parallel. Note that standard container are thread safe while writing writing on their own dedicated object. However, this is not true when the object is a boolean. For more information see https://en.cppreference.com/w/cpp/container .

+ +

Definition at line 132 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Algorithm(), egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Clear(), egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Collection(), egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::graph_, egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::JoinThreadBasedResults(), and egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TotalNumberOfPaths().

+ +
+
+ +

◆ TotalNumberOfPaths() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
std::vector< Types::count > const & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TotalNumberOfPaths () const
+ 		+inline
+
+ +

Getter for the total number of paths per edge.

+
Returns
The total number of paths per edge.
+ +

Definition at line 200 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ TotalNumberOfPaths() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TotalNumberOfPaths (TNumberOfPaths & numberOfPaths,
TRelativeNumberOfPaths & relativeNumberOfPaths 
)
+ 		+inlineprotected
+
+ +

Total number of paths.

+

This method abstracts the usage of the CentralityCounter and OpenMP.

+
Parameters
+ + + +
numberOfPathsThe number of paths.
relativeNumberOfPathsThe relative number of paths.
+
+
+ +

Definition at line 342 of file BetweennessCentrality.hpp.

+ +

References egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::Algorithm().

+ +
+
+ +

◆ TotalRelativeNumberOfPaths()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + + + + +
std::vector< Types::real > const & egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::TotalRelativeNumberOfPaths () const
+ 		+inline
+
+ +

Getter for the total relative number of paths per edge.

+
Returns
The total relative number of paths per edge.
+ +

Definition at line 189 of file BetweennessCentrality.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ algo_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
TAlgoHandling egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::algo_
+ 		+private
+
+

Multiple path finding algorithm are used for the parallelization.

+ +

Definition at line 393 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ collection_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
TMeasurementCollection egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::collection_
+ 		+private
+
+

The collection of measurements.

+ +

Definition at line 394 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ countersSize_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
Types::count egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::countersSize_
+ 		+private
+
+ +

Definition at line 391 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
TGraph const& egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::graph_
+ 		+private
+
+

The graph $\graph = (\vertices,\edges)$ on which the DTP is calculated.

+ +

Definition at line 392 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ totalNumberOfPaths_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
std::vector<Types::count> egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::totalNumberOfPaths_
+ 		+private
+
+ +

Definition at line 397 of file BetweennessCentrality.hpp.

+ +
+
+ +

◆ totalRelativeNumberOfPaths_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >, typename PathFindingAlgorithm = DominatingThetaPath<GraphType>, typename MeasurementCollection = IO::DtpRuntimeCollection, CentralityCounter CentralityCounterType = CentralityCounter::counterAtEdges>
+ + + + + +
+ + + + +
std::vector<Types::real> egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >::totalRelativeNumberOfPaths_
+ 		+private
+
+ +

Definition at line 396 of file BetweennessCentrality.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_binary_heap-members.html b/classegoa_1_1_binary_heap-members.html new file mode 100644 index 00000000..f52f0164 --- /dev/null +++ b/classegoa_1_1_binary_heap-members.html @@ -0,0 +1,151 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BinaryHeap< ElementType > Member List
+
+
+ +

This is the complete list of members for egoa::BinaryHeap< ElementType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Back()egoa::BinaryHeap< ElementType >inlineprivate
Back() constegoa::BinaryHeap< ElementType >inlineprivate
begin() const noexceptegoa::BinaryHeap< ElementType >inline
BinaryHeap()egoa::BinaryHeap< ElementType >inline
BinaryHeap(std::vector< TElement > const &elements)egoa::BinaryHeap< ElementType >inlineexplicit
BuildWith(std::vector< TElement > const &elements)egoa::BinaryHeap< ElementType >inline
ChangeKey(Types::index index, TElement const &element)egoa::BinaryHeap< ElementType >inline
Clear()egoa::BinaryHeap< ElementType >inline
Comparator() constegoa::BinaryHeap< ElementType >inline
Comparator(std::function< bool(TElement const &, TElement const &)> comparator)egoa::BinaryHeap< ElementType >inline
comparator_ (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >private
ComplyHeapProperty(Types::index index) constegoa::BinaryHeap< ElementType >inlineprivate
ComplyHeapProperty() constegoa::BinaryHeap< ElementType >inlineprivate
DecreaseKey(Types::index index, TElement const &element)egoa::BinaryHeap< ElementType >inline
DeleteTop()egoa::BinaryHeap< ElementType >inline
ElementAt(Types::index index) (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
ElementAt(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
Emplace(Args &&... args)egoa::BinaryHeap< ElementType >inline
Empty() constegoa::BinaryHeap< ElementType >inline
end() const noexceptegoa::BinaryHeap< ElementType >inline
for_all_elements(FUNCTION function)egoa::BinaryHeap< ElementType >inline
for_all_elements(FUNCTION function) constegoa::BinaryHeap< ElementType >inline
Front()egoa::BinaryHeap< ElementType >inlineprivate
Front() constegoa::BinaryHeap< ElementType >inlineprivate
HasChildren(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
HasLeftChild(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
HasParent(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
HasRightChild(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
heap_ (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >private
Insert(TElement const &element)egoa::BinaryHeap< ElementType >inline
Insert(TElement &&element)egoa::BinaryHeap< ElementType >inline
Insert(InputIt first, InputIt last)egoa::BinaryHeap< ElementType >inline
Insert(std::vector< TElement > const &elements)egoa::BinaryHeap< ElementType >inline
IsEqualTo(BinaryHeap const &rhs) constegoa::BinaryHeap< ElementType >inline
LeftChildIdOf(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
LeftElementAt(Types::index index) (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
LeftElementAt(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
MakeHeapProperty()egoa::BinaryHeap< ElementType >inlineprivate
Maximize()egoa::BinaryHeap< ElementType >inline
MaximumIndex() constegoa::BinaryHeap< ElementType >inlineprivate
Minimize()egoa::BinaryHeap< ElementType >inline
operator!=(BinaryHeap const &rhs) constegoa::BinaryHeap< ElementType >inline
operator+=(TElement const &rhs)egoa::BinaryHeap< ElementType >inline
operator+=(TElement &&rhs)egoa::BinaryHeap< ElementType >inline
operator<<egoa::BinaryHeap< ElementType >friend
operator==(BinaryHeap const &rhs) constegoa::BinaryHeap< ElementType >inline
ParentElementAt(Types::index index) (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
ParentElementAt(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
ParentIdOf(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
Pop()egoa::BinaryHeap< ElementType >inline
RightChildIdOf(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
RightElementAt(Types::index index) (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
RightElementAt(Types::index index) const (defined in egoa::BinaryHeap< ElementType >)egoa::BinaryHeap< ElementType >inlineprivate
Search(TElement const &element) constegoa::BinaryHeap< ElementType >inline
SelectSwappableChildAt(Types::index index) constegoa::BinaryHeap< ElementType >inlineprivate
SiftDown()egoa::BinaryHeap< ElementType >inlineprivate
SiftDown(Types::index index)egoa::BinaryHeap< ElementType >inlineprivate
SiftUp()egoa::BinaryHeap< ElementType >inlineprivate
SiftUp(Types::index index)egoa::BinaryHeap< ElementType >inlineprivate
Size() constegoa::BinaryHeap< ElementType >inline
swapegoa::BinaryHeap< ElementType >friend
TElement typedefegoa::BinaryHeap< ElementType >
Top() constegoa::BinaryHeap< ElementType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_binary_heap.html b/classegoa_1_1_binary_heap.html new file mode 100644 index 00000000..d9824451 --- /dev/null +++ b/classegoa_1_1_binary_heap.html @@ -0,0 +1,2659 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BinaryHeap< ElementType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Private Attributes | +List of all members
+
egoa::BinaryHeap< ElementType > Class Template Reference
+
+
+ +

Class for binary heap data structure. + More...

+ +

#include <BinaryHeap.hpp>

+ + + + + +

+Classes

class  HeapIterator
 Class for a heap iterator. More...
 
+ + + + +

+Public Types

using TElement = ElementType
 The type of the elements in the heap.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 BinaryHeap ()
 Constructs an empty Min-heap.
 
 BinaryHeap (std::vector< TElement > const &elements)
 Constructs a Min-heap of an vector.
 
Element Access
TElement const & Top () const
 The top element.
 
Types::index Search (TElement const &element) const
 Searches for the first match.
 
Element Insertion
BinaryHeap & operator+= (TElement const &rhs)
 Inserts an element into the heap.
 
BinaryHeap & operator+= (TElement &&rhs)
 Inserts an element into the heap.
 
void Insert (TElement const &element)
 Inserts an element into the heap.
 
void Insert (TElement &&element)
 Inserts an element into the heap.
 
template<typename InputIt >
void Insert (InputIt first, InputIt last)
 Inserts the elements from the range [first, last).
 
void Insert (std::vector< TElement > const &elements)
 Inserts the elements from the vector.
 
template<typename... Args>
void Emplace (Args &&... args)
 Emplaces an element to the heap.
 
void BuildWith (std::vector< TElement > const &elements)
 Builds a heap.
 
Modifiers
void Pop ()
 Deletes the top element.
 
TElement DeleteTop ()
 Deletes the top element.
 
void Clear ()
 Clears the heap.
 
void ChangeKey (Types::index index, TElement const &element)
 Changes the key of one element.
 
void DecreaseKey (Types::index index, TElement const &element)
 Decreases the key of one element.
 
Capacity
bool Empty () const
 Checks if BinaryHeap is empty.
 
Types::count Size () const
 Number of elements in the heap.
 
Comparator
std::function< bool(TElement const &, TElement const &) > const & Comparator () const
 The comparator.
 
void Comparator (std::function< bool(TElement const &, TElement const &)> comparator)
 Changes the comparator.
 
void Maximize ()
 Changes the comparator to construct a max-heap.
 
void Minimize ()
 Changes the comparator to construct a min-heap.
 
Iterators
HeapIterator begin () const noexcept
 An iterator pointing to the top element of the heap.
 
HeapIterator end () const noexcept
 An interator pointing behind the last element.
 
Loops
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_elements (FUNCTION function)
 Iterates over all elements in the heap.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 Iterates over all elements in the heap.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Accessors
TElement & ElementAt (Types::index index)
 
TElement const & ElementAt (Types::index index) const
 
TElement & ParentElementAt (Types::index index)
 
TElement const & ParentElementAt (Types::index index) const
 
TElement & RightElementAt (Types::index index)
 
TElement const & RightElementAt (Types::index index) const
 
TElement & LeftElementAt (Types::index index)
 
TElement const & LeftElementAt (Types::index index) const
 
Types::index LeftChildIdOf (Types::index index) const
 
Types::index RightChildIdOf (Types::index index) const
 
bool HasChildren (Types::index index) const
 
bool HasLeftChild (Types::index index) const
 
bool HasRightChild (Types::index index) const
 
Types::index ParentIdOf (Types::index index) const
 
bool HasParent (Types::index index) const
 
TElement & Front ()
 The top element.
 
TElement const & Front () const
 The top element.
 
TElement & Back ()
 The last element.
 
TElement const & Back () const
 The last element.
 
Types::index MaximumIndex () const
 Maximum index of the heap.
 
Heap Property Methods
void MakeHeapProperty ()
 Makes a heap property.
 
bool ComplyHeapProperty (Types::index index) const
 Checks if the heap complies with the heap property at element index.
 
bool ComplyHeapProperty () const
 Checks if the heap complies with the heap property.
 
Sifts
void SiftUp ()
 Sift the last element up.
 
void SiftUp (Types::index index)
 Sift up.
 
void SiftDown ()
 Sift down the element at the root.
 
void SiftDown (Types::index index)
 Sift down the element at index.
 
Swappability
Types::index SelectSwappableChildAt (Types::index index) const
 Selects the smallest child, where smallest is measured according to the comparator.
 
+ + + + + +

+Private Attributes

std::vector< TElement > heap_
 
std::function< bool(TElement const &a, TElement const &b)> comparator_
 
+ + + + + +

+Friends

Output
std::ostream & operator<< (std::ostream &outputStream, BinaryHeap const &heap)
 Writes the heap into an output stream.
 
+ + + + + + + + + + + + + + +

Operators

bool operator== (BinaryHeap const &rhs) const
 Check if two heaps are equivalent.
 
bool operator!= (BinaryHeap const &rhs) const
 Check if two heaps are not equivalent.
 
template<bool IsIdentical>
bool IsEqualTo (BinaryHeap const &rhs) const
 Determines if equal to.
 
void swap (BinaryHeap< TElement > &lhs, BinaryHeap< TElement > &rhs)
 Swap two BinaryHeaps.
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::BinaryHeap< ElementType >

Class for binary heap data structure.

+

The methods have the following worst case time complexities:

+ + + + + + + + + + + + + + + + +
Function Time Complexity
Top $\Theta(1)$
Insertion (Emplace, Push) $\Theta(\log n)$
MakeHeap $\Theta(1)$
DeleteTop, Pop $\Theta(\log n)$
Delete $\Theta(\log n)$
ChangeKey $\Theta(\log n)$
Union (not implemented yet) $\Theta(n)$
+

The comparator must implement a strict total order on the elements, e.g., std::less<TElement>.

+
BinaryHeap<int> heap;
+
heap.Maximize();
+
heap += 1;
+
heap.Insert(3);
+
heap.Push(5);
+
heap.Emplace(9);
+
std::cout << heap << std::endl;
+
egoa::BinaryHeap
Class for binary heap data structure.
Definition BinaryHeap.hpp:94
+
egoa::BinaryHeap::Emplace
void Emplace(Args &&... args)
Emplaces an element to the heap.
Definition BinaryHeap.hpp:259
+
egoa::BinaryHeap::Insert
void Insert(TElement const &element)
Inserts an element into the heap.
Definition BinaryHeap.hpp:204
+
egoa::BinaryHeap::Maximize
void Maximize()
Changes the comparator to construct a max-heap.
Definition BinaryHeap.hpp:441
+
Template Parameters
+ + +
ElementTypeType of the elements contained by the heap.
+
+
+ +

Definition at line 94 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::TElement = ElementType
+
+ +

The type of the elements in the heap.

+ +

Definition at line 100 of file BinaryHeap.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BinaryHeap() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
egoa::BinaryHeap< ElementType >::BinaryHeap ()
+ 		+inline
+
+ +

Constructs an empty Min-heap.

+
Parameters
+ + +
elementsThe elements
+
+
+ +

Definition at line 110 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Minimize().

+ +
+
+ +

◆ BinaryHeap() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
egoa::BinaryHeap< ElementType >::BinaryHeap (std::vector< TElement > const & elements)
+ 		+inlineexplicit
+
+ +

Constructs a Min-heap of an vector.

+
Parameters
+ + +
elementsThe elements
+
+
+ +

Definition at line 120 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::BuildWith(), and egoa::BinaryHeap< ElementType >::Minimize().

+ +
+
+

Member Function Documentation

+ +

◆ Back() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::Back ()
+ 		+inlineprivate
+
+ +

The last element.

+
Returns
The last element, which is at the back of heap_.
+ +

Definition at line 706 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+ +

◆ Back() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::Back () const
+ 		+inlineprivate
+
+ +

The last element.

+
Returns
The last element, which is at the back of heap_.
+ +

Definition at line 717 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+ +

◆ begin()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
HeapIterator egoa::BinaryHeap< ElementType >::begin () const
+ 		+inlinenoexcept
+
+ +

An iterator pointing to the top element of the heap.

+
Returns
An iterator pointing to the top element.
+ +

Definition at line 599 of file BinaryHeap.hpp.

+ +
+
+ +

◆ BuildWith()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::BuildWith (std::vector< TElement > const & elements)
+ 		+inline
+
+ +

Builds a heap.

+
Note
This will overwrite the existing content.
+
Parameters
+ + +
[in]elementsThe elements with which to build the heap
+
+
+ +

Definition at line 274 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::MakeHeapProperty().

+ +
+
+ +

◆ ChangeKey()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::BinaryHeap< ElementType >::ChangeKey (Types::index index,
TElement const & element 
)
+ 		+inline
+
+ +

Changes the key of one element.

+

The key of the element may be increased or decreased (or remain unchanged).

+
Precondition
index < Size()
+
egoa::BinaryHeap::Size
Types::count Size() const
Number of elements in the heap.
Definition BinaryHeap.hpp:393
+
+
Parameters
+ + + +
[in]indexThe index of which the key shall be changed.
[in]elementThe element with a new key.
+
+
+ +

Definition at line 339 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), egoa::BinaryHeap< ElementType >::SiftDown(), egoa::BinaryHeap< ElementType >::SiftUp(), and egoa::BinaryHeap< ElementType >::Size().

+ +
+
+ +

◆ Clear()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::Clear ()
+ 		+inline
+
+ +

Clears the heap.

+ +

Definition at line 324 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Comparator() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
std::function< bool(TElement const &, TElement const &) > const & egoa::BinaryHeap< ElementType >::Comparator () const
+ 		+inline
+
+ +

The comparator.

+
Returns
The comparator.
+ +

Definition at line 410 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Comparator() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::Comparator (std::function< bool(TElement const &, TElement const &)> comparator)
+ 		+inline
+
+ +

Changes the comparator.

+

The comparator must represent a strict total order on the elements.

+
...
+
heap_.Comparator( []( int a, int b ) { return a < b; } );
+
...
+
See also
TestBinaryHeapWithVectorOfInteger::TEST_F(TestBinaryHeapWithVectorOfInteger,ChangeComparatorToLess)
+
Parameters
+ + +
[in]comparatorThe comparator
+
+
+ +

Definition at line 429 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::MakeHeapProperty().

+ +
+
+ +

◆ ComplyHeapProperty() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
bool egoa::BinaryHeap< ElementType >::ComplyHeapProperty () const
+ 		+inlineprivate
+
+ +

Checks if the heap complies with the heap property.

+
Returns
true if the heap complies the heap property, false otherwise.
+ +

Definition at line 786 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::Size().

+ +
+
+ +

◆ ComplyHeapProperty() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::ComplyHeapProperty (Types::index index) const
+ 		+inlineprivate
+
+ +

Checks if the heap complies with the heap property at element index.

+
Parameters
+ + +
[in]indexThe index of the element.
+
+
+
Returns
true if the heap complies with the heap property at element index and false otherwise.
+ +

Definition at line 771 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator(), and egoa::BinaryHeap< ElementType >::Size().

+ +
+
+ +

◆ DecreaseKey()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::BinaryHeap< ElementType >::DecreaseKey (Types::index index,
TElement const & element 
)
+ 		+inline
+
+ +

Decreases the key of one element.

+

This only supports decreasing the key (according to the comparator) but not increasing it. That is, Comparator()(oldElement, element) is false.

+
Precondition
index < Size() && !Comparator()(oldElement, element), where oldElement denotes the element at position index, which is replaced.
+
Parameters
+ + + +
[in]indexThe index of which the key shall be decreased.
elementThe new element.
+
+
+ +

Definition at line 363 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), egoa::BinaryHeap< ElementType >::SiftUp(), and egoa::BinaryHeap< ElementType >::Size().

+ +
+
+ +

◆ DeleteTop()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement egoa::BinaryHeap< ElementType >::DeleteTop ()
+ 		+inline
+
+ +

Deletes the top element.

+
Precondition
The heap is not empty.
+
Returns
The top element.
+ +

Definition at line 303 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Back(), egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), egoa::BinaryHeap< ElementType >::Front(), egoa::BinaryHeap< ElementType >::SiftDown(), egoa::BinaryHeap< ElementType >::Size(), and egoa::BinaryHeap< ElementType >::swap.

+ +
+
+ +

◆ ElementAt() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::ElementAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 659 of file BinaryHeap.hpp.

+ +
+
+ +

◆ ElementAt() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::ElementAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 660 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Emplace()

+ +
+
+
+template<typename ElementType >
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::Emplace (Args &&... args)
+ 		+inline
+
+ +

Emplaces an element to the heap.

+
Parameters
+ + +
argsThe arguments of a constructor of TElement.
+
+
+ +

Definition at line 259 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::SiftUp().

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
bool egoa::BinaryHeap< ElementType >::Empty () const
+ 		+inline
+
+ +

Checks if BinaryHeap is empty.

+
Returns
TRUE if empty and FALSE otherwise.
+ +

Definition at line 383 of file BinaryHeap.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
HeapIterator egoa::BinaryHeap< ElementType >::end () const
+ 		+inlinenoexcept
+
+ +

An interator pointing behind the last element.

+
Returns
An interator pointing behind the last element.
+ +

Definition at line 606 of file BinaryHeap.hpp.

+ +
+
+ +

◆ for_all_elements() [1/2]

+ +
+
+
+template<typename ElementType >
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

Iterates over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function object that is called for all elements in the heap. It must accept one argument of type TElement, e.g.,
[]( TElement & element ) { ... }
+
egoa::BinaryHeap::TElement
ElementType TElement
The type of the elements in the heap.
Definition BinaryHeap.hpp:100
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 627 of file BinaryHeap.hpp.

+ +
+
+ +

◆ for_all_elements() [2/2]

+ +
+
+
+template<typename ElementType >
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Iterates over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function object that is called for all elements in the heap. It must accept one argument of type TElement, e.g.,
[]( TElement const & element ) { ... }
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 648 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Front() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::Front ()
+ 		+inlineprivate
+
+ +

The top element.

+
Returns
The top element, which is at the front of heap_.
+ +

Definition at line 684 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+ +

◆ Front() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::Front () const
+ 		+inlineprivate
+
+ +

The top element.

+
Returns
The top element, which is at the front of heap_.
+ +

Definition at line 695 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+ +

◆ HasChildren()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HasChildren (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 673 of file BinaryHeap.hpp.

+ +
+
+ +

◆ HasLeftChild()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HasLeftChild (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 674 of file BinaryHeap.hpp.

+ +
+
+ +

◆ HasParent()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HasParent (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 677 of file BinaryHeap.hpp.

+ +
+
+ +

◆ HasRightChild()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HasRightChild (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 675 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Insert() [1/4]

+ +
+
+
+template<typename ElementType >
+
+template<typename InputIt >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::BinaryHeap< ElementType >::Insert (InputIt first,
InputIt last 
)
+ 		+inline
+
+ +

Inserts the elements from the range [first, last).

+
Parameters
+ + + +
[in]firstIterator pointing to the first element to add.
[in]lastIterator pointing behind the last element to add.
+
+
+
Template Parameters
+ + +
InputItThe type of the iterators. It must satisfy the requirements of input iterators.
+
+
+ +

Definition at line 231 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty().

+ +
+
+ +

◆ Insert() [2/4]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::Insert (std::vector< TElement > const & elements)
+ 		+inline
+
+ +

Inserts the elements from the vector.

+
Parameters
+ + +
elementsThe elements to insert
+
+
+ +

Definition at line 247 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::Insert().

+ +
+
+ +

◆ Insert() [3/4]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::Insert (TElement && element)
+ 		+inline
+
+ +

Inserts an element into the heap.

+
Parameters
+ + +
elementThe element.
+
+
+ +

Definition at line 215 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty().

+ +
+
+ +

◆ Insert() [4/4]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::Insert (TElement const & element)
+ 		+inline
+
+ +

Inserts an element into the heap.

+
Parameters
+ + +
elementThe element.
+
+
+ +

Definition at line 204 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty().

+ +
+
+ +

◆ IsEqualTo()

+ +
+
+
+template<typename ElementType >
+
+template<bool IsIdentical>
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::IsEqualTo (BinaryHeap< ElementType > const & rhs) const
+ 		+inline
+
+ +

Determines if equal to.

+
Parameters
+ + +
rhsThe right hand side binary heap object
+
+
+
Template Parameters
+ + +
IsIdenticalIf true it determines if equal—in sense of order—to the @rhs binary heap, if false it checks if the heap has the same elements.
+
+
+
Returns
true if equal to rhs, false otherwise.
+ +

Definition at line 503 of file BinaryHeap.hpp.

+ +
+
+ +

◆ LeftChildIdOf()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::LeftChildIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 671 of file BinaryHeap.hpp.

+ +
+
+ +

◆ LeftElementAt() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::LeftElementAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 668 of file BinaryHeap.hpp.

+ +
+
+ +

◆ LeftElementAt() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::LeftElementAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 669 of file BinaryHeap.hpp.

+ +
+
+ +

◆ MakeHeapProperty()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::MakeHeapProperty ()
+ 		+inlineprivate
+
+ +

Makes a heap property.

+

This works even if the heap is empty. 

        The counter starts at @f$ n / 2 - 1 @f$ since the
+        leafs fulfill the heap property. Thus, starting at
+        the second level is sufficient. Roughly speaking,
+        each layer @p l contains twice as many elements
+        than the previous layer meaning @f$2^l@f$ elements.
+        Dividing by 2 brings us to the previous layer
+        @f$2^{l-1}@f$. As we start at 0, the value has to
+        be reduced by 1.
+
+

Definition at line 751 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::SiftDown().

+ +
+
+ +

◆ Maximize()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::Maximize ()
+ 		+inline
+
+ +

Changes the comparator to construct a max-heap.

+

The comparator is set to std::greater<TElement>() and the heap is updated to respect the new comparator.

+ +

Definition at line 441 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator().

+ +
+
+ +

◆ MaximumIndex()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::MaximumIndex () const
+ 		+inlineprivate
+
+ +

Maximum index of the heap.

+
Returns
The maximum index.
+ +

Definition at line 728 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+ +

◆ Minimize()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::Minimize ()
+ 		+inline
+
+ +

Changes the comparator to construct a min-heap.

+

The comparator is set to std::less<TElement>() and the heap is updated to respect the new comparator.

+ +

Definition at line 451 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator().

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::operator!= (BinaryHeap< ElementType > const & rhs) const
+ 		+inline
+
+ +

Check if two heaps are not equivalent.

+

Equivalent means that they contain the same elements when the order of the elements is ignored.

+
Parameters
+ + +
rhsThe right hand side heap.
+
+
+
Returns
true if the heaps do not contain the same elements, false if they contain the same elements where the order does not matter.
+ +

Definition at line 486 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator+=() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
BinaryHeap & egoa::BinaryHeap< ElementType >::operator+= (TElement && rhs)
+ 		+inline
+
+ +

Inserts an element into the heap.

+
Parameters
+ + +
elementThe element.
+
+
+
Returns
*this.
+ +

Definition at line 190 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::SiftUp().

+ +
+
+ +

◆ operator+=() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
BinaryHeap & egoa::BinaryHeap< ElementType >::operator+= (TElement const & rhs)
+ 		+inline
+
+ +

Inserts an element into the heap.

+
Parameters
+ + +
elementThe element.
+
+
+
Returns
*this.
+ +

Definition at line 174 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::SiftUp().

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::operator== (BinaryHeap< ElementType > const & rhs) const
+ 		+inline
+
+ +

Check if two heaps are equivalent.

+

Equivalent means that they contain the same elements when the order of the elements is ignored.

+
Parameters
+ + +
rhsThe right hand side heap.
+
+
+
Returns
true if the heaps are equivalent, false if they do not have the same element.
+ +

Definition at line 470 of file BinaryHeap.hpp.

+ +
+
+ +

◆ ParentElementAt() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::ParentElementAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 662 of file BinaryHeap.hpp.

+ +
+
+ +

◆ ParentElementAt() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::ParentElementAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 663 of file BinaryHeap.hpp.

+ +
+
+ +

◆ ParentIdOf()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::ParentIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 676 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Pop()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::Pop ()
+ 		+inline
+
+ +

Deletes the top element.

+
Precondition
The heap is not empty.
+ +

Definition at line 289 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), egoa::BinaryHeap< ElementType >::DeleteTop(), and egoa::BinaryHeap< ElementType >::Size().

+ +
+
+ +

◆ RightChildIdOf()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::RightChildIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 672 of file BinaryHeap.hpp.

+ +
+
+ +

◆ RightElementAt() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement & egoa::BinaryHeap< ElementType >::RightElementAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 665 of file BinaryHeap.hpp.

+ +
+
+ +

◆ RightElementAt() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::RightElementAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 666 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Search()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::Search (TElement const & element) const
+ 		+inline
+
+ +

Searches for the first match.

+
Parameters
+ + +
[in]elementThe element to search for.
+
+
+
Returns
Index of the element, or if not available Const::none.
+ +

Definition at line 151 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty().

+ +
+
+ +

◆ SelectSwappableChildAt()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BinaryHeap< ElementType >::SelectSwappableChildAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Selects the smallest child, where smallest is measured according to the comparator.

+

If the elements needs to be swapped with a child, then it is the child at the position returned by this method.

+
Parameters
+ + +
[in]indexThe current index.
+
+
+
Returns
The index of the child that has the best key.
+ +

Definition at line 884 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator().

+ +
+
+ +

◆ SiftDown() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::SiftDown ()
+ 		+inlineprivate
+
+ +

Sift down the element at the root.

+ +

Definition at line 839 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty(), and egoa::BinaryHeap< ElementType >::SiftDown().

+ +
+
+ +

◆ SiftDown() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::SiftDown (Types::index index)
+ 		+inlineprivate
+
+ +

Sift down the element at index.

+

Moves an element down the tree until the heap property holds

+
Parameters
+ + +
[in]indexThe index of the element that shall be sifted down.
+
+
+ +

Definition at line 851 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator(), egoa::BinaryHeap< ElementType >::SelectSwappableChildAt(), egoa::BinaryHeap< ElementType >::Size(), and egoa::BinaryHeap< ElementType >::swap.

+ +
+
+ +

◆ SiftUp() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
void egoa::BinaryHeap< ElementType >::SiftUp ()
+ 		+inlineprivate
+
+ +

Sift the last element up.

+ +

Definition at line 807 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Empty(), egoa::BinaryHeap< ElementType >::MaximumIndex(), and egoa::BinaryHeap< ElementType >::SiftUp().

+ +
+
+ +

◆ SiftUp() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
void egoa::BinaryHeap< ElementType >::SiftUp (Types::index index)
+ 		+inlineprivate
+
+ +

Sift up.

+

The element will be shifted upwards the tree while the

+
Parameters
+ + +
[in]indexThe index of the element tha shall be sifted up.
+
+
+ +

Definition at line 819 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Comparator(), egoa::BinaryHeap< ElementType >::Size(), and egoa::BinaryHeap< ElementType >::swap.

+ +
+
+ +

◆ Size()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
Types::count egoa::BinaryHeap< ElementType >::Size () const
+ 		+inline
+
+ +

Number of elements in the heap.

+
Returns
The size of the heap
+ +

Definition at line 393 of file BinaryHeap.hpp.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::Top () const
+ 		+inline
+
+ +

The top element.

+
Precondition
The heap must not be empty.
+
Returns
The element with minimum key according to the comparator.
+ +

Definition at line 137 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::ComplyHeapProperty(), and egoa::BinaryHeap< ElementType >::Empty().

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
BinaryHeap< ElementType > const & heap 
)
+ 		+friend
+
+ +

Writes the heap into an output stream.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
heapThe heap.
+
+
+
Returns
The resulting output stream.
+ +

Definition at line 534 of file BinaryHeap.hpp.

+ +
+
+ +

◆ swap

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (BinaryHeap< TElement > & lhs,
BinaryHeap< TElement > & rhs 
)
+ 		+friend
+
+ +

Swap two BinaryHeaps.

+
Parameters
+ + + +
lhsThe left hand side BinaryHeaps
rhsThe right hand side BinaryHeaps
+
+
+ +

Definition at line 515 of file BinaryHeap.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ comparator_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
std::function<bool(TElement const & a, TElement const & b)> egoa::BinaryHeap< ElementType >::comparator_
+ 		+private
+
+ +

Definition at line 914 of file BinaryHeap.hpp.

+ +
+
+ +

◆ heap_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
std::vector<TElement> egoa::BinaryHeap< ElementType >::heap_
+ 		+private
+
+ +

Definition at line 913 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_binary_heap_1_1_heap_iterator-members.html b/classegoa_1_1_binary_heap_1_1_heap_iterator-members.html new file mode 100644 index 00000000..0bb8a089 --- /dev/null +++ b/classegoa_1_1_binary_heap_1_1_heap_iterator-members.html @@ -0,0 +1,105 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BinaryHeap< ElementType >::HeapIterator Member List
+
+
+ +

This is the complete list of members for egoa::BinaryHeap< ElementType >::HeapIterator, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
begin_egoa::BinaryHeap< ElementType >::HeapIteratorprivate
counter_egoa::BinaryHeap< ElementType >::HeapIteratorprivate
difference_type typedefegoa::BinaryHeap< ElementType >::HeapIterator
end_egoa::BinaryHeap< ElementType >::HeapIteratorprivate
HeapIterator(std::vector< TElement > const *vector, Types::largeNumber counter=0) (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinlineexplicit
HeapIterator(std::vector< TElement > const *vector, Types::largeNumber counter, Types::largeNumber begin, Types::largeNumber end) (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinlineexplicit
iterator_category typedefegoa::BinaryHeap< ElementType >::HeapIterator
operator!=(HeapIterator const &rhs) const (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
operator*() const (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
operator++() (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
operator++(int) (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
operator->() const (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
operator==(HeapIterator const &rhs) const (defined in egoa::BinaryHeap< ElementType >::HeapIterator)egoa::BinaryHeap< ElementType >::HeapIteratorinline
pointer typedefegoa::BinaryHeap< ElementType >::HeapIterator
reference typedefegoa::BinaryHeap< ElementType >::HeapIterator
value_type typedefegoa::BinaryHeap< ElementType >::HeapIterator
vector_egoa::BinaryHeap< ElementType >::HeapIteratorprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_binary_heap_1_1_heap_iterator.html b/classegoa_1_1_binary_heap_1_1_heap_iterator.html new file mode 100644 index 00000000..9f4aa819 --- /dev/null +++ b/classegoa_1_1_binary_heap_1_1_heap_iterator.html @@ -0,0 +1,622 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BinaryHeap< ElementType >::HeapIterator Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::BinaryHeap< ElementType >::HeapIterator Class Reference
+
+
+ +

Class for a heap iterator. + More...

+ + + + + + + + + + + + +

+Public Types

using iterator_category = std::forward_iterator_tag
 
using value_type = TElement
 
using difference_type = Types::difference
 
using pointer = const TElement *
 
using reference = const TElement &
 
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 HeapIterator (std::vector< TElement > const *vector, Types::largeNumber counter=0)
 
 HeapIterator (std::vector< TElement > const *vector, Types::largeNumber counter, Types::largeNumber begin, Types::largeNumber end)
 
HeapIterator & operator++ ()
 
HeapIterator operator++ (int)
 
bool operator== (HeapIterator const &rhs) const
 
bool operator!= (HeapIterator const &rhs) const
 
TElement const & operator* () const
 
TElement const * operator-> () const
 
+ + + + + + + + + +

+Private Attributes

Types::largeNumber counter_
 
Types::largeNumber begin_
 
Types::largeNumber end_
 
std::vector< TElement > const * vector_
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::BinaryHeap< ElementType >::HeapIterator

Class for a heap iterator.

+

Based on example code from https://en.cppreference.com/w/cpp/iterator/iterator.

+ +

Definition at line 551 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::HeapIterator::difference_type = Types::difference
+
+

Difference type

+ +

Definition at line 559 of file BinaryHeap.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::HeapIterator::iterator_category = std::forward_iterator_tag
+
+

Iterator category type

+ +

Definition at line 557 of file BinaryHeap.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::HeapIterator::pointer = const TElement*
+
+

Element pointer type

+ +

Definition at line 560 of file BinaryHeap.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::HeapIterator::reference = const TElement&
+
+

Element reference type

+ +

Definition at line 561 of file BinaryHeap.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BinaryHeap< ElementType >::HeapIterator::value_type = TElement
+
+

Value type

+ +

Definition at line 558 of file BinaryHeap.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ HeapIterator() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BinaryHeap< ElementType >::HeapIterator::HeapIterator (std::vector< TElement > const * vector,
Types::largeNumber counter = 0 
)
+ 		+inlineexplicit
+
+ +

Definition at line 563 of file BinaryHeap.hpp.

+ +
+
+ +

◆ HeapIterator() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::BinaryHeap< ElementType >::HeapIterator::HeapIterator (std::vector< TElement > const * vector,
Types::largeNumber counter,
Types::largeNumber begin,
Types::largeNumber end 
)
+ 		+inlineexplicit
+
+ +

Definition at line 570 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HeapIterator::operator!= (HeapIterator const & rhs) const
+ 		+inline
+
+ +

Definition at line 588 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement const & egoa::BinaryHeap< ElementType >::HeapIterator::operator* () const
+ 		+inline
+
+ +

Definition at line 589 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
HeapIterator & egoa::BinaryHeap< ElementType >::HeapIterator::operator++ ()
+ 		+inline
+
+ +

Definition at line 579 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
HeapIterator egoa::BinaryHeap< ElementType >::HeapIterator::operator++ (int )
+ 		+inline
+
+ +

Definition at line 580 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement const * egoa::BinaryHeap< ElementType >::HeapIterator::operator-> () const
+ 		+inline
+
+ +

Definition at line 590 of file BinaryHeap.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BinaryHeap< ElementType >::HeapIterator::operator== (HeapIterator const & rhs) const
+ 		+inline
+
+ +

Definition at line 585 of file BinaryHeap.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ begin_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
Types::largeNumber egoa::BinaryHeap< ElementType >::HeapIterator::begin_
+ 		+private
+
+

Begin

+ +

Definition at line 553 of file BinaryHeap.hpp.

+ +
+
+ +

◆ counter_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
Types::largeNumber egoa::BinaryHeap< ElementType >::HeapIterator::counter_
+ 		+private
+
+

Counter

+ +

Definition at line 552 of file BinaryHeap.hpp.

+ +
+
+ +

◆ end_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
Types::largeNumber egoa::BinaryHeap< ElementType >::HeapIterator::end_
+ 		+private
+
+

End

+ +

Definition at line 554 of file BinaryHeap.hpp.

+ +
+
+ +

◆ vector_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
std::vector<TElement> const* egoa::BinaryHeap< ElementType >::HeapIterator::vector_
+ 		+private
+
+

Vector of elements

+ +

Definition at line 555 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree-members.html b/classegoa_1_1_block_cut_tree-members.html new file mode 100644 index 00000000..d95fd18d --- /dev/null +++ b/classegoa_1_1_block_cut_tree-members.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BlockCutTree< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::BlockCutTree< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
BlockAt(Types::blockId id) constegoa::BlockCutTree< GraphType >inline
BlockCutTree(TGraph const &graph) (defined in egoa::BlockCutTree< GraphType >)egoa::BlockCutTree< GraphType >inlineprivate
BlockOfEdge(Types::edgeId id) constegoa::BlockCutTree< GraphType >inline
blockOfEdge_egoa::BlockCutTree< GraphType >private
blocks_egoa::BlockCutTree< GraphType >private
BlocksOfVertex(Types::vertexId id) constegoa::BlockCutTree< GraphType >inline
blocksOfVertex_egoa::BlockCutTree< GraphType >private
Build(TGraph const &graph)egoa::BlockCutTree< GraphType >inlinestatic
CutVertexAt(Types::vertexId id) constegoa::BlockCutTree< GraphType >inline
cutVertices_egoa::BlockCutTree< GraphType >private
egoa::internal::BlockCutTreeBuilder< TGraph > (defined in egoa::BlockCutTree< GraphType >)egoa::BlockCutTree< GraphType >friend
Graph() constegoa::BlockCutTree< GraphType >inline
graph_egoa::BlockCutTree< GraphType >private
IsCutVertex(Types::vertexId id) constegoa::BlockCutTree< GraphType >inline
NumberOfBlocks() constegoa::BlockCutTree< GraphType >inline
NumberOfCutVertices() constegoa::BlockCutTree< GraphType >inline
numberOfCutVertices_egoa::BlockCutTree< GraphType >private
TGraph typedef (defined in egoa::BlockCutTree< GraphType >)egoa::BlockCutTree< GraphType >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree.html b/classegoa_1_1_block_cut_tree.html new file mode 100644 index 00000000..62112818 --- /dev/null +++ b/classegoa_1_1_block_cut_tree.html @@ -0,0 +1,796 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BlockCutTree< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Static Public Member Functions | +Private Member Functions | +Friends | +List of all members
+
egoa::BlockCutTree< GraphType > Class Template Referencefinal
Block-cut tree related classes and functions
+
+
+ +

A block-cut tree. + More...

+ +

#include <BlockCutTree.hpp>

+ + + + + + + + +

+Classes

class  Block
 A block. More...
 
class  CutVertex
 Class for cut-vertices. More...
 
+ + + +

+Public Types

using TGraph = GraphType
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Basic Properties
Types::count NumberOfBlocks () const
 The number of blocks in the block-cut tree.
 
Types::count NumberOfCutVertices () const
 The number of cut-vertices in the block-cut tree.
 
TGraph const & Graph () const
 The underlying graph of the block-cut tree.
 
Topology
std::vector< Types::blockId > const & BlocksOfVertex (Types::vertexId id) const
 All identifiers of the blocks a vertex belongs to.
 
Types::blockId BlockOfEdge (Types::edgeId id) const
 The identifiers of the block an edge belongs to.
 
bool IsCutVertex (Types::vertexId id) const
 Whether a vertex is a cut-vertex.
 
Block const & BlockAt (Types::blockId id) const
 The block with identifier id.
 
CutVertex const & CutVertexAt (Types::vertexId id) const
 The cut-vertex with identifier id.
 
+ + + + +

+Static Public Member Functions

static BlockCutTree Build (TGraph const &graph)
 Builds a BlockCutTree for a given graph.
 
+ + + +

+Private Member Functions

 BlockCutTree (TGraph const &graph)
 
+ + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Members
std::reference_wrapper< TGraph const > graph_
 The underlying graph.
 
std::vector< Block > blocks_
 The blocks in the block-cut tree ordered by their component identifiers.
 
std::vector< CutVertex > cutVertices_
 The cut-vertices in the graph.
 
std::vector< Types::blockId > blockOfEdge_
 For each edge the block it belongs to.
 
std::vector< std::vector< Types::blockId > > blocksOfVertex_
 For each vertex the blocks it belongs to.
 
Types::count numberOfCutVertices_
 The number of cut-vertices.
 
+ + + +

+Friends

class egoa::internal::BlockCutTreeBuilder< TGraph >
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::BlockCutTree< GraphType >

A block-cut tree.

+

The block-cut tree is unrooted.

+
Todo:
Example how a block-cut tree is constructed and how it can be used.
+
Template Parameters
+ + +
GraphTypeThe type of the underlying graph.
+
+
+ +

Definition at line 52 of file BlockCutTree.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTree< GraphType >::TGraph = GraphType
+
+ +

Definition at line 57 of file BlockCutTree.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BlockCutTree()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
egoa::BlockCutTree< GraphType >::BlockCutTree (TGraph const & graph)
+ 		+inlineprivate
+
+ +

Definition at line 60 of file BlockCutTree.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ BlockAt()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
Block const & egoa::BlockCutTree< GraphType >::BlockAt (Types::blockId id) const
+ 		+inline
+
+ +

The block with identifier id.

+
Parameters
+ + +
[in]idThe identifier of the block.
+
+
+
Returns
The block with identifier id.
+ +

Definition at line 158 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocks_.

+ +
+
+ +

◆ BlockOfEdge()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
Types::blockId egoa::BlockCutTree< GraphType >::BlockOfEdge (Types::edgeId id) const
+ 		+inline
+
+ +

The identifiers of the block an edge belongs to.

+
Parameters
+ + +
[in]idThe identifier of the edge.
+
+
+
Returns
The block identifier.
+ +

Definition at line 136 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blockOfEdge_.

+ +
+
+ +

◆ BlocksOfVertex()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
std::vector< Types::blockId > const & egoa::BlockCutTree< GraphType >::BlocksOfVertex (Types::vertexId id) const
+ 		+inline
+
+ +

All identifiers of the blocks a vertex belongs to.

+
Parameters
+ + +
[in]idThe identifier of the vertex.
+
+
+
Returns
A vector containing all identifiers of the blocks a vertex belongs to.
+ +

Definition at line 125 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocksOfVertex_.

+ +
+
+ +

◆ Build()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
static BlockCutTree egoa::BlockCutTree< GraphType >::Build (TGraph const & graph)
+ 		+inlinestatic
+
+ +

Builds a BlockCutTree for a given graph.

+
Parameters
+ + +
graphThe graph.
+
+
+
Returns
The BlockCutTree.
+ +

Definition at line 78 of file BlockCutTree.hpp.

+ +

References egoa::internal::BlockCutTreeBuilder< GraphType >::Build().

+ +
+
+ +

◆ CutVertexAt()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
CutVertex const & egoa::BlockCutTree< GraphType >::CutVertexAt (Types::vertexId id) const
+ 		+inline
+
+ +

The cut-vertex with identifier id.

+
Precondition
The vertex with identifier id is a cut-vertex.
+
Parameters
+ + +
[in]idThe identifier of the cut-vertex.
+
+
+
Returns
The cut-vertex object with identifier id.
+ +

Definition at line 171 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::cutVertices_, and egoa::BlockCutTree< GraphType >::IsCutVertex().

+ +
+
+ +

◆ Graph()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TGraph const & egoa::BlockCutTree< GraphType >::Graph () const
+ 		+inline
+
+ +

The underlying graph of the block-cut tree.

+
Returns
The underlying graph.
+ +

Definition at line 109 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::graph_.

+ +
+
+ +

◆ IsCutVertex()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
bool egoa::BlockCutTree< GraphType >::IsCutVertex (Types::vertexId id) const
+ 		+inline
+
+ +

Whether a vertex is a cut-vertex.

+
Parameters
+ + +
[in]idThe identifier of the vertex.
+
+
+
Returns
true if the vertex is a cut-vertex, false otherwise.
+ +

Definition at line 147 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::BlocksOfVertex().

+ +
+
+ +

◆ NumberOfBlocks()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Types::count egoa::BlockCutTree< GraphType >::NumberOfBlocks () const
+ 		+inline
+
+ +

The number of blocks in the block-cut tree.

+
Returns
The number of blocks.
+ +

Definition at line 91 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocks_.

+ +
+
+ +

◆ NumberOfCutVertices()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Types::count egoa::BlockCutTree< GraphType >::NumberOfCutVertices () const
+ 		+inline
+
+ +

The number of cut-vertices in the block-cut tree.

+
Returns
The number of cut-vertices.
+ +

Definition at line 100 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::numberOfCutVertices_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ egoa::internal::BlockCutTreeBuilder< TGraph >

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
friend class egoa::internal::BlockCutTreeBuilder< TGraph >
+ 		+friend
+
+ +

Definition at line 182 of file BlockCutTree.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ blockOfEdge_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<Types::blockId> egoa::BlockCutTree< GraphType >::blockOfEdge_
+ 		+private
+
+ +

For each edge the block it belongs to.

+

Note that each edge belongs to exactly one block.

+ +

Definition at line 325 of file BlockCutTree.hpp.

+ +
+
+ +

◆ blocks_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<Block> egoa::BlockCutTree< GraphType >::blocks_
+ 		+private
+
+ +

The blocks in the block-cut tree ordered by their component identifiers.

+ +

Definition at line 311 of file BlockCutTree.hpp.

+ +
+
+ +

◆ blocksOfVertex_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<std::vector<Types::blockId> > egoa::BlockCutTree< GraphType >::blocksOfVertex_
+ 		+private
+
+ +

For each vertex the blocks it belongs to.

+

A vertex is a cut-vertex if and only if it belongs to more than one block. For cut-vertices the first block is the parent block and the remaining blocks are the child blocks. For the root, all blocks are child blocks.

+ +

Definition at line 335 of file BlockCutTree.hpp.

+ +
+
+ +

◆ cutVertices_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<CutVertex> egoa::BlockCutTree< GraphType >::cutVertices_
+ 		+private
+
+ +

The cut-vertices in the graph.

+

The cut-vertex with identifier id is at position id in the vector. The positions that do not correspond to cut-vertices contain empty objects.

+ +

Definition at line 319 of file BlockCutTree.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::reference_wrapper<TGraph const> egoa::BlockCutTree< GraphType >::graph_
+ 		+private
+
+ +

The underlying graph.

+

A reference_wrapper is stored instead of a reference to make the block-cut tree assignable.

+ +

Definition at line 306 of file BlockCutTree.hpp.

+ +
+
+ +

◆ numberOfCutVertices_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::count egoa::BlockCutTree< GraphType >::numberOfCutVertices_
+ 		+private
+
+ +

The number of cut-vertices.

+

This is stored explicitly because cutVertices_ contains an entry for all vertices.

+ +

Definition at line 343 of file BlockCutTree.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_1_1_block-members.html b/classegoa_1_1_block_cut_tree_1_1_block-members.html new file mode 100644 index 00000000..0923917f --- /dev/null +++ b/classegoa_1_1_block_cut_tree_1_1_block-members.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BlockCutTree< GraphType >::Block Member List
+
+
+ +

This is the complete list of members for egoa::BlockCutTree< GraphType >::Block, including all inherited members.

+ + + + + + + + + + + + +
Block(Types::blockId identifier, Subgraph< TGraph const > subgraph, std::vector< Types::vertexId > cutVertices) (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockinline
CutVertices() constegoa::BlockCutTree< GraphType >::Blockinline
cutVertices_ (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockprivate
egoa::internal::BlockCutTreeBuilder< TGraph > (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockfriend
Identifier() constegoa::BlockCutTree< GraphType >::Blockinline
identifier_ (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockprivate
IsBridge() constegoa::BlockCutTree< GraphType >::Blockinline
IsLeaf() constegoa::BlockCutTree< GraphType >::Blockinline
parent_ (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockprivate
Subgraph() constegoa::BlockCutTree< GraphType >::Blockinline
subgraph_ (defined in egoa::BlockCutTree< GraphType >::Block)egoa::BlockCutTree< GraphType >::Blockprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_1_1_block.html b/classegoa_1_1_block_cut_tree_1_1_block.html new file mode 100644 index 00000000..21995c81 --- /dev/null +++ b/classegoa_1_1_block_cut_tree_1_1_block.html @@ -0,0 +1,485 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BlockCutTree< GraphType >::Block Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::BlockCutTree< GraphType >::Block Class Referencefinal
Block-cut tree related classes and functions
+
+
+ +

A block. + More...

+ +

#include <BlockCutTree.hpp>

+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Block (Types::blockId identifier, Subgraph< TGraph const > subgraph, std::vector< Types::vertexId > cutVertices)
 
Types::blockId Identifier () const
 The identifier of the block.
 
egoa::Subgraph< TGraph const > const & Subgraph () const
 The subgraph forming the block.
 
std::vector< Types::vertexId > const & CutVertices () const
 The cut-vertices of the block.
 
bool IsLeaf () const
 Whether the block is a leaf of the block-cut tree.
 
bool IsBridge () const
 Whether the block is a bridge.
 
+ + + + + + + + + +

+Private Attributes

Types::blockId identifier_
 
egoa::Subgraph< TGraph const > subgraph_
 
Types::vertexId parent_
 
std::vector< Types::vertexId > cutVertices_
 
+ + + +

+Friends

class egoa::internal::BlockCutTreeBuilder< TGraph >
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::BlockCutTree< GraphType >::Block

A block.

+ +

Definition at line 182 of file BlockCutTree.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Block()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::BlockCutTree< GraphType >::Block::Block (Types::blockId identifier,
Subgraph< TGraph const > subgraph,
std::vector< Types::vertexId > cutVertices 
)
+ 		+inline
+
+ +

Definition at line 184 of file BlockCutTree.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ CutVertices()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
std::vector< Types::vertexId > const & egoa::BlockCutTree< GraphType >::Block::CutVertices () const
+ 		+inline
+
+ +

The cut-vertices of the block.

+
Returns
A vector containing the identifiers of the cut-vertices.
+ +

Definition at line 215 of file BlockCutTree.hpp.

+ +
+
+ +

◆ Identifier()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Types::blockId egoa::BlockCutTree< GraphType >::Block::Identifier () const
+ 		+inline
+
+ +

The identifier of the block.

+
Returns
The identifier of the block.
+ +

Definition at line 197 of file BlockCutTree.hpp.

+ +
+
+ +

◆ IsBridge()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
bool egoa::BlockCutTree< GraphType >::Block::IsBridge () const
+ 		+inline
+
+ +

Whether the block is a bridge.

+

Bridges are blocks that consist of only one edge.

+
Returns
true if the block represents a bridge, false otherwise.
+ +

Definition at line 235 of file BlockCutTree.hpp.

+ +

References egoa::Subgraph< GraphType >::Edges(), and egoa::BlockCutTree< GraphType >::Block::Subgraph().

+ +
+
+ +

◆ IsLeaf()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
bool egoa::BlockCutTree< GraphType >::Block::IsLeaf () const
+ 		+inline
+
+ +

Whether the block is a leaf of the block-cut tree.

+
Returns
true if the block is a leaf, false otherwise.
+ +

Definition at line 224 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::Block::CutVertices().

+ +
+
+ +

◆ Subgraph()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
egoa::Subgraph< TGraph const > const & egoa::BlockCutTree< GraphType >::Block::Subgraph () const
+ 		+inline
+
+ +

The subgraph forming the block.

+
Returns
The subgraph forming the block.
+ +

Definition at line 206 of file BlockCutTree.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ egoa::internal::BlockCutTreeBuilder< TGraph >

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
friend class egoa::internal::BlockCutTreeBuilder< TGraph >
+ 		+friend
+
+ +

Definition at line 235 of file BlockCutTree.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ cutVertices_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<Types::vertexId> egoa::BlockCutTree< GraphType >::Block::cutVertices_
+ 		+private
+
+ +

Definition at line 245 of file BlockCutTree.hpp.

+ +
+
+ +

◆ identifier_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::blockId egoa::BlockCutTree< GraphType >::Block::identifier_
+ 		+private
+
+ +

Definition at line 242 of file BlockCutTree.hpp.

+ +
+
+ +

◆ parent_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::vertexId egoa::BlockCutTree< GraphType >::Block::parent_
+ 		+private
+
+ +

Definition at line 244 of file BlockCutTree.hpp.

+ +
+
+ +

◆ subgraph_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
egoa::Subgraph<TGraph const> egoa::BlockCutTree< GraphType >::Block::subgraph_
+ 		+private
+
+ +

Definition at line 243 of file BlockCutTree.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_1_1_cut_vertex-members.html b/classegoa_1_1_block_cut_tree_1_1_cut_vertex-members.html new file mode 100644 index 00000000..e79c5752 --- /dev/null +++ b/classegoa_1_1_block_cut_tree_1_1_cut_vertex-members.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BlockCutTree< GraphType >::CutVertex Member List
+
+
+ +

This is the complete list of members for egoa::BlockCutTree< GraphType >::CutVertex, including all inherited members.

+ + + + + + + + +
Blocks() constegoa::BlockCutTree< GraphType >::CutVertexinline
blocks_ (defined in egoa::BlockCutTree< GraphType >::CutVertex)egoa::BlockCutTree< GraphType >::CutVertexprivate
CutVertex() (defined in egoa::BlockCutTree< GraphType >::CutVertex)egoa::BlockCutTree< GraphType >::CutVertexinline
CutVertex(Types::vertexId identifier, std::vector< Types::blockId > blocks) (defined in egoa::BlockCutTree< GraphType >::CutVertex)egoa::BlockCutTree< GraphType >::CutVertexinline
egoa::internal::BlockCutTreeBuilder< TGraph > (defined in egoa::BlockCutTree< GraphType >::CutVertex)egoa::BlockCutTree< GraphType >::CutVertexfriend
Identifier() constegoa::BlockCutTree< GraphType >::CutVertexinline
identifier_ (defined in egoa::BlockCutTree< GraphType >::CutVertex)egoa::BlockCutTree< GraphType >::CutVertexprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_1_1_cut_vertex.html b/classegoa_1_1_block_cut_tree_1_1_cut_vertex.html new file mode 100644 index 00000000..1f32935b --- /dev/null +++ b/classegoa_1_1_block_cut_tree_1_1_cut_vertex.html @@ -0,0 +1,343 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BlockCutTree< GraphType >::CutVertex Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::BlockCutTree< GraphType >::CutVertex Class Reference
Block-cut tree related classes and functions
+
+
+ +

Class for cut-vertices. + More...

+ +

#include <BlockCutTree.hpp>

+ + + + + + + + + + +

+Public Member Functions

 CutVertex (Types::vertexId identifier, std::vector< Types::blockId > blocks)
 
Types::vertexId Identifier () const
 The vertex identifier.
 
std::vector< Types::blockId > const & Blocks () const
 The blocks the cut-vertex belongs to.
 
+ + + + + +

+Private Attributes

Types::vertexId identifier_
 
std::vector< Types::blockId > blocks_
 
+ + + +

+Friends

class egoa::internal::BlockCutTreeBuilder< TGraph >
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::BlockCutTree< GraphType >::CutVertex

Class for cut-vertices.

+ +

Definition at line 253 of file BlockCutTree.hpp.

+

Constructor & Destructor Documentation

+ +

◆ CutVertex() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
egoa::BlockCutTree< GraphType >::CutVertex::CutVertex ()
+ 		+inline
+
+ +

Definition at line 255 of file BlockCutTree.hpp.

+ +
+
+ +

◆ CutVertex() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BlockCutTree< GraphType >::CutVertex::CutVertex (Types::vertexId identifier,
std::vector< Types::blockId > blocks 
)
+ 		+inline
+
+ +

Definition at line 260 of file BlockCutTree.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Blocks()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
std::vector< Types::blockId > const & egoa::BlockCutTree< GraphType >::CutVertex::Blocks () const
+ 		+inline
+
+ +

The blocks the cut-vertex belongs to.

+
Returns
A vector containing the indentifiers of the blocks.
+ +

Definition at line 282 of file BlockCutTree.hpp.

+ +
+
+ +

◆ Identifier()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::BlockCutTree< GraphType >::CutVertex::Identifier () const
+ 		+inline
+
+ +

The vertex identifier.

+

This is the same identifier as in the underlying graph.

+
Returns
The vertex identifier.
+ +

Definition at line 273 of file BlockCutTree.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ egoa::internal::BlockCutTreeBuilder< TGraph >

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
friend class egoa::internal::BlockCutTreeBuilder< TGraph >
+ 		+friend
+
+ +

Definition at line 282 of file BlockCutTree.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ blocks_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<Types::blockId> egoa::BlockCutTree< GraphType >::CutVertex::blocks_
+ 		+private
+
+ +

Definition at line 290 of file BlockCutTree.hpp.

+ +
+
+ +

◆ identifier_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::vertexId egoa::BlockCutTree< GraphType >::CutVertex::identifier_
+ 		+private
+
+ +

Definition at line 289 of file BlockCutTree.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_traversal-members.html b/classegoa_1_1_block_cut_tree_traversal-members.html new file mode 100644 index 00000000..78ac6a8c --- /dev/null +++ b/classegoa_1_1_block_cut_tree_traversal-members.html @@ -0,0 +1,113 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BlockCutTreeTraversal< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::BlockCutTreeTraversal< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
bcTree_ (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >private
Block typedef (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >
BlockAt(Types::index identifier) const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inlineprivate
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree)egoa::BlockCutTreeTraversal< GraphType >inline
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, TNode root)egoa::BlockCutTreeTraversal< GraphType >inline
BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, CutVertex const &root)egoa::BlockCutTreeTraversal< GraphType >inline
CutVertex typedef (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >
CutVertexAt(Types::index identifier) const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inlineprivate
IsBlock(Types::index id) const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inlineprivate
IsCutVertex(Types::index id) const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inlineprivate
nodeStack_egoa::BlockCutTreeTraversal< GraphType >private
NodeToId(TNode const &node) const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inlineprivate
Root() (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inline
Root() const (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >inline
root_ (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >private
rootId_ (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >private
Run()egoa::BlockCutTreeTraversal< GraphType >inline
TGraph typedef (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >
TNode typedef (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >
TTree typedef (defined in egoa::BlockCutTreeTraversal< GraphType >)egoa::BlockCutTreeTraversal< GraphType >
VisitBlock(Block const &block)egoa::BlockCutTreeTraversal< GraphType >inlineprotectedvirtual
VisitCutVertex(CutVertex const &cutVertex)egoa::BlockCutTreeTraversal< GraphType >inlineprotectedvirtual
visited_egoa::BlockCutTreeTraversal< GraphType >private
VisitLeaf(Block const &block)egoa::BlockCutTreeTraversal< GraphType >inlineprotectedvirtual
VisitRoot(TNode root)egoa::BlockCutTreeTraversal< GraphType >inlineprotectedvirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_block_cut_tree_traversal.html b/classegoa_1_1_block_cut_tree_traversal.html new file mode 100644 index 00000000..83d29e6e --- /dev/null +++ b/classegoa_1_1_block_cut_tree_traversal.html @@ -0,0 +1,961 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BlockCutTreeTraversal< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +List of all members
+
egoa::BlockCutTreeTraversal< GraphType > Class Template Reference
Block-cut tree related classes and functions
+
+
+ +

Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited. + More...

+ +

#include <BlockCutTreeTraversal.hpp>

+ + + + + + + + + + + + +

+Public Types

using TGraph = GraphType
 
using TTree = BlockCutTree< TGraph >
 
using Block = typename TTree::Block
 
using CutVertex = typename TTree::CutVertex
 
using TNode = std::variant< std::reference_wrapper< Block const >, std::reference_wrapper< CutVertex const > >
 
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors
 BlockCutTreeTraversal (BlockCutTree< TGraph > const &bcTree)
 A constructor.
 
 BlockCutTreeTraversal (BlockCutTree< TGraph > const &bcTree, TNode root)
 A constructor.
 
 BlockCutTreeTraversal (BlockCutTree< TGraph > const &bcTree, CutVertex const &root)
 A constructor.
 
Accessors
TNode & Root ()
 
TNode const & Root () const
 
Algorithm Execution
void Run ()
 Runs the algorithm.
 
+ + + + + + + + + + + + + + +

+Protected Member Functions

Visiting
virtual void VisitLeaf (Block const &block)
 This function is called for each leaf.
 
virtual void VisitCutVertex (CutVertex const &cutVertex)
 This function is called for each cut-vertex.
 
virtual void VisitBlock (Block const &block)
 This function is called for each inner block.
 
virtual void VisitRoot (TNode root)
 This function is called for the root.
 
+ + + + + + + + + + + + +

+Private Member Functions

Auxiliary
bool IsBlock (Types::index id) const
 
bool IsCutVertex (Types::index id) const
 
Types::index NodeToId (TNode const &node) const
 
Block const & BlockAt (Types::index identifier) const
 
CutVertex const & CutVertexAt (Types::index identifier) const
 
+ + + + + + + + + + + + + + + +

+Private Attributes

Input Members
BlockCutTree< TGraph > const & bcTree_
 
TNode root_
 
Types::index rootId_
 
Members for Traversal
std::stack< Types::index, std::vector< Types::index > > nodeStack_
 The identifiers of the nodes on the stack.
 
std::vector< bool > visited_ = std::vector<bool>(bcTree_.Graph().NumberOfVertices() + bcTree_.NumberOfBlocks(), false)
 Whether the node with the given identifier has been visited.
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::BlockCutTreeTraversal< GraphType >

Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited.

+

This base implementation does nothing for each node. To do something useful, implement the corresponding member function:

    +
  • VisitLeaf
    • +
  • VisitCutVertex
    • +
  • VisitBlock
    • +
  • VisitRoot
    • +
+
Template Parameters
+ + +
GraphTypeThe type of the graph for which the block-cut tree was computed.
+
+
+ +

Definition at line 39 of file BlockCutTreeTraversal.hpp.

+

Member Typedef Documentation

+ +

◆ Block

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTreeTraversal< GraphType >::Block = typename TTree::Block
+
+ +

Definition at line 43 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ CutVertex

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTreeTraversal< GraphType >::CutVertex = typename TTree::CutVertex
+
+ +

Definition at line 44 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTreeTraversal< GraphType >::TGraph = GraphType
+
+ +

Definition at line 41 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ TNode

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTreeTraversal< GraphType >::TNode = std::variant<std::reference_wrapper<Block const>, std::reference_wrapper<CutVertex const> >
+
+ +

Definition at line 45 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ TTree

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::BlockCutTreeTraversal< GraphType >::TTree = BlockCutTree<TGraph>
+
+ +

Definition at line 42 of file BlockCutTreeTraversal.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BlockCutTreeTraversal() [1/3]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
egoa::BlockCutTreeTraversal< GraphType >::BlockCutTreeTraversal (BlockCutTree< TGraph > const & bcTree)
+ 		+inline
+
+ +

A constructor.

+

The root is set to the first block.

+
Parameters
+ + + +
bcTreeThe block-cut tree.
visitorThe visitor.
+
+
+ +

Definition at line 60 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ BlockCutTreeTraversal() [2/3]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BlockCutTreeTraversal< GraphType >::BlockCutTreeTraversal (BlockCutTree< TGraph > const & bcTree,
TNode root 
)
+ 		+inline
+
+ +

A constructor.

+
Parameters
+ + + + +
bcTreeThe block-cut tree.
rootThe root.
visitorThe visitor.
+
+
+ +

Definition at line 71 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ BlockCutTreeTraversal() [3/3]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BlockCutTreeTraversal< GraphType >::BlockCutTreeTraversal (BlockCutTree< TGraph > const & bcTree,
CutVertex const & root 
)
+ 		+inline
+
+ +

A constructor.

+
Parameters
+ + + + +
bcTreeThe block-cut tree.
rootThe root.
visitorThe visitor.
+
+
+ +

Definition at line 85 of file BlockCutTreeTraversal.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ BlockAt()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
Block const & egoa::BlockCutTreeTraversal< GraphType >::BlockAt (Types::index identifier) const
+ 		+inlineprivate
+
+ +

Definition at line 221 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ CutVertexAt()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
CutVertex const & egoa::BlockCutTreeTraversal< GraphType >::CutVertexAt (Types::index identifier) const
+ 		+inlineprivate
+
+ +

Definition at line 226 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ IsBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
bool egoa::BlockCutTreeTraversal< GraphType >::IsBlock (Types::index id) const
+ 		+inlineprivate
+
+ +

Definition at line 202 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ IsCutVertex()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
bool egoa::BlockCutTreeTraversal< GraphType >::IsCutVertex (Types::index id) const
+ 		+inlineprivate
+
+ +

Definition at line 207 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ NodeToId()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
Types::index egoa::BlockCutTreeTraversal< GraphType >::NodeToId (TNode const & node) const
+ 		+inlineprivate
+
+ +

Definition at line 212 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ Root() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TNode & egoa::BlockCutTreeTraversal< GraphType >::Root ()
+ 		+inline
+
+ +

Definition at line 95 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ Root() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TNode const & egoa::BlockCutTreeTraversal< GraphType >::Root () const
+ 		+inline
+
+ +

Definition at line 99 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
void egoa::BlockCutTreeTraversal< GraphType >::Run ()
+ 		+inline
+
+ +

Runs the algorithm.

+ +

Definition at line 110 of file BlockCutTreeTraversal.hpp.

+ +

References egoa::BlockCutTree< GraphType >::Graph(), egoa::BlockCutTreeTraversal< GraphType >::nodeStack_, egoa::BlockCutTreeTraversal< GraphType >::VisitBlock(), egoa::BlockCutTreeTraversal< GraphType >::VisitCutVertex(), egoa::BlockCutTreeTraversal< GraphType >::visited_, egoa::BlockCutTreeTraversal< GraphType >::VisitLeaf(), and egoa::BlockCutTreeTraversal< GraphType >::VisitRoot().

+ +
+
+ +

◆ VisitBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::BlockCutTreeTraversal< GraphType >::VisitBlock (Block const & block)
+ 		+inlineprotectedvirtual
+
+ +

This function is called for each inner block.

+

This function is not called for the root even if the root is a block.

+
Parameters
+ + +
blockThe block.
+
+
+ +

Definition at line 187 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ VisitCutVertex()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::BlockCutTreeTraversal< GraphType >::VisitCutVertex (CutVertex const & cutVertex)
+ 		+inlineprotectedvirtual
+
+ +

This function is called for each cut-vertex.

+

This function is not called for the root even if the root is a cut-vertex.

+
Parameters
+ + +
cutVertexThe cut-vertex.
+
+
+ +

Definition at line 177 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ VisitLeaf()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::BlockCutTreeTraversal< GraphType >::VisitLeaf (Block const & block)
+ 		+inlineprotectedvirtual
+
+ +

This function is called for each leaf.

+

VisitBlock is not called for the block. This function is not called for the root even if the root has degree 1.

+
Parameters
+ + +
blockThe block.
+
+
+ +

Definition at line 167 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ VisitRoot()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::BlockCutTreeTraversal< GraphType >::VisitRoot (TNode root)
+ 		+inlineprotectedvirtual
+
+ +

This function is called for the root.

+
Parameters
+ + +
rootThe root.
+
+
+ +

Definition at line 194 of file BlockCutTreeTraversal.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ bcTree_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
BlockCutTree<TGraph> const& egoa::BlockCutTreeTraversal< GraphType >::bcTree_
+ 		+private
+
+ +

Definition at line 235 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ nodeStack_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::stack<Types::index, std::vector<Types::index> > egoa::BlockCutTreeTraversal< GraphType >::nodeStack_
+ 		+private
+
+ +

The identifiers of the nodes on the stack.

+

To distiguish between block and cut-vertex identifiers, the block identifiers have an added offset of bcTree_.Graph().NumberOfVertices().

+ +

Definition at line 250 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ root_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
TNode egoa::BlockCutTreeTraversal< GraphType >::root_
+ 		+private
+
+ +

Definition at line 236 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ rootId_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::index egoa::BlockCutTreeTraversal< GraphType >::rootId_
+ 		+private
+
+ +

Definition at line 237 of file BlockCutTreeTraversal.hpp.

+ +
+
+ +

◆ visited_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<bool> egoa::BlockCutTreeTraversal< GraphType >::visited_ = std::vector<bool>(bcTree_.Graph().NumberOfVertices() + bcTree_.NumberOfBlocks(), false)
+ 		+private
+
+ +

Whether the node with the given identifier has been visited.

+ +

Definition at line 254 of file BlockCutTreeTraversal.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bound-members.html b/classegoa_1_1_bound-members.html new file mode 100644 index 00000000..6fad5055 --- /dev/null +++ b/classegoa_1_1_bound-members.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Bound< BoundType > Member List
+
+
+ +

This is the complete list of members for egoa::Bound< BoundType >, including all inherited members.

+ + + + + + + + + + + + + +
Bound()=delete (defined in egoa::Bound< BoundType >)egoa::Bound< BoundType >
Bound(TBound const &minimum, TBound const &maximum)egoa::Bound< BoundType >inline
Maximum() constegoa::Bound< BoundType >inline
Maximum()egoa::Bound< BoundType >inline
maximum_egoa::Bound< BoundType >private
Minimum() constegoa::Bound< BoundType >inline
Minimum()egoa::Bound< BoundType >inline
minimum_egoa::Bound< BoundType >private
operator!=(Bound< TBound > const &rhs) const (defined in egoa::Bound< BoundType >)egoa::Bound< BoundType >inline
operator==(Bound< TBound > const &rhs) constegoa::Bound< BoundType >inline
Range(TBound const &minimum, TBound const &maximum)egoa::Bound< BoundType >inline
TBound typedefegoa::Bound< BoundType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bound.html b/classegoa_1_1_bound.html new file mode 100644 index 00000000..adf76a2b --- /dev/null +++ b/classegoa_1_1_bound.html @@ -0,0 +1,549 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Bound< BoundType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::Bound< BoundType > Class Template Reference
+
+
+ +

Class for bounds. + More...

+ +

#include <Bound.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 Bound (TBound const &minimum, TBound const &maximum)
 Constructs the object.
 
Getter and Setter
TBound Minimum () const
 Getter of the minimum of the bound.
 
TBound & Minimum ()
 Setter of the minimum of the bound.
 
TBound Maximum () const
 Getter of the maximum of the bound.
 
TBound & Maximum ()
 Setter of the maximum of the bound.
 
Modifier
void Range (TBound const &minimum, TBound const &maximum)
 Set the range of the bound.
 
Comparators
bool operator== (Bound< TBound > const &rhs) const
 Comparison operator.
 
bool operator!= (Bound< TBound > const &rhs) const
 
+ + + +

+Private Types

using TBound = BoundType
 
+ + + + + + +

+Private Attributes

Members
TBound minimum_
 
TBound maximum_
 
+

Detailed Description

+
template<typename BoundType = double>
+class egoa::Bound< BoundType >

Class for bounds.

+
Template Parameters
+ + +
BoundTypeThe type of the lower and upper bounds.
+
+
+ +

Definition at line 22 of file Bound.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + +
using egoa::Bound< BoundType >::TBound = BoundType
+ 		+private
+
+

The bound type, e.g., int.

+ +

Definition at line 25 of file Bound.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Bound()

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Bound< BoundType >::Bound (TBound< BoundType > const & minimum,
TBound< BoundType > const & maximum 
)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + + +
[in]minimumThe minimum representing the lower bound.
[in]maximumThe maximum representing the upper bound.
+
+
+ +

Definition at line 40 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::maximum_, and egoa::Bound< BoundType >::minimum_.

+ +
+
+

Member Function Documentation

+ +

◆ Maximum() [1/2]

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + +
TBound & egoa::Bound< BoundType >::Maximum ()
+ 		+inline
+
+ +

Setter of the maximum of the bound.

+
someBound.Maximum() = 99;
+
Returns
The maximum of the bound, i.e., upper bound.
+ +

Definition at line 99 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::maximum_.

+ +
+
+ +

◆ Maximum() [2/2]

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + +
TBound egoa::Bound< BoundType >::Maximum () const
+ 		+inline
+
+ +

Getter of the maximum of the bound.

+
Returns
The maximum of the bound, i.e., upper bound.
+ +

Definition at line 85 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::maximum_.

+ +
+
+ +

◆ Minimum() [1/2]

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + +
TBound & egoa::Bound< BoundType >::Minimum ()
+ 		+inline
+
+ +

Setter of the minimum of the bound.

+
someBound.Minimum() = 9;
+
Returns
The minimum of the bound, i.e., lower bound.
+ +

Definition at line 75 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::minimum_.

+ +
+
+ +

◆ Minimum() [2/2]

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + +
TBound egoa::Bound< BoundType >::Minimum () const
+ 		+inline
+
+ +

Getter of the minimum of the bound.

+
Returns
The minimum of the bound, i.e., lower bound.
+ +

Definition at line 61 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::minimum_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + + +
bool egoa::Bound< BoundType >::operator!= (Bound< TBound< BoundType > > const & rhs) const
+ 		+inline
+
+ +

Definition at line 150 of file Bound.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + + +
bool egoa::Bound< BoundType >::operator== (Bound< TBound< BoundType > > const & rhs) const
+ 		+inline
+
+ +

Comparison operator.

+
Parameters
+ + +
[in]rhsThe right hand side Bound.
+
+
+
if ( Bound<int>(0,0) == Bound<int>(1,0) ) { }
+
egoa::Bound
Class for bounds.
Definition Bound.hpp:22
+
Returns
True if both bounds are equal, False otherwise.
+ +

Definition at line 144 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::Maximum(), and egoa::Bound< BoundType >::Minimum().

+ +
+
+ +

◆ Range()

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::Bound< BoundType >::Range (TBound< BoundType > const & minimum,
TBound< BoundType > const & maximum 
)
+ 		+inline
+
+ +

Set the range of the bound.

+
Parameters
+ + + +
[in]minimumThe minimum of the bound, i.e., lower bound.
[in]maximumThe maximum of the bound, i.e., upper bound.
+
+
+ +

Definition at line 115 of file Bound.hpp.

+ +

References egoa::Bound< BoundType >::maximum_, and egoa::Bound< BoundType >::minimum_.

+ +
+
+

Member Data Documentation

+ +

◆ maximum_

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + +
TBound egoa::Bound< BoundType >::maximum_
+ 		+private
+
+

The maximum of the bound representing the upper bound.

+ +

Definition at line 162 of file Bound.hpp.

+ +
+
+ +

◆ minimum_

+ +
+
+
+template<typename BoundType = double>
+ + + + + +
+ + + + +
TBound egoa::Bound< BoundType >::minimum_
+ 		+private
+
+

The minimum of the bound representing the lower bound.

+ +

Definition at line 161 of file Bound.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bound_mismatch-members.html b/classegoa_1_1_bound_mismatch-members.html new file mode 100644 index 00000000..75c3f5ad --- /dev/null +++ b/classegoa_1_1_bound_mismatch-members.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BoundMismatch Member List
+
+
+ +

This is the complete list of members for egoa::BoundMismatch, including all inherited members.

+ + + + + + + + + + + + +
BoundMismatch(std::string msg, T minimum, T maximum)egoa::BoundMismatchinline
BoundMismatch(T minimum, T maximum) (defined in egoa::BoundMismatch)egoa::BoundMismatchinline
Check(const T2 &minimum, const T2 &maximum) (defined in egoa::BoundMismatch)egoa::BoundMismatchinlinestatic
Maximum() const (defined in egoa::BoundMismatch)egoa::BoundMismatchinline
Maximum() (defined in egoa::BoundMismatch)egoa::BoundMismatchinline
maximum_ (defined in egoa::BoundMismatch)egoa::BoundMismatchprivate
Minimum() const (defined in egoa::BoundMismatch)egoa::BoundMismatchinline
Minimum() (defined in egoa::BoundMismatch)egoa::BoundMismatchinline
minimum_ (defined in egoa::BoundMismatch)egoa::BoundMismatchprivate
T typedef (defined in egoa::BoundMismatch)egoa::BoundMismatchprivate
What() const (defined in egoa::BoundMismatch)egoa::BoundMismatchinlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bound_mismatch.html b/classegoa_1_1_bound_mismatch.html new file mode 100644 index 00000000..e75bb1cc --- /dev/null +++ b/classegoa_1_1_bound_mismatch.html @@ -0,0 +1,481 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BoundMismatch Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Private Types | +Private Attributes | +List of all members
+
egoa::BoundMismatch Class Reference
+
+
+
+Inheritance diagram for egoa::BoundMismatch:
+
+
+ +
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 BoundMismatch (std::string msg, T minimum, T maximum)
 constructor only which passes message to base class
 
 BoundMismatch (T minimum, T maximum)
 
T Minimum () const
 
T & Minimum ()
 
T Maximum () const
 
T & Maximum ()
 
virtual Types::string What () const throw ()
 
+ + + + +

+Static Public Member Functions

template<typename T2 = double>
static T2 Check (const T2 &minimum, const T2 &maximum)
 
+ + + +

+Private Types

typedef double T
 
+ + + + + +

+Private Attributes

double minimum_
 
double maximum_
 
+

Detailed Description

+
+

Definition at line 35 of file Exceptions.hpp.

+

Member Typedef Documentation

+ +

◆ T

+ +
+
+ + + + + +
+ + + + +
typedef double egoa::BoundMismatch::T
+ 		+private
+
+ +

Definition at line 36 of file Exceptions.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BoundMismatch() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::BoundMismatch::BoundMismatch (std::string msg,
T minimum,
T maximum 
)
+ 		+inline
+
+ +

constructor only which passes message to base class

+ +

Definition at line 39 of file Exceptions.hpp.

+ +
+
+ +

◆ BoundMismatch() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BoundMismatch::BoundMismatch (T minimum,
T maximum 
)
+ 		+inline
+
+ +

Definition at line 42 of file Exceptions.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Check()

+ +
+
+
+template<typename T2 = double>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static T2 egoa::BoundMismatch::Check (const T2 & minimum,
const T2 & maximum 
)
+ 		+inlinestatic
+
+ +

Definition at line 54 of file Exceptions.hpp.

+ +
+
+ +

◆ Maximum() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
T & egoa::BoundMismatch::Maximum ()
+ 		+inline
+
+ +

Definition at line 51 of file Exceptions.hpp.

+ +
+
+ +

◆ Maximum() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
T egoa::BoundMismatch::Maximum () const
+ 		+inline
+
+ +

Definition at line 50 of file Exceptions.hpp.

+ +
+
+ +

◆ Minimum() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
T & egoa::BoundMismatch::Minimum ()
+ 		+inline
+
+ +

Definition at line 48 of file Exceptions.hpp.

+ +
+
+ +

◆ Minimum() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
T egoa::BoundMismatch::Minimum () const
+ 		+inline
+
+ +

Definition at line 47 of file Exceptions.hpp.

+ +
+
+ +

◆ What()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + +
virtual Types::string egoa::BoundMismatch::What () const
throw (
)
+ 		+inlinevirtual
+
+ +

Definition at line 62 of file Exceptions.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ maximum_

+ +
+
+ + + + + +
+ + + + +
double egoa::BoundMismatch::maximum_
+ 		+private
+
+ +

Definition at line 74 of file Exceptions.hpp.

+ +
+
+ +

◆ minimum_

+ +
+
+ + + + + +
+ + + + +
double egoa::BoundMismatch::minimum_
+ 		+private
+
+ +

Definition at line 73 of file Exceptions.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bound_mismatch.png b/classegoa_1_1_bound_mismatch.png new file mode 100644 index 00000000..9cf49cce Binary files /dev/null and b/classegoa_1_1_bound_mismatch.png differ diff --git a/classegoa_1_1_bucket-members.html b/classegoa_1_1_bucket-members.html new file mode 100644 index 00000000..8f4dd7f6 --- /dev/null +++ b/classegoa_1_1_bucket-members.html @@ -0,0 +1,132 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Bucket< PriorityQueue > Member List
+
+
+ +

This is the complete list of members for egoa::Bucket< PriorityQueue >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Bucket()egoa::Bucket< PriorityQueue >inline
Clear() noexceptegoa::Bucket< PriorityQueue >inline
Comparator() const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
Comparator(std::function< bool(TElement const &, TElement const &)> comparator) (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
DeleteTop()egoa::Bucket< PriorityQueue >inline
Dominates(TElement const &lhs, TElement const &rhs) constegoa::Bucket< PriorityQueue >inlineprivate
ElementAt(Types::index index)egoa::Bucket< PriorityQueue >inline
Empty() constegoa::Bucket< PriorityQueue >inline
EmptyQueue() constegoa::Bucket< PriorityQueue >inline
for_all_elements(FUNCTION function)egoa::Bucket< PriorityQueue >inline
for_all_elements(FUNCTION function) constegoa::Bucket< PriorityQueue >inline
for_all_optima(FUNCTION function)egoa::Bucket< PriorityQueue >inline
for_all_optima(FUNCTION function) constegoa::Bucket< PriorityQueue >inline
for_all_processed_elements(FUNCTION function)egoa::Bucket< PriorityQueue >inline
for_all_processed_elements(FUNCTION function) constegoa::Bucket< PriorityQueue >inline
for_all_unprocessed_elements(FUNCTION function)egoa::Bucket< PriorityQueue >inline
for_all_unprocessed_elements(FUNCTION function) constegoa::Bucket< PriorityQueue >inline
HasElement(TElement const &newElement, TElement &existingElement)egoa::Bucket< PriorityQueue >inline
HasElementAt(Types::index index)egoa::Bucket< PriorityQueue >inline
Insert(TElement &&element)egoa::Bucket< PriorityQueue >inlineprivate
Merge(TElement &&newElement) (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
Merge(TElement &newElement) (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
Merge(TElement const &newElement) (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
MoveToProcessed(TElement &&element)egoa::Bucket< PriorityQueue >inlineprivate
NumberOfProcessedElements() const noexceptegoa::Bucket< PriorityQueue >inlineprivate
NumberOfUnprocessedElements() const noexceptegoa::Bucket< PriorityQueue >inlineprivate
numberOfValidUnprocessedElements_egoa::Bucket< PriorityQueue >private
operator<(TBucket const &rhs) const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
operator<=(TBucket const &rhs) const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
operator>(TBucket const &rhs) const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
operator>=(TBucket const &rhs) const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
operator[](Types::index index)egoa::Bucket< PriorityQueue >inline
operator[](Types::index index) constegoa::Bucket< PriorityQueue >inline
Optima() constegoa::Bucket< PriorityQueue >inline
Pop()egoa::Bucket< PriorityQueue >inline
PopInvalidUnprocessedElements()egoa::Bucket< PriorityQueue >inlineprivate
processedElements_egoa::Bucket< PriorityQueue >private
Size() const (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >inline
TBucket typedef (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >
TElement typedef (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >
TIterator typedef (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >
Top() constegoa::Bucket< PriorityQueue >inline
TPriorityQueue typedef (defined in egoa::Bucket< PriorityQueue >)egoa::Bucket< PriorityQueue >
unprocessedElements_egoa::Bucket< PriorityQueue >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bucket.html b/classegoa_1_1_bucket.html new file mode 100644 index 00000000..5019b6d8 --- /dev/null +++ b/classegoa_1_1_bucket.html @@ -0,0 +1,1926 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Bucket< PriorityQueue > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::Bucket< PriorityQueue > Class Template Reference
+
+
+ +

Class for bucket data structure. + More...

+ +

#include <Bucket.hpp>

+ + + + + + + + + + +

+Public Types

using TPriorityQueue = PriorityQueue
 
using TElement = typename TPriorityQueue::TElement
 
using TBucket = Bucket< TPriorityQueue >
 
using TIterator = std::iterator< std::input_iterator_tag, TElement, Types::largeNumber, Types::largeNumber const *, Types::largeNumber >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

bool HasElement (TElement const &newElement, TElement &existingElement)
 
void Clear () noexcept
 Clear the bucket.
 
bool Empty () const
 Determines if the bucket is empty.
 
bool EmptyQueue () const
 Determines if there are no unprocessed elements in the bucket.
 
Types::count Size () const
 
Constructors and Destructor
 Bucket ()
 Constructs the object.
 
Comparators for Unprocessed Bucket Elements
Parameters
+ + +
rhsThe right hand side bucket.
+
+
+
Precondition
Neither of the bucket queues is allowed to be empty. Check status of the queue by using EmptyQueue().
+
Returns
true if the element with an optimal key is <, >, <=, >= than the rhs bucket, false otherwise.
+
See also
EmptyQueue()
+
bool operator< (TBucket const &rhs) const
 
bool operator> (TBucket const &rhs) const
 
bool operator<= (TBucket const &rhs) const
 
bool operator>= (TBucket const &rhs) const
 
Merge an Element into the Bucket

Note that the valid flag for the processed labels might change in some special cases. However, this flag is ignored for processed labels.

+
Parameters
+ + +
newElementThe new element to merge into the bucket.
+
+
+
Precondition
Note that the element will be moved if the return type is true.
+
Template Parameters
+ + +
DominationThe domination sense such as weak, strict, or none.
+
+
+
Returns
true if the newElement is added into the bucket, false otherwise (meaning it was dominated in some sense defined by Domination).
+
template<DominationCriterion Domination = DominationCriterion::weak>
bool Merge (TElement &&newElement)
 
template<DominationCriterion Domination = DominationCriterion::weak>
bool Merge (TElement &newElement)
 
template<DominationCriterion Domination = DominationCriterion::weak>
bool Merge (TElement const &newElement)
 
Element Accessors
bool HasElementAt (Types::index index)
 Determines if it has a processed element at position index.
 
TElement & ElementAt (Types::index index)
 Processed element at a certain position index.
 
TElement & operator[] (Types::index index)
 Processed element at a certain position index.
 
TElement & operator[] (Types::index index) const
 Processed element at a certain position index.
 
TElement const & Top () const
 Returns the first valid and unprocessed element.
 
std::vector< TElement > Optima () const
 All elements with an optimum value.
 
Modifiers
Types::index Pop ()
 Pop the first valid element.
 
std::pair< TElement, Types::index > DeleteTop ()
 Delete and return the first valid element.
 
Comparator Accessors.
...
+
bucket_.Comparator( []( int a, int b ) { return a < b; } );
+
...
+
Precondition
If the comparator is changed to a non standard comparator you have to make sure that the elements comply these conditions, e.g., changing the comparator to "<" implicitly requires that no duplicates are allowed.
+
Returns
Comparator function pointer.
+
std::function< bool(TElement const &, TElement const &) > const & Comparator () const
 
void Comparator (std::function< bool(TElement const &, TElement const &)> comparator)
 
Element Loops
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_elements (FUNCTION function)
 The for loop over all elements in the bucket.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 The for loop over all elements in the bucket with const access.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_processed_elements (FUNCTION function)
 The for loop over all processed elements in the bucket.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_processed_elements (FUNCTION function) const
 The for loop over all processed elements in the bucket.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_unprocessed_elements (FUNCTION function)
 The for loop over all unprocessed elements in the bucket.
 
template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_unprocessed_elements (FUNCTION function) const
 The for loop over all unprocessed elements in the bucket.
 
template<ExecutionPolicy Policy, typename FUNCTION >
Types::real for_all_optima (FUNCTION function)
 The for loop over all elements with optimal value.
 
template<ExecutionPolicy Policy, typename FUNCTION >
Types::real for_all_optima (FUNCTION function) const
 The for loop over all elements with optimal value with const access.
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Add an Element
Types::index MoveToProcessed (TElement &&element)
 Move element to processed elements.
 
void Insert (TElement &&element)
 Insert an element.
 
Number of Elements
Types::count NumberOfProcessedElements () const noexcept
 Number of processed elements.
 
Types::count NumberOfUnprocessedElements () const noexcept
 Number of valid unprocessed elements.
 
Domination
template<DominationCriterion Domination>
bool Dominates (TElement const &lhs, TElement const &rhs) const
 Checks if lhs dominates rhs in a certain sense.
 
Ensuring Invariants
void PopInvalidUnprocessedElements ()
 Pops invalid unprocessed elements until unprocessedElements_ is empty or the top element is valid.
 
+ + + + + + + +

+Private Attributes

std::vector< TElement > processedElements_
 
TPriorityQueue unprocessedElements_
 
Types::count numberOfValidUnprocessedElements_
 
+

Detailed Description

+
template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+class egoa::Bucket< PriorityQueue >

Class for bucket data structure.

+
egoa::Bucket<egoa::BinaryHeap<int>, int> bucket;
+
egoa::Bucket
Class for bucket data structure.
Definition Bucket.hpp:65
+
Template Parameters
+ + +
PriorityQueueType of the priority queue used within the bucket, e.g., BinaryHeap. The PriorityQueue has to provide the following interface.
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Function Description
Top Returns the top element.
Search Search for the first match.
Insert, operator+=, Emplace Inserts one or more elements.
BuildWith Builds a heap.
DeleteTop, Pop Deletes the top element.
Clear Clears the heap.
ChangeKey Changes the key of one element.
DecreaseKey Decreases the key of an element.
Empty, Size Capacity operations.
Comparator, Maximize, Minimize Comparators.
operator==, operator!=, Equality operators.
+

IsEqualTo | swap | Swap two heaps. operator<< | Writes the heap into an output stream.

+ +

Definition at line 65 of file Bucket.hpp.

+

Member Typedef Documentation

+ +

◆ TBucket

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + +
using egoa::Bucket< PriorityQueue >::TBucket = Bucket< TPriorityQueue >
+
+ +

Definition at line 70 of file Bucket.hpp.

+ +
+
+ +

◆ TElement

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + +
using egoa::Bucket< PriorityQueue >::TElement = typename TPriorityQueue::TElement
+
+ +

Definition at line 69 of file Bucket.hpp.

+ +
+
+ +

◆ TIterator

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + +
using egoa::Bucket< PriorityQueue >::TIterator = std::iterator< std::input_iterator_tag , TElement , Types::largeNumber , Types::largeNumber const * , Types::largeNumber>
+
+ +

Definition at line 71 of file Bucket.hpp.

+ +
+
+ +

◆ TPriorityQueue

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + +
using egoa::Bucket< PriorityQueue >::TPriorityQueue = PriorityQueue
+
+ +

Definition at line 68 of file Bucket.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Bucket()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
egoa::Bucket< PriorityQueue >::Bucket ()
+ 		+inline
+
+ +

Constructs the object.

+ +

Definition at line 84 of file Bucket.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Clear()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
void egoa::Bucket< PriorityQueue >::Clear ()
+ 		+inlinenoexcept
+
+ +

Clear the bucket.

+ +

Definition at line 423 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::numberOfValidUnprocessedElements_, egoa::Bucket< PriorityQueue >::processedElements_, and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ Comparator() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
std::function< bool(TElement const &, TElement const &) > const & egoa::Bucket< PriorityQueue >::Comparator () const
+ 		+inline
+
+ +

Definition at line 451 of file Bucket.hpp.

+ +
+
+ +

◆ Comparator() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::Comparator (std::function< bool(TElement const &, TElement const &)> comparator)
+ 		+inline
+
+ +

Definition at line 456 of file Bucket.hpp.

+ +
+
+ +

◆ DeleteTop()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
std::pair< TElement, Types::index > egoa::Bucket< PriorityQueue >::DeleteTop ()
+ 		+inline
+
+ +

Delete and return the first valid element.

+

Returns the first unprocessed valid label and removes it from the set of unprocessed labels. The first unprocessed label is the one with the smallest key (e.g. for VoltageAngleDifferenceLabel the key would be the susceptance norm times the minimum capacity).

+
Precondition
The queue—meaning the unprocessed items—is not allowed to be empty.
+
Returns
The element with a optimal key.
+ +

Definition at line 410 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::EmptyQueue(), egoa::Bucket< PriorityQueue >::Pop(), and egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ Dominates()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<DominationCriterion Domination>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::Bucket< PriorityQueue >::Dominates (TElement const & lhs,
TElement const & rhs 
) const
+ 		+inlineprivate
+
+ +

Checks if lhs dominates rhs in a certain sense.

+
Parameters
+ + + +
lhsThe left hand side element.
rhsThe right hand side element.
+
+
+
Template Parameters
+ + +
DominationThe domination sense such as weak, strict, or none.
+
+
+
Returns
true if the lhs dominates the rhs, false otherwise.
+ +

Definition at line 770 of file Bucket.hpp.

+ +
+
+ +

◆ ElementAt()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
TElement & egoa::Bucket< PriorityQueue >::ElementAt (Types::index index)
+ 		+inline
+
+ +

Processed element at a certain position index.

+
Parameters
+ + +
[in]indexThe position of a processed element.
+
+
+
Precondition
There are processed elements and #HasElementAt( index ) is true.
+
Returns
The processed element at the position index.
+ +

Definition at line 258 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::HasElementAt(), egoa::Bucket< PriorityQueue >::NumberOfProcessedElements(), and egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
bool egoa::Bucket< PriorityQueue >::Empty () const
+ 		+inline
+
+ +

Determines if the bucket is empty.

+
Returns
true if empty, false otherwise.
+ +

Definition at line 469 of file Bucket.hpp.

+ +

References egoa::PriorityQueue< Type >::Empty(), egoa::Bucket< PriorityQueue >::processedElements_, and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ EmptyQueue()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
bool egoa::Bucket< PriorityQueue >::EmptyQueue () const
+ 		+inline
+
+ +

Determines if there are no unprocessed elements in the bucket.

+
Returns
true if empty, false otherwise.
+ +

Definition at line 479 of file Bucket.hpp.

+ +

References egoa::PriorityQueue< Type >::Empty(), and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ for_all_elements() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all elements in the bucket.

+

Loop over all processed and unprocessed elements.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 512 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::PopInvalidUnprocessedElements().

+ +
+
+ +

◆ for_all_elements() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all elements in the bucket with const access.

+

Loop over all processed and unprocessed elements.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement const & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 539 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_optima() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
Types::real egoa::Bucket< PriorityQueue >::for_all_optima (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all elements with optimal value.

+

Loop over all unprocessed elements having an optimal value.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 667 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_optima() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
Types::real egoa::Bucket< PriorityQueue >::for_all_optima (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all elements with optimal value with const access.

+

Loop over all unprocessed elements having an optimal value.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement const & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 693 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_processed_elements() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_processed_elements (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all processed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 563 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_processed_elements() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_processed_elements (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all processed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement const & element )
+
{
+
Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 587 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_unprocessed_elements() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_unprocessed_elements (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all unprocessed elements in the bucket.

+

If the function returns true the loop will be continued, if false this emulates a break.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 614 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::PopInvalidUnprocessedElements().

+ +
+
+ +

◆ for_all_unprocessed_elements() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::for_all_unprocessed_elements (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all unprocessed elements in the bucket.

+

If the function returns true the loop will be continued, if false this emulates a break.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement const & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 642 of file Bucket.hpp.

+ +
+
+ +

◆ HasElement()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::Bucket< PriorityQueue >::HasElement (TElement const & newElement,
TElement & existingElement 
)
+ 		+inline
+
+
Todo:
Think about it
+ +

Definition at line 208 of file Bucket.hpp.

+ +
+
+ +

◆ HasElementAt()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::HasElementAt (Types::index index)
+ 		+inline
+
+ +

Determines if it has a processed element at position index.

+
Parameters
+ + +
[in]indexThe position of an element
+
+
+
Returns
true if it has an element at that position, false otherwise.
+ +

Definition at line 242 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::NumberOfProcessedElements().

+ +
+
+ +

◆ Insert()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
void egoa::Bucket< PriorityQueue >::Insert (TElement && element)
+ 		+inlineprivate
+
+ +

Insert an element.

+
Parameters
+ + +
elementThe element.
+
+
+ +

Definition at line 726 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ Merge() [1/3]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<DominationCriterion Domination = DominationCriterion::weak>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::Merge (TElement && newElement)
+ 		+inline
+
+ +

Definition at line 158 of file Bucket.hpp.

+ +
+
+ +

◆ Merge() [2/3]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<DominationCriterion Domination = DominationCriterion::weak>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::Merge (TElement & newElement)
+ 		+inline
+
+ +

Definition at line 193 of file Bucket.hpp.

+ +
+
+ +

◆ Merge() [3/3]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+
+template<DominationCriterion Domination = DominationCriterion::weak>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::Merge (TElement const & newElement)
+ 		+inline
+
+ +

Definition at line 201 of file Bucket.hpp.

+ +
+
+ +

◆ MoveToProcessed()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
Types::index egoa::Bucket< PriorityQueue >::MoveToProcessed (TElement && element)
+ 		+inlineprivate
+
+ +

Move element to processed elements.

+

After moving it to the list of processed elements its identifier corresponds to the index.

+
Parameters
+ + +
elementThe element to move to unprocessed elements.
+
+
+
Precondition
Function
+
See also
Pop().
+ +

Definition at line 714 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ NumberOfProcessedElements()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
Types::count egoa::Bucket< PriorityQueue >::NumberOfProcessedElements () const
+ 		+inlineprivatenoexcept
+
+ +

Number of processed elements.

+
Returns
The number of processed elements.
+ +

Definition at line 740 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ NumberOfUnprocessedElements()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
Types::count egoa::Bucket< PriorityQueue >::NumberOfUnprocessedElements () const
+ 		+inlineprivatenoexcept
+
+ +

Number of valid unprocessed elements.

+
Returns
The number of valid unprocessed elements.
+ +

Definition at line 750 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::numberOfValidUnprocessedElements_.

+ +
+
+ +

◆ operator<()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::operator< (TBucket< PriorityQueue > const & rhs) const
+ 		+inline
+
+ +

Definition at line 109 of file Bucket.hpp.

+ +
+
+ +

◆ operator<=()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::operator<= (TBucket< PriorityQueue > const & rhs) const
+ 		+inline
+
+ +

Definition at line 123 of file Bucket.hpp.

+ +
+
+ +

◆ operator>()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::operator> (TBucket< PriorityQueue > const & rhs) const
+ 		+inline
+
+ +

Definition at line 116 of file Bucket.hpp.

+ +
+
+ +

◆ operator>=()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
bool egoa::Bucket< PriorityQueue >::operator>= (TBucket< PriorityQueue > const & rhs) const
+ 		+inline
+
+ +

Definition at line 130 of file Bucket.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
TElement & egoa::Bucket< PriorityQueue >::operator[] (Types::index index)
+ 		+inline
+
+ +

Processed element at a certain position index.

+
Parameters
+ + +
[in]indexThe position of a processed element.
+
+
+
Precondition
There are processed elements and #HasElementAt( index ) is true.
+
Returns
The processed element at the position index.
+ +

Definition at line 277 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::HasElementAt(), egoa::Bucket< PriorityQueue >::NumberOfProcessedElements(), and egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + + +
TElement & egoa::Bucket< PriorityQueue >::operator[] (Types::index index) const
+ 		+inline
+
+ +

Processed element at a certain position index.

+
Parameters
+ + +
[in]indexThe position of a processed element.
+
+
+
Precondition
There are processed elements and #HasElementAt( index ) is true.
+
Returns
The processed element at the position index.
+ +

Definition at line 296 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::HasElementAt(), egoa::Bucket< PriorityQueue >::NumberOfProcessedElements(), and egoa::Bucket< PriorityQueue >::processedElements_.

+ +
+
+ +

◆ Optima()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
std::vector< TElement > egoa::Bucket< PriorityQueue >::Optima () const
+ 		+inline
+
+ +

All elements with an optimum value.

+

Get all elements that have an optimum value, e.g. for the VoltageAngleDifferenceLabel an optimum corresponds to the minimum delta theta value of the path.

+
Note
This function does not change the bucket. All elements stay in the queue. The equality check depends on the element equality check.
+
Todo:
Is this loop sufficient for unprocessed labels only?
+
Returns
Vector of elements with optimum value
+ +

Definition at line 336 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::processedElements_, and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ Pop()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
Types::index egoa::Bucket< PriorityQueue >::Pop ()
+ 		+inline
+
+ +

Pop the first valid element.

+

Returns the first unprocessed valid label and removes it from the set of unprocessed labels. The first unprocessed label is the one with the smallest key (e.g. for VoltageAngleDifferenceLabel the key would be the susceptance norm).

+
Precondition
The queue—meaning the unprocessed items—is not allowed to be empty.
+
Returns
The element with a optimal key.
+ +

Definition at line 385 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::EmptyQueue(), egoa::Bucket< PriorityQueue >::MoveToProcessed(), egoa::Bucket< PriorityQueue >::numberOfValidUnprocessedElements_, egoa::Bucket< PriorityQueue >::PopInvalidUnprocessedElements(), and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ PopInvalidUnprocessedElements()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
void egoa::Bucket< PriorityQueue >::PopInvalidUnprocessedElements ()
+ 		+inlineprivate
+
+ +

Pops invalid unprocessed elements until unprocessedElements_ is empty or the top element is valid.

+ +

Definition at line 785 of file Bucket.hpp.

+ +

References egoa::PriorityQueue< Type >::Empty(), egoa::PriorityQueue< Type >::Top(), and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+ +

◆ Size()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
Types::count egoa::Bucket< PriorityQueue >::Size () const
+ 		+inline
+
+ +

Definition at line 484 of file Bucket.hpp.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + + + + +
TElement const & egoa::Bucket< PriorityQueue >::Top () const
+ 		+inline
+
+ +

Returns the first valid and unprocessed element.

+

Top returns an unprocessed element that has an optimal key (e.g. for VoltageAngleDifferenceLabel the key would be the susceptance norm).

+
Precondition
The queue is not empty meaning EmptyQueue() is false.
+
Returns
The element with an optimal key.
+ +

Definition at line 315 of file Bucket.hpp.

+ +

References egoa::Bucket< PriorityQueue >::EmptyQueue(), egoa::PriorityQueue< Type >::Top(), and egoa::Bucket< PriorityQueue >::unprocessedElements_.

+ +
+
+

Member Data Documentation

+ +

◆ numberOfValidUnprocessedElements_

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + +
Types::count egoa::Bucket< PriorityQueue >::numberOfValidUnprocessedElements_
+ 		+private
+
+

The number of valid unprocessed elements.

+ +

Definition at line 806 of file Bucket.hpp.

+ +
+
+ +

◆ processedElements_

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + +
std::vector<TElement> egoa::Bucket< PriorityQueue >::processedElements_
+ 		+private
+
+

The processed elements that do not change their status and stay valid

+ +

Definition at line 804 of file Bucket.hpp.

+ +
+
+ +

◆ unprocessedElements_

+ +
+
+
+template<typename PriorityQueue = BinaryHeap<VoltageAngleDifferenceLabel<Edges::Edge<Edges::ElectricalProperties> > >>
+ + + + + +
+ + + + +
TPriorityQueue egoa::Bucket< PriorityQueue >::unprocessedElements_
+ 		+private
+
+

The unprocessed elements that might change their status, e.g., to invalid

+ +

Definition at line 805 of file Bucket.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Bucket.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bucket_element-members.html b/classegoa_1_1_bucket_element-members.html new file mode 100644 index 00000000..66480e51 --- /dev/null +++ b/classegoa_1_1_bucket_element-members.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::BucketElement< ElementType > Member List
+
+
+ +

This is the complete list of members for egoa::BucketElement< ElementType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
BucketElement() (defined in egoa::BucketElement< ElementType >)egoa::BucketElement< ElementType >inline
BucketElement(TElement value, bool valid)egoa::BucketElement< ElementType >inline
BucketElement(TElement element)egoa::BucketElement< ElementType >inline
Index() constegoa::BucketElement< ElementType >inline
Index()egoa::BucketElement< ElementType >inline
index_egoa::BucketElement< ElementType >private
operator!=(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
operator+(TElement const &rhs) constegoa::BucketElement< ElementType >inline
operator+=(TElement const &rhs)egoa::BucketElement< ElementType >inline
operator<(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
operator<<egoa::BucketElement< ElementType >friend
operator<=(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
operator==(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
operator>(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
operator>=(BucketElement const &rhs) constegoa::BucketElement< ElementType >inline
TBucketElement typedef (defined in egoa::BucketElement< ElementType >)egoa::BucketElement< ElementType >
TElement typedef (defined in egoa::BucketElement< ElementType >)egoa::BucketElement< ElementType >
Valid() constegoa::BucketElement< ElementType >inline
Valid()egoa::BucketElement< ElementType >inline
valid_egoa::BucketElement< ElementType >private
Value() constegoa::BucketElement< ElementType >inline
Value()egoa::BucketElement< ElementType >inline
value_egoa::BucketElement< ElementType >private
~BucketElement()egoa::BucketElement< ElementType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_bucket_element.html b/classegoa_1_1_bucket_element.html new file mode 100644 index 00000000..fddbbdc2 --- /dev/null +++ b/classegoa_1_1_bucket_element.html @@ -0,0 +1,1044 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::BucketElement< ElementType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +Friends | +List of all members
+
egoa::BucketElement< ElementType > Class Template Reference
+
+
+ +

Class representing the minimal bucket element. + More...

+ +

#include <BucketElement.hpp>

+ + + + + + +

+Public Types

using TElement = ElementType
 
using TBucketElement = BucketElement< TElement >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and destructor
 BucketElement (TElement value, bool valid)
 Constructs the BucketElement object.
 
 BucketElement (TElement element)
 Constructs the object.
 
 ~BucketElement ()
 Destroys the BucketElement object.
 
Domination Operators
bool operator< (BucketElement const &rhs) const
 Strict domination using less than.
 
bool operator<= (BucketElement const &rhs) const
 Weak domination using less or equal than.
 
bool operator> (BucketElement const &rhs) const
 Strict domination using greater than.
 
bool operator>= (BucketElement const &rhs) const
 Weak domination using greater or equal than.
 
Comparison Operators
bool operator== (BucketElement const &rhs) const
 Equality check.
 
bool operator!= (BucketElement const &rhs) const
 Inequality check.
 
Concatenation Operators
BucketElement & operator+= (TElement const &rhs)
 In place addition.
 
BucketElement operator+ (TElement const &rhs) const
 Adding an element to the BucketElement.
 
Getter and Setter
Types::labelId Index () const
 Getter for the identifier.
 
Types::labelId & Index ()
 Setter for the identifier.
 
bool Valid () const
 Getter for the valid flag.
 
bool & Valid ()
 Setter for the valid flag.
 
TElement Value () const
 Getter for the value of the BucketElement.
 
TElement & Value ()
 Setter for the value of the BucketElement.
 
+ + + + + + + +

+Private Attributes

Types::index index_
 
bool valid_
 
TElement value_
 
+ + + + +

+Friends

std::ostream & operator<< (std::ostream &os, BucketElement const &rhs)
 Output stream.
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::BucketElement< ElementType >

Class representing the minimal bucket element.

+

This is a wrapper that can be used to atomic elements to the bucket container. If you want to use more complex elements make sure the elements implement all comparison operators such as <, >, <=, >=, ==, and !=.

+
Template Parameters
+ + +
ElementTypeAtomic or complex element implementing comparison operators.
+
+
+
See also
Label representing a label interface.
+
+Bucket representing a bucket.
+ +

Definition at line 27 of file BucketElement.hpp.

+

Member Typedef Documentation

+ +

◆ TBucketElement

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BucketElement< ElementType >::TBucketElement = BucketElement<TElement>
+
+ +

Definition at line 31 of file BucketElement.hpp.

+ +
+
+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::BucketElement< ElementType >::TElement = ElementType
+
+ +

Definition at line 30 of file BucketElement.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BucketElement() [1/3]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
egoa::BucketElement< ElementType >::BucketElement ()
+ 		+inline
+
+ +

Definition at line 37 of file BucketElement.hpp.

+ +
+
+ +

◆ BucketElement() [2/3]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::BucketElement< ElementType >::BucketElement (TElement value,
bool valid 
)
+ 		+inline
+
+ +

Constructs the BucketElement object.

+
Parameters
+ + + +
[in]valueThe value.
[in]validThe information about the validity of this element.
+
+
+ +

Definition at line 48 of file BucketElement.hpp.

+ +
+
+ +

◆ BucketElement() [3/3]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
egoa::BucketElement< ElementType >::BucketElement (TElement element)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + +
[in]elementThe element.
+
+
+ +

Definition at line 60 of file BucketElement.hpp.

+ +
+
+ +

◆ ~BucketElement()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
egoa::BucketElement< ElementType >::~BucketElement ()
+ 		+inline
+
+ +

Destroys the BucketElement object.

+ +

Definition at line 67 of file BucketElement.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Index() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
Types::labelId & egoa::BucketElement< ElementType >::Index ()
+ 		+inline
+
+ +

Setter for the identifier.

+

This identifier is set while the element is moved to the processed elements in the bucket. Thus, the element will be fixed to this position.

+
this->Index() = 9;
+
egoa::BucketElement::Index
Types::labelId Index() const
Getter for the identifier.
Definition BucketElement.hpp:192
+
Returns
The BucketElement's identifier.
+ +

Definition at line 209 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::index_.

+ +
+
+ +

◆ Index() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
Types::labelId egoa::BucketElement< ElementType >::Index () const
+ 		+inline
+
+ +

Getter for the identifier.

+

This identifier represents the label's position, e.g., within the buckets processed elements.

+
Returns
The BucketElement's identifier.
+ +

Definition at line 192 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::index_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator!= (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Inequality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
True if lhs != rhs, False otherwise.
+ +

Definition at line 145 of file BucketElement.hpp.

+ +
+
+ +

◆ operator+()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
BucketElement egoa::BucketElement< ElementType >::operator+ (TElement const & rhs) const
+ 		+inline
+
+ +

Adding an element to the BucketElement.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
The BucketElement with added TElement.
+ +

Definition at line 174 of file BucketElement.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
BucketElement & egoa::BucketElement< ElementType >::operator+= (TElement const & rhs)
+ 		+inline
+
+ +

In place addition.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
The BucketElement with added TElement.
+ +

Definition at line 161 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::Value().

+ +
+
+ +

◆ operator<()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator< (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using less than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
True if lhs < rhs, False otherwise.
+ +

Definition at line 80 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::value_.

+ +
+
+ +

◆ operator<=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator<= (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using less or equal than.

+
Parameters
+ + +
rhsThe right hand side
+
+
+
Returns
True if lhs <= rhs, False otherwise.
+ +

Definition at line 92 of file BucketElement.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator== (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Equality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
True if lhs == rhs, False otherwise.
+ +

Definition at line 133 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::value_.

+ +
+
+ +

◆ operator>()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator> (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using greater than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
True if lhs > rhs, False otherwise.
+ +

Definition at line 104 of file BucketElement.hpp.

+ +
+
+ +

◆ operator>=()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
bool egoa::BucketElement< ElementType >::operator>= (BucketElement< ElementType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using greater or equal than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
True if lhs >= rhs, False otherwise.
+ +

Definition at line 116 of file BucketElement.hpp.

+ +
+
+ +

◆ Valid() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
bool & egoa::BucketElement< ElementType >::Valid ()
+ 		+inline
+
+ +

Setter for the valid flag.

+
this->Valid() = false;
+
egoa::BucketElement::Valid
bool Valid() const
Getter for the valid flag.
Definition BucketElement.hpp:219
+
Returns
True if the BucketElement is valid, false otherwise.
+ +

Definition at line 233 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::valid_.

+ +
+
+ +

◆ Valid() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
bool egoa::BucketElement< ElementType >::Valid () const
+ 		+inline
+
+ +

Getter for the valid flag.

+
Returns
True if the BucketElement is valid, false otherwise.
+ +

Definition at line 219 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::valid_.

+ +
+
+ +

◆ Value() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement & egoa::BucketElement< ElementType >::Value ()
+ 		+inline
+
+ +

Setter for the value of the BucketElement.

+
this->Value() = TElement();
+
egoa::BucketElement::Value
TElement Value() const
Getter for the value of the BucketElement.
Definition BucketElement.hpp:243
+
Returns
The value of the BucketElement.
+ +

Definition at line 257 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::value_.

+ +
+
+ +

◆ Value() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
TElement egoa::BucketElement< ElementType >::Value () const
+ 		+inline
+
+ +

Getter for the value of the BucketElement.

+
Returns
The value of the BucketElement.
+ +

Definition at line 243 of file BucketElement.hpp.

+ +

References egoa::BucketElement< ElementType >::value_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
BucketElement< ElementType > const & rhs 
)
+ 		+friend
+
+ +

Output stream.

+
Parameters
+ + + +
osThe output stream such as std::cout.
rhsThe right hand side BucketElement.
+
+
+
Returns
The output stream.
+ +

Definition at line 272 of file BucketElement.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ index_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
Types::index egoa::BucketElement< ElementType >::index_
+ 		+private
+
+

The BucketElement identifier.

+ +

Definition at line 280 of file BucketElement.hpp.

+ +
+
+ +

◆ valid_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
bool egoa::BucketElement< ElementType >::valid_
+ 		+private
+
+

The valid flag that is true if the bucket element is valid, false otherwise.

+ +

Definition at line 281 of file BucketElement.hpp.

+ +
+
+ +

◆ value_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
TElement egoa::BucketElement< ElementType >::value_
+ 		+private
+
+

The value of the BucketElement.

+ +

Definition at line 282 of file BucketElement.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_callback_empty-members.html b/classegoa_1_1_callback_empty-members.html new file mode 100644 index 00000000..9a31fd71 --- /dev/null +++ b/classegoa_1_1_callback_empty-members.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::CallbackEmpty< LoggingType > Member List
+
+
+ +

This is the complete list of members for egoa::CallbackEmpty< LoggingType >, including all inherited members.

+ + + + + + +
callback() overrideegoa::CallbackEmpty< LoggingType >inlineprivate
CallbackEmpty(TSolver *solver)egoa::CallbackEmpty< LoggingType >inline
solver_ (defined in egoa::CallbackEmpty< LoggingType >)egoa::CallbackEmpty< LoggingType >private
TLogging typedef (defined in egoa::CallbackEmpty< LoggingType >)egoa::CallbackEmpty< LoggingType >
TSolver typedef (defined in egoa::CallbackEmpty< LoggingType >)egoa::CallbackEmpty< LoggingType >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_callback_empty.html b/classegoa_1_1_callback_empty.html new file mode 100644 index 00000000..b3f29e05 --- /dev/null +++ b/classegoa_1_1_callback_empty.html @@ -0,0 +1,264 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::CallbackEmpty< LoggingType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Member Functions | +Private Attributes | +List of all members
+
egoa::CallbackEmpty< LoggingType > Class Template Reference
+
+
+
+Inheritance diagram for egoa::CallbackEmpty< LoggingType >:
+
+
+ +
+ + + + + + +

+Public Types

using TLogging = LoggingType
 
using TSolver = GurobiSolver< CallbackEmpty< TLogging > >
 
+ + + + +

+Public Member Functions

 CallbackEmpty (TSolver *solver)
 Constructs the object.
 
+ + + + +

+Private Member Functions

void callback () override
 Do nothing.
 
+ + + +

+Private Attributes

TSolver * solver_
 
+

Detailed Description

+
template<typename LoggingType>
+class egoa::CallbackEmpty< LoggingType >
+

Definition at line 20 of file CallbackEmpty.hpp.

+

Member Typedef Documentation

+ +

◆ TLogging

+ +
+
+
+template<typename LoggingType >
+ + + + +
using egoa::CallbackEmpty< LoggingType >::TLogging = LoggingType
+
+ +

Definition at line 22 of file CallbackEmpty.hpp.

+ +
+
+ +

◆ TSolver

+ +
+
+
+template<typename LoggingType >
+ + + + +
using egoa::CallbackEmpty< LoggingType >::TSolver = GurobiSolver<CallbackEmpty<TLogging> >
+
+ +

Definition at line 23 of file CallbackEmpty.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ CallbackEmpty()

+ +
+
+
+template<typename LoggingType >
+ + + + + +
+ + + + + + + + +
egoa::CallbackEmpty< LoggingType >::CallbackEmpty (TSolver * solver)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + +
solverThe solver
+
+
+ +

Definition at line 30 of file CallbackEmpty.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ callback()

+ +
+
+
+template<typename LoggingType >
+ + + + + +
+ + + + + + + +
void egoa::CallbackEmpty< LoggingType >::callback ()
+ 		+inlineoverrideprivate
+
+ +

Do nothing.

+ +

Definition at line 36 of file CallbackEmpty.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ solver_

+ +
+
+
+template<typename LoggingType >
+ + + + + +
+ + + + +
TSolver* egoa::CallbackEmpty< LoggingType >::solver_
+ 		+private
+
+ +

Definition at line 40 of file CallbackEmpty.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_callback_empty.png b/classegoa_1_1_callback_empty.png new file mode 100644 index 00000000..9147afd6 Binary files /dev/null and b/classegoa_1_1_callback_empty.png differ diff --git a/classegoa_1_1_color-members.html b/classegoa_1_1_color-members.html new file mode 100644 index 00000000..34349759 --- /dev/null +++ b/classegoa_1_1_color-members.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Color Member List
+
+
+ +

This is the complete list of members for egoa::Color, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
alpha_ (defined in egoa::Color)egoa::Colorprivate
Blue() const (defined in egoa::Color)egoa::Color
Blue(Types::ubyte blue) (defined in egoa::Color)egoa::Color
blue() const (defined in egoa::Color)egoa::Colorinline
blue() (defined in egoa::Color)egoa::Colorinline
blue_ (defined in egoa::Color)egoa::Colorprivate
Color(Types::real red=0.0, Types::real green=0.0, Types::real blue=0, Types::real alpha=0) (defined in egoa::Color)egoa::Colorinline
Color(Color::Name name) (defined in egoa::Color)egoa::Color
Green() const (defined in egoa::Color)egoa::Color
Green(Types::ubyte green) (defined in egoa::Color)egoa::Color
green() const (defined in egoa::Color)egoa::Colorinline
green() (defined in egoa::Color)egoa::Colorinline
green_ (defined in egoa::Color)egoa::Colorprivate
Hexadecimal() (defined in egoa::Color)egoa::Color
Name enum nameegoa::Color
operator!=(Color const &rhs) (defined in egoa::Color)egoa::Colorinline
operator<< (defined in egoa::Color)egoa::Colorfriend
operator==(Color const &rhs) (defined in egoa::Color)egoa::Colorinline
red() constegoa::Colorinline
red() (defined in egoa::Color)egoa::Colorinline
Red() const (defined in egoa::Color)egoa::Color
Red(Types::ubyte red) (defined in egoa::Color)egoa::Color
red_ (defined in egoa::Color)egoa::Colorprivate
~Color() (defined in egoa::Color)egoa::Colorinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_color.html b/classegoa_1_1_color.html new file mode 100644 index 00000000..79a967e7 --- /dev/null +++ b/classegoa_1_1_color.html @@ -0,0 +1,1449 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Color Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::Color Class Reference
+
+
+ +

#include <Color.hpp>

+ + + + +

+Public Types

enum class  Name {
+  KITgreen +, KITgreen70 +, KITgreen50 +, KITgreen30 +,
+  KITgreen15 +, KITblue +, KITblue70 +, KITblue50 +,
+  KITblue30 +, KITblue15 +, KITblack +, KITblack70 +,
+  KITblack50 +, KITblack32 +, KITblack31 +, KITblack30 +,
+  KITblack29 +, KITblack28 +, KITblack27 +, KITblack26 +,
+  KITblack25 +, KITblack24 +, KITblack23 +, KITblack22 +,
+  KITblack21 +, KITblack20 +, KITblack19 +, KITblack18 +,
+  KITblack17 +, KITblack16 +, KITblack15 +, KITblack14 +,
+  KITblack13 +, KITblack12 +, KITblack11 +, KITblack10 +,
+  KITblack09 +, KITblack08 +, KITblack07 +, KITblack06 +,
+  KITblack05 +, KITblack04 +, KITblack03 +, KITblack02 +,
+  KITblack01 +, KITpalegreen +, KITpalegreen70 +, KITpalegreen50 +,
+  KITpalegreen30 +, KITpalegreen15 +, KITyellow +, KITyellow70 +,
+  KITyellow50 +, KITyellow30 +, KITyellow15 +, KITorange +,
+  KITorange70 +, KITorange50 +, KITorange30 +, KITorange15 +,
+  KITbrown +, KITbrown70 +, KITbrown50 +, KITbrown30 +,
+  KITbrown15 +, KITred +, KITred70 +, KITred50 +,
+  KITred30 +, KITred15 +, KITlilac +, KITlilac70 +,
+  KITlilac50 +, KITlilac30 +, KITlilac15 +, KITcyanblue +,
+  KITcyanblue70 +, KITcyanblue50 +, KITcyanblue30 +, KITcyanblue15 +,
+  KITseablue +, KITseablue70 +, KITseablue50 +, KITseablue30 +,
+  KITseablue15 +, THESISblue +, THESISblue_dark +, THESISblue_light +,
+  THESISblue_vlight +, THESISred +, THESISred_dark +, THESISred_light +,
+  THESISred_vlight +, THESISgreen +, THESISgreen_dark +, THESISgreen_light +,
+  THESISgreen_vlight +, THESISyellow +, THESISyellow_dark +, THESISyellow_light +,
+  THESISyellow_vlight +, THESISblack +, THESISblack70 +, THESISblack50 +,
+  THESISblack30 +, THESISblack15 +, THESISblack7 +, Goldenrod +,
+  Gray +, Green +, Greenyellow +, Grey +,
+  Honeydew +, Hotpink +, Indianred +, Indigo +,
+  Ivory +, Khaki +, Lavender +, Lavenderblush +,
+  Lawngreen +, Lemonchiffon +, Lightblue +, Lightcoral +,
+  Lightcyan +, Lightgoldenrodyellow +, Lightgray +, Lightgreen +,
+  Lightgrey +, Lightpink +, Lightsalmon +, Lightseagreen +,
+  Lightskyblue +, Lightslategray +, Lightslategrey +, Lightsteelblue +,
+  Lightyellow +, Lime +, Limegreen +, Linen +,
+  Magenta +, Maroon +, Mediumaquamarine +, Mediumblue +,
+  Mediumorchid +, Mediumpurple +, Mediumseagreen +, Mediumslateblue +,
+  Mediumspringgreen +, Mediumturquoise +, Mediumvioletred +, Midnightblue +,
+  Mintcream +, Mistyrose +, Moccasin +, Navajowhite +,
+  Navy +, Oldlace +, Olive +, Olivedrab +,
+  Orange +, Orangered +, Orchid +, Palegoldenrod +,
+  Palegreen +, Paleturquoise +, Palevioletred +, Papayawhip +,
+  Peachpuff +, Peru +, Pink +, Plum +,
+  Powderblue +, Purple +, Red +, Rosybrown +,
+  Royalblue +, Saddlebrown +, Salmon +, Sandybrown +,
+  Seagreen +, Seashell +, Sienna +, Silver +,
+  Skyblue +, Slateblue +, Slategray +, Slategrey +,
+  Snow +, Springgreen +, Steelblue +, Tan +,
+  Teal +, Thistle +, Tomato +, Turquoise +,
+  Violet +, Wheat +, White +, Whitesmoke +,
+  Yellow +, Yellowgreen +
+ }
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Color (Types::real red=0.0, Types::real green=0.0, Types::real blue=0, Types::real alpha=0)
 
 Color (Color::Name name)
 
bool operator== (Color const &rhs)
 
bool operator!= (Color const &rhs)
 
std::string Hexadecimal ()
 
Types::real red () const
 
Types::real & red ()
 
Types::real green () const
 
Types::real & green ()
 
Types::real blue () const
 
Types::real & blue ()
 
Types::ubyte Red () const
 
void Red (Types::ubyte red)
 
Types::ubyte Green () const
 
void Green (Types::ubyte green)
 
Types::ubyte Blue () const
 
void Blue (Types::ubyte blue)
 
+ + + + + + + + + +

+Private Attributes

Types::real red_
 
Types::real green_
 
Types::real blue_
 
Types::real alpha_
 
+ + + +

+Friends

std::ostream & operator<< (std::ostream &os, Name const color)
 
+

Detailed Description

+
...
+
pgt::Color color(255,255,255);
+
pgt::Color color(0.9,0.5,0.1);
+
pgt::Color color(pgt::Color::Name::KITred);
+
std::cout << "Color: " << to_string(color.Green()) << std::endl;
+
std::cout << "Color: " << color.Hexadecimal() << std::endl;
+
+
std::cout << std::fixed << std::setprecision(3);
+
std::cout << color.red() << ", "
+
<< color.green() << ", "
+
<< color.blue() << ""
+
<< std::endl;
+
std::cout << "Color: " << color.Hexadecimal() << std::endl;
+
...
+
+

Definition at line 37 of file Color.hpp.

+

Member Enumeration Documentation

+ +

◆ Name

+ +
+
+ + + + + +
+ + + + +
enum class egoa::Color::Name
+ 		+strong
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
KITgreen 

RGB <- ( 0, 150, 130 ), rgb <- ( 0 , 0.588, 0.509 )

+
KITgreen70 

RGB <- ( 77, 181, 167 ), rgb <- ( 0.3 , 0.711, 0.656 )

+
KITgreen50 

RGB <- ( 128, 202, 192 ), rgb <- ( 0.5 , 0.794, 0.754 )

+
KITgreen30 

RGB <- ( 179, 223, 217 ), rgb <- ( 0.7 , 0.876, 0.852 )

+
KITgreen15 

RGB <- ( 217, 239, 236 ), rgb <- ( 0.85 , 0.938, 0.926 )

+
KITblue 

RGB <- ( 70, 100, 170 ), rgb <- ( 0.274, 0.392, 0.666 )

+
KITblue70 

RGB <- ( 125, 146, 195 ), rgb <- ( 0.492, 0.574, 0.766 )

+
KITblue50 

RGB <- ( 162, 177, 212 ), rgb <- ( 0.637, 0.696, 0.833 )

+
KITblue30 

RGB <- ( 199, 208, 230 ), rgb <- ( 0.782, 0.817, 0.9 )

+
KITblue15 

RGB <- ( 227, 232, 242 ), rgb <- ( 0.891, 0.908, 0.95 )

+
KITblack 

RGB <- ( 0, 0, 0 ), rgb <- ( 0 , 0 , 0 )

+
KITblack70 

RGB <- ( 77, 77, 77 ), rgb <- ( 0.3 , 0.3 , 0.3 )

+
KITblack50 

RGB <- ( 128, 128, 128 ), rgb <- ( 0.5 , 0.5 , 0.5 )

+
KITblack32 

RGB <- ( 179, 179, 179 ), rgb <- ( 0.7 , 0.7 , 0.7 )

+
KITblack31 

RGB <- ( 179, 179, 179 ), rgb <- ( 0.7 , 0.7 , 0.7 )

+
KITblack30 

RGB <- ( 179, 179, 179 ), rgb <- ( 0.7 , 0.7 , 0.7 )

+
KITblack29 

RGB <- ( 181, 181, 181 ), rgb <- ( 0.71 , 0.71 , 0.71 )

+
KITblack28 

RGB <- ( 184, 184, 184 ), rgb <- ( 0.72 , 0.72 , 0.72 )

+
KITblack27 

RGB <- ( 186, 186, 186 ), rgb <- ( 0.73 , 0.73 , 0.73 )

+
KITblack26 

RGB <- ( 189, 189, 189 ), rgb <- ( 0.74 , 0.74 , 0.74 )

+
KITblack25 

RGB <- ( 191, 191, 191 ), rgb <- ( 0.75 , 0.75 , 0.75 )

+
KITblack24 

RGB <- ( 194, 194, 194 ), rgb <- ( 0.76 , 0.76 , 0.76 )

+
KITblack23 

RGB <- ( 196, 196, 196 ), rgb <- ( 0.77 , 0.77 , 0.77 )

+
KITblack22 

RGB <- ( 199, 199, 199 ), rgb <- ( 0.78 , 0.78 , 0.78 )

+
KITblack21 

RGB <- ( 201, 201, 201 ), rgb <- ( 0.79 , 0.79 , 0.79 )

+
KITblack20 

RGB <- ( 204, 204, 204 ), rgb <- ( 0.80 , 0.80 , 0.80 )

+
KITblack19 

RGB <- ( 207, 207, 207 ), rgb <- ( 0.81 , 0.81 , 0.81 )

+
KITblack18 

RGB <- ( 209, 209, 209 ), rgb <- ( 0.82 , 0.82 , 0.82 )

+
KITblack17 

RGB <- ( 212, 212, 212 ), rgb <- ( 0.83 , 0.83 , 0.83 )

+
KITblack16 

RGB <- ( 214, 214, 214 ), rgb <- ( 0.84 , 0.84 , 0.84 )

+
KITblack15 

RGB <- ( 217, 217, 217 ), rgb <- ( 0.85 , 0.85 , 0.85 )

+
KITblack14 

RGB <- ( 219, 219, 219 ), rgb <- ( 0.86 , 0.86 , 0.86 )

+
KITblack13 

RGB <- ( 222, 222, 222 ), rgb <- ( 0.87 , 0.87 , 0.87 )

+
KITblack12 

RGB <- ( 224, 224, 224 ), rgb <- ( 0.88 , 0.88 , 0.88 )

+
KITblack11 

RGB <- ( 227, 227, 227 ), rgb <- ( 0.89 , 0.89 , 0.89 )

+
KITblack10 

RGB <- ( 230, 230, 230 ), rgb <- ( 0.90 , 0.90 , 0.90 )

+
KITblack09 

RGB <- ( 232, 232, 232 ), rgb <- ( 0.91 , 0.91 , 0.91 )

+
KITblack08 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
KITblack07 

RGB <- ( 237, 237, 237 ), rgb <- ( 0.93 , 0.93 , 0.93 )

+
KITblack06 

RGB <- ( 240, 240, 240 ), rgb <- ( 0.94 , 0.94 , 0.94 )

+
KITblack05 

RGB <- ( 242, 242, 242 ), rgb <- ( 0.95 , 0.95 , 0.95 )

+
KITblack04 

RGB <- ( 245, 245, 245 ), rgb <- ( 0.96 , 0.96 , 0.96 )

+
KITblack03 

RGB <- ( 247, 247, 247 ), rgb <- ( 0.97 , 0.97 , 0.97 )

+
KITblack02 

RGB <- ( 250, 250, 250 ), rgb <- ( 0.98 , 0.98 , 0.98 )

+
KITblack01 

RGB <- ( 252, 252, 252 ), rgb <- ( 0.99 , 0.99 , 0.99 )

+
KITpalegreen 

RGB <- ( 130, 190, 60 ), rgb <- ( 0.509, 0.745, 0.235 )

+
KITpalegreen70 

RGB <- ( 167, 209, 118 ), rgb <- ( 0.656, 0.821, 0.464 )

+
KITpalegreen50 

RGB <- ( 192, 222, 157 ), rgb <- ( 0.754, 0.872, 0.617 )

+
KITpalegreen30 

RGB <- ( 217, 235, 196 ), rgb <- ( 0.852, 0.923, 0.77 )

+
KITpalegreen15 

RGB <- ( 236, 245, 226 ), rgb <- ( 0.926, 0.961, 0.885 )

+
KITyellow 

RGB <- ( 250, 230, 20 ), rgb <- ( 0.98 , 0.901, 0.078 )

+
KITyellow70 

RGB <- ( 251, 237, 90 ), rgb <- ( 0.986, 0.931, 0.354 )

+
KITyellow50 

RGB <- ( 252, 242, 137 ), rgb <- ( 0.99 , 0.95 , 0.539 )

+
KITyellow30 

RGB <- ( 253, 247, 184 ), rgb <- ( 0.994, 0.97 , 0.723 )

+
KITyellow15 

RGB <- ( 254, 251, 220 ), rgb <- ( 0.997, 0.985, 0.861 )

+
KITorange 

RGB <- ( 220, 160, 30 ), rgb <- ( 0.862, 0.627, 0.117 )

+
KITorange70 

RGB <- ( 230, 188, 97 ), rgb <- ( 0.903, 0.739, 0.382 )

+
KITorange50 

RGB <- ( 237, 207, 142 ), rgb <- ( 0.931, 0.813, 0.558 )

+
KITorange30 

RGB <- ( 244, 226, 187 ), rgb <- ( 0.958, 0.888, 0.735 )

+
KITorange15 

RGB <- ( 250, 241, 221 ), rgb <- ( 0.979, 0.944, 0.867 )

+
KITbrown 

RGB <- ( 160, 130, 50 ), rgb <- ( 0.627, 0.509, 0.196 )

+
KITbrown70 

RGB <- ( 188, 167, 111 ), rgb <- ( 0.739, 0.656, 0.437 )

+
KITbrown50 

RGB <- ( 207, 192, 152 ), rgb <- ( 0.813, 0.754, 0.598 )

+
KITbrown30 

RGB <- ( 226, 217, 193 ), rgb <- ( 0.888, 0.852, 0.758 )

+
KITbrown15 

RGB <- ( 241, 236, 224 ), rgb <- ( 0.944, 0.926, 0.879 )

+
KITred 

RGB <- ( 160, 30, 40 ), rgb <- ( 0.627, 0.117, 0.156 )

+
KITred70 

RGB <- ( 188, 97, 104 ), rgb <- ( 0.739, 0.382, 0.409 )

+
KITred50 

RGB <- ( 207, 142, 147 ), rgb <- ( 0.813, 0.558, 0.578 )

+
KITred30 

RGB <- ( 226, 187, 190 ), rgb <- ( 0.888, 0.735, 0.747 )

+
KITred15 

RGB <- ( 241, 221, 223 ), rgb <- ( 0.944, 0.867, 0.873 )

+
KITlilac 

RGB <- ( 160, 0, 120 ), rgb <- ( 0.627, 0 , 0.47 )

+
KITlilac70 

RGB <- ( 188, 77, 160 ), rgb <- ( 0.739, 0.3 , 0.629 )

+
KITlilac50 

RGB <- ( 207, 128, 187 ), rgb <- ( 0.813, 0.5 , 0.735 )

+
KITlilac30 

RGB <- ( 226, 179, 214 ), rgb <- ( 0.888, 0.7 , 0.841 )

+
KITlilac15 

RGB <- ( 241, 217, 235 ), rgb <- ( 0.944, 0.85 , 0.92 )

+
KITcyanblue 

RGB <- ( 80, 170, 230 ), rgb <- ( 0.313, 0.666, 0.901 )

+
KITcyanblue70 

RGB <- ( 132, 195, 237 ), rgb <- ( 0.519, 0.766, 0.931 )

+
KITcyanblue50 

RGB <- ( 167, 212, 242 ), rgb <- ( 0.656, 0.833, 0.95 )

+
KITcyanblue30 

RGB <- ( 202, 230, 247 ), rgb <- ( 0.794, 0.9 , 0.97 )

+
KITcyanblue15 

RGB <- ( 229, 242, 251 ), rgb <- ( 0.897, 0.95 , 0.985 )

+
KITseablue 

RGB <- ( 50, 80, 140 ), rgb <- ( 0.196, 0.313, 0.549 )

+
KITseablue70 

RGB <- ( 111, 132, 174 ), rgb <- ( 0.437, 0.519, 0.684 )

+
KITseablue50 

RGB <- ( 152, 167, 197 ), rgb <- ( 0.598, 0.656, 0.774 )

+
KITseablue30 

RGB <- ( 193, 202, 220 ), rgb <- ( 0.758, 0.794, 0.864 )

+
KITseablue15 

RGB <- ( 224, 229, 238 ), rgb <- ( 0.879, 0.897, 0.932 )

+
THESISblue 

RGB <- ( 86, 151, 197 ), rgb <- ( 0.337, 0.592, 0.773 )

+
THESISblue_dark 

RGB <- ( 54, 120, 167 ), rgb <- ( 0.212, 0.471, 0.655 )

+
THESISblue_light 

RGB <- ( 125, 181, 221 ), rgb <- ( 0.490, 0.710, 0.867 )

+
THESISblue_vlight 

RGB <- ( 222, 239, 252 ), rgb <- ( 0.871, 0.937, 0.988 )

+
THESISred 

RGB <- ( 198, 91, 101 ), rgb <- ( 0.776, 0.357, 0.396 )

+
THESISred_dark 

RGB <- ( 169, 60, 69 ), rgb <- ( 0.663, 0.235, 0.271 )

+
THESISred_light 

RGB <- ( 221, 128, 136 ), rgb <- ( 0.867, 0.502, 0.533 )

+
THESISred_vlight 

RGB <- ( 251, 222, 224 ), rgb <- ( 0.984, 0.871, 0.878 )

+
THESISgreen 

RGB <- ( 86, 195, 60 ), rgb <- ( 0.337, 0.765, 0.235 )

+
THESISgreen_dark 

RGB <- ( 68, 156, 47 ), rgb <- ( 0.267, 0.612, 0.184 )

+
THESISgreen_light 

RGB <- ( 112, 222, 87 ), rgb <- ( 0.443, 0.871, 0.341 )

+
THESISgreen_vlight 

RGB <- ( 181, 251, 164 ), rgb <- ( 0.710, 0.984, 0.643 )

+
THESISyellow 

RGB <- ( 206, 168, 67 ), rgb <- ( 0.808, 0.659, 0.263 )

+
THESISyellow_dark 

RGB <- ( 170, 135, 46 ), rgb <- ( 0.667, 0.529, 0.180 )

+
THESISyellow_light 

RGB <- ( 229, 195, 105 ), rgb <- ( 0.898, 0.765, 0.412 )

+
THESISyellow_vlight 

RGB <- ( 253, 238, 198 ), rgb <- ( 0.992, 0.933, 0.776 )

+
THESISblack 

RGB <- ( 0, 0, 0 ), rgb <- ( 0 , 0 , 0 )

+
THESISblack70 

RGB <- ( 77, 77, 77 ), rgb <- ( 0.3 , 0.3 , 0.3 )

+
THESISblack50 

RGB <- ( 128, 128, 128 ), rgb <- ( 0.5 , 0.5 , 0.5 )

+
THESISblack30 

RGB <- ( 179, 179, 179 ), rgb <- ( 0.7 , 0.7 , 0.7 )

+
THESISblack15 

RGB <- ( 217, 217, 217 ), rgb <- ( 0.85 , 0.85 , 0.85 )

+
THESISblack7 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Goldenrod 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.855, 0.647, 0.125 )

+
Gray 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.002, 0.002, 0.002 )

+
Green 

RGB <- ( 235, 235, 235 ), rgb <- ( 0 , 0.002, 0 )

+
Greenyellow 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Grey 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Honeydew 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Hotpink 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Indianred 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Indigo 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Ivory 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Khaki 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lavender 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lavenderblush 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lawngreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lemonchiffon 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightcoral 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightcyan 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightgoldenrodyellow 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightgray 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightgreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightgrey 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightpink 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightsalmon 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightseagreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightskyblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightslategray 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightslategrey 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightsteelblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lightyellow 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Lime 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Limegreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Linen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Magenta 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Maroon 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumaquamarine 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumorchid 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumpurple 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumseagreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumslateblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumspringgreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumturquoise 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mediumvioletred 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Midnightblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mintcream 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Mistyrose 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Moccasin 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Navajowhite 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Navy 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Oldlace 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Olive 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Olivedrab 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Orange 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Orangered 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Orchid 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Palegoldenrod 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Palegreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Paleturquoise 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Palevioletred 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Papayawhip 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Peachpuff 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Peru 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Pink 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Plum 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Powderblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Purple 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Red 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Rosybrown 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Royalblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Saddlebrown 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Salmon 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Sandybrown 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Seagreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Seashell 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Sienna 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Silver 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Skyblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Slateblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Slategray 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Slategrey 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Snow 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Springgreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Steelblue 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Tan 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Teal 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Thistle 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Tomato 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Turquoise 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Violet 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Wheat 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
White 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Whitesmoke 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Yellow 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
Yellowgreen 

RGB <- ( 235, 235, 235 ), rgb <- ( 0.92 , 0.92 , 0.92 )

+
+ +

Definition at line 39 of file Color.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Color() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::Color::Color (Types::real red = 0.0,
Types::real green = 0.0,
Types::real blue = 0,
Types::real alpha = 0 
)
+ 		+inline
+
+ +

Definition at line 264 of file Color.hpp.

+ +
+
+ +

◆ Color() [2/2]

+ +
+
+ + + + + + + + +
egoa::Color::Color (Color::Name name)
+
+ +

Definition at line 466 of file Color.cpp.

+ +
+
+ +

◆ ~Color()

+ +
+
+ + + + + +
+ + + + + + + +
egoa::Color::~Color ()
+ 		+inline
+
+ +

Definition at line 279 of file Color.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ blue() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Color::blue ()
+ 		+inline
+
+ +

Definition at line 432 of file Color.hpp.

+ +
+
+ +

◆ blue() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Color::blue () const
+ 		+inline
+
+ +

Definition at line 431 of file Color.hpp.

+ +
+
+ +

◆ Blue() [1/2]

+ +
+
+ + + + + + + +
Types::ubyte egoa::Color::Blue () const
+
+ +

Definition at line 497 of file Color.cpp.

+ +
+
+ +

◆ Blue() [2/2]

+ +
+
+ + + + + + + + +
void egoa::Color::Blue (Types::ubyte blue)
+
+ +

Definition at line 493 of file Color.cpp.

+ +
+
+ +

◆ green() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Color::green ()
+ 		+inline
+
+ +

Definition at line 429 of file Color.hpp.

+ +
+
+ +

◆ green() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Color::green () const
+ 		+inline
+
+ +

Definition at line 428 of file Color.hpp.

+ +
+
+ +

◆ Green() [1/2]

+ +
+
+ + + + + + + +
Types::ubyte egoa::Color::Green () const
+
+ +

Definition at line 487 of file Color.cpp.

+ +
+
+ +

◆ Green() [2/2]

+ +
+
+ + + + + + + + +
void egoa::Color::Green (Types::ubyte green)
+
+ +

Definition at line 483 of file Color.cpp.

+ +
+
+ +

◆ Hexadecimal()

+ +
+
+ + + + + + + +
std::string egoa::Color::Hexadecimal ()
+
+ +

Definition at line 503 of file Color.cpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + +
bool egoa::Color::operator!= (Color const & rhs)
+ 		+inline
+
+ +

Definition at line 286 of file Color.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool egoa::Color::operator== (Color const & rhs)
+ 		+inline
+
+ +

Definition at line 282 of file Color.hpp.

+ +
+
+ +

◆ red() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Color::red ()
+ 		+inline
+
+ +

Definition at line 426 of file Color.hpp.

+ +
+
+ +

◆ red() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Color::red () const
+ 		+inline
+
+

@Name Getter and setter

+ +

Definition at line 425 of file Color.hpp.

+ +
+
+ +

◆ Red() [1/2]

+ +
+
+ + + + + + + +
Types::ubyte egoa::Color::Red () const
+
+ +

Definition at line 477 of file Color.cpp.

+ +
+
+ +

◆ Red() [2/2]

+ +
+
+ + + + + + + + +
void egoa::Color::Red (Types::ubyte red)
+
+ +

Definition at line 473 of file Color.cpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
Name const color 
)
+ 		+friend
+
+ +

Definition at line 290 of file Color.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ alpha_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Color::alpha_
+ 		+private
+
+ +

Definition at line 450 of file Color.hpp.

+ +
+
+ +

◆ blue_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Color::blue_
+ 		+private
+
+ +

Definition at line 449 of file Color.hpp.

+ +
+
+ +

◆ green_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Color::green_
+ 		+private
+
+ +

Definition at line 448 of file Color.hpp.

+ +
+
+ +

◆ red_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Color::red_
+ 		+private
+
+ +

Definition at line 447 of file Color.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_depth_first_search-members.html b/classegoa_1_1_depth_first_search-members.html new file mode 100644 index 00000000..782895d4 --- /dev/null +++ b/classegoa_1_1_depth_first_search-members.html @@ -0,0 +1,130 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::DepthFirstSearch< GraphType, IsDirected, Recursive > Member List
+
+
+ +

This is the complete list of members for egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
Clear()egoa::Traversal< GraphType, IsDirected >inlineprotected
DepthFirstSearch(TGraph const &graph, TVertexId source)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
entryTime_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
EntryTimeAt(TVertexId vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
exitTime_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
ExitTimeAt(TVertexId const vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
graph_egoa::Traversal< GraphType, IsDirected >private
NumberOfVertices() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
parent_egoa::Traversal< GraphType, IsDirected >private
ParentOf(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inline
ParentOf(TVertexId vertexId) const (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
PostprocessingVertexWith(TVertexId vertexId)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
PreprocessingVertexWith(TVertexId vertexId)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
processed_egoa::Traversal< GraphType, IsDirected >private
ProcessedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
ProcessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
Result(std::vector< TVertexId > parent) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
Run() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
SetTerminate() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
SetVertexProcessedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
SetVertexVisitedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
Source() constegoa::Traversal< GraphType, IsDirected >inline
Source() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
source_egoa::Traversal< GraphType, IsDirected >private
Terminate() constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
terminate_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
TGraph typedef (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >
Time() constegoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlineprivate
Time() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlineprivate
time_egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >private
Traversal(TGraph const &graph, TVertexId source)egoa::Traversal< GraphType, IsDirected >inline
TTime typedef (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >
TVertexId typedef (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >
TypifyEdge(TVertexId source, TVertexId target)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inline
VertexExists(TVertexId vertexId) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
visited_egoa::Traversal< GraphType, IsDirected >private
VisitedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
~DepthFirstSearch() (defined in egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >)egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >inlinevirtual
~Traversal() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_depth_first_search.html b/classegoa_1_1_depth_first_search.html new file mode 100644 index 00000000..8a1710ea --- /dev/null +++ b/classegoa_1_1_depth_first_search.html @@ -0,0 +1,975 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::DepthFirstSearch< GraphType, IsDirected, Recursive > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::DepthFirstSearch< GraphType, IsDirected, Recursive > Class Template Reference
+
+
+ +

Class for the Depth-First Search (DFS). + More...

+ +

#include <DepthFirstSearch.hpp>

+
+Inheritance diagram for egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >:
+
+
+ + +egoa::Traversal< GraphType, IsDirected > +egoa::ArticulationVertexDetection< GraphType, IsDirected > + +
+ + + + + + + + + + + + + +

+Public Types

using TGraph = GraphType
 
using TVertexId = typename TGraph::TVertexId
 
using TTime = Types::count
 
- Public Types inherited from egoa::Traversal< GraphType, IsDirected >
using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

void Run ()
 
DfsEdgeType TypifyEdge (TVertexId source, TVertexId target)
 Determine DFS edge type.
 
bool Terminate () const
 Terminate the DFS.
 
void SetTerminate ()
 
TTime EntryTimeAt (TVertexId vertexId) const
 { function_description }
 
TTime ExitTimeAt (TVertexId const vertexId) const
 Returns the exit time of a vertex.
 
virtual void PreprocessingVertexWith (TVertexId vertexId)
 Preprocessing the vertex with vertexId.
 
virtual void PostprocessingVertexWith (TVertexId vertexId)
 Post processing the vertex with vertexId.
 
virtual void ProcessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId)
 
virtual void PostprocessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId)
 Post processing the edge with edgeId.
 
Constructors and destructor
 DepthFirstSearch (TGraph const &graph, TVertexId source)
 Constructs a new DFS instance.
 
- Public Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
virtual void Result (std::vector< TVertexId > parent)
 
 Traversal (TGraph const &graph, TVertexId source)
 Constructs a new instance.
 
TVertexId Source () const
 Getter and setter for the source vertex.
 
TVertexId & Source ()
 
TVertexId & ParentOf (TVertexId vertexId)
 Getter and setter for the parent relation.
 
TVertexId ParentOf (TVertexId vertexId) const
 
+ + + + + + + +

+Private Member Functions

TTime Time () const
 Modify time counter.
 
TTime & Time ()
 
+ + + + + + + + + +

+Private Attributes

TTime time_
 
bool terminate_
 
std::vector< TTime > entryTime_
 
std::vector< TTime > exitTime_
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
void Clear ()
 Clear and resize all vectors.
 
bool VertexExists (TVertexId vertexId)
 
bool NumberOfVertices ()
 
void SetVertexVisitedAt (TVertexId vertexId)
 Sets the vertex at vertexId to visited.
 
bool VisitedVertexAt (TVertexId vertexId) const
 Getter and setter to access the visited field.
 
void SetVertexProcessedAt (TVertexId vertexId)
 Sets the vertex at vertexId to processed.
 
bool ProcessedVertexAt (TVertexId vertexId) const
 Getter and setter to access the process field.
 
template<typename FUNCTION >
void breakable_for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges that is breakable.
 
template<typename FUNCTION >
void for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges.
 
+

Detailed Description

+
template<typename GraphType, bool IsDirected = false, bool Recursive = true>
+class egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >

Class for the Depth-First Search (DFS).

+
Template Parameters
+ + + +
GraphTypeThe graph should at least provide the same interface as the StaticGraph.
IsDirectedIf true the graph is treated as a directed graph, if false the graph is treated as an undirected graph.
+
+
+ +

Definition at line 35 of file DepthFirstSearch.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + +
using egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TGraph = GraphType
+
+ +

Definition at line 37 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ TTime

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + +
using egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TTime = Types::count
+
+ +

Definition at line 39 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + +
using egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TVertexId = typename TGraph::TVertexId
+
+ +

Definition at line 38 of file DepthFirstSearch.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ DepthFirstSearch()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::DepthFirstSearch (TGraph const & graph,
TVertexId source 
)
+ 		+inline
+
+ +

Constructs a new DFS instance.

+
Parameters
+ + + +
graphThe graph
[in]sourceThe source
+
+
+ +

Definition at line 51 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ ~DepthFirstSearch()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
virtual egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::~DepthFirstSearch ()
+ 		+inlinevirtual
+
+ +

Definition at line 60 of file DepthFirstSearch.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ EntryTimeAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + +
TTime egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::EntryTimeAt (TVertexId vertexId) const
+ 		+inline
+
+ +

{ function_description }

+
Parameters
+ + +
vertexThe vertex
+
+
+
Returns
{ description_of_the_return_value }
+ +

Definition at line 188 of file DepthFirstSearch.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::entryTime_.

+ +
+
+ +

◆ ExitTimeAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + +
TTime egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::ExitTimeAt (TVertexId const vertexId) const
+ 		+inline
+
+ +

Returns the exit time of a vertex.

+
Parameters
+ + +
vertexIdThe vertex identifier.
+
+
+
Returns
The exit time for a vertex during the DFS.
+ +

Definition at line 200 of file DepthFirstSearch.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::exitTime_.

+ +
+
+ +

◆ PostprocessingEdgeWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::PostprocessingEdgeWith (TVertexId source,
TVertexId target,
Types::edgeId edgeId 
)
+ 		+inlinevirtual
+
+ +

Post processing the edge with edgeId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for the vertexId, e.g., a lambda function.
+
+
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for the edge identifiers edgeId.
+
+
+ +

Reimplemented in egoa::ArticulationVertexDetection< GraphType, IsDirected >, and egoa::ArticulationVertexDetection< GraphType, false >.

+ +

Definition at line 274 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ PostprocessingVertexWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + +
virtual void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::PostprocessingVertexWith (TVertexId vertexId)
+ 		+inlinevirtual
+
+ +

Post processing the vertex with vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for the vertexId, e.g., a lambda function.
+
+
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for the vertex identifiers vertexId.
+
+
+ +

Reimplemented in egoa::ArticulationVertexDetection< GraphType, IsDirected >, and egoa::ArticulationVertexDetection< GraphType, false >.

+ +

Definition at line 242 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ PreprocessingVertexWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + +
virtual void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::PreprocessingVertexWith (TVertexId vertexId)
+ 		+inlinevirtual
+
+ +

Preprocessing the vertex with vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for the vertexId, e.g., a lambda function.
+
+
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for the vertex identifiers vertexId.
+
+
+ +

Reimplemented in egoa::ArticulationVertexDetection< GraphType, IsDirected >, and egoa::ArticulationVertexDetection< GraphType, false >.

+ +

Definition at line 222 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ ProcessingEdgeWith()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::ProcessingEdgeWith (TVertexId source,
TVertexId target,
Types::edgeId edgeId 
)
+ 		+inlinevirtual
+
+ +

Reimplemented in egoa::ArticulationVertexDetection< GraphType, IsDirected >, and egoa::ArticulationVertexDetection< GraphType, false >.

+ +

Definition at line 252 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::Run ()
+ 		+inline
+
+ +

Definition at line 64 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ SetTerminate()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
void egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::SetTerminate ()
+ 		+inline
+
+ +

Definition at line 165 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ Terminate()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
bool egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::Terminate () const
+ 		+inline
+
+ +

Terminate the DFS.

+
Returns
TRUE if the DFS
+ +

Definition at line 164 of file DepthFirstSearch.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::terminate_.

+ +
+
+ +

◆ Time() [1/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
TTime & egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::Time ()
+ 		+inlineprivate
+
+ +

Definition at line 177 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ Time() [2/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + +
TTime egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::Time () const
+ 		+inlineprivate
+
+ +

Modify time counter.

+
Returns
Current time
+ +

Definition at line 176 of file DepthFirstSearch.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::time_.

+ +
+
+ +

◆ TypifyEdge()

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
DfsEdgeType egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TypifyEdge (TVertexId source,
TVertexId target 
)
+ 		+inline
+
+ +

Determine DFS edge type.

+
Parameters
+ + + +
[in]sourceThe source identifier.
[in]targetThe target identifier.
+
+
+
Returns
The DFS edge type.
+
Todo:
Cross edge is only possible in directed case -> check for graph type
+ +

Definition at line 127 of file DepthFirstSearch.hpp.

+ +

References egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::EntryTimeAt(), egoa::Traversal< GraphType, IsDirected >::ParentOf(), egoa::Traversal< GraphType, IsDirected >::ProcessedVertexAt(), and egoa::Traversal< GraphType, IsDirected >::VisitedVertexAt().

+ +
+
+

Member Data Documentation

+ +

◆ entryTime_

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + +
std::vector<TTime> egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::entryTime_
+ 		+private
+
+

Entry time at a vertex

+ +

Definition at line 288 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ exitTime_

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + +
std::vector<TTime> egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::exitTime_
+ 		+private
+
+

Exit time at a vertex

+ +

Definition at line 289 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ terminate_

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + +
bool egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::terminate_
+ 		+private
+
+

Terminate search

+ +

Definition at line 286 of file DepthFirstSearch.hpp.

+ +
+
+ +

◆ time_

+ +
+
+
+template<typename GraphType , bool IsDirected = false, bool Recursive = true>
+ + + + + +
+ + + + +
TTime egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::time_
+ 		+private
+
+

Current time counter

+ +

Definition at line 285 of file DepthFirstSearch.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_depth_first_search.png b/classegoa_1_1_depth_first_search.png new file mode 100644 index 00000000..ecaca06a Binary files /dev/null and b/classegoa_1_1_depth_first_search.png differ diff --git a/classegoa_1_1_dominating_theta_path-members.html b/classegoa_1_1_dominating_theta_path-members.html new file mode 100644 index 00000000..a12e2368 --- /dev/null +++ b/classegoa_1_1_dominating_theta_path-members.html @@ -0,0 +1,129 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination > Member List
+
+
+ +

This is the complete list of members for egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Clear()egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
DominatingThetaPath(TGraph const &graph)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
DominatingThetaPath(TGraph const &graph, TVertexId source)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
dtpRuntimeRow_egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >private
graph_egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >private
Insert(TLabel const &label)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
LabelAt(TVertexId const vertexId, Types::labelId const labelId)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
LabelSetAt(TVertexId const vertexId) constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
LabelSetAt(TVertexId const vertexId)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
LabelSetEmptyAt(TVertexId const vertexId) constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
LabelSetEmptyAt(TLabel const &label) constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
labelSets_egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >private
MergeLabelAt(TVertexId vertexId, TLabel &label)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
NumberOfLabels()egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
NumberOfPathsThroughEdge(TVertexId target, std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
NumberOfPathsThroughVertex(TVertexId target, std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
ProduceCycle(TLabel &label, std::pair< TLabel, bool > &&pair)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
queue_egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >private
QueueDeleteMinimum()egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
QueueEmpty() constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
Result(Subgraph< TGraph const > &resultSubgraph, TVertexId const target)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
Result(std::vector< std::vector< TVertexId > > &parent, TVertexId const target)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
Run()egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
SetParentOf(TLabel &label, TLabel const &previousLabel)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
Source(TVertexId source)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
Statistic()egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
Statistic() constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
TEdge typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TEdgeId typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TGraph typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TLabel typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TLabelSet typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TotalNumberOfPathsThroughEdge(std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
TotalNumberOfPathsThroughVertex(std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inline
TQueue typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TVertex typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
TVertexId typedefegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
UpdateLabelSet(TLabelSet &labelSet)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
UpdateLabelSetAt(TVertexId vertexId)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
UpdateQueueWith(TLabel const &newLabel)egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
VertexIdOf(TLabel const &label) constegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >inlineprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_dominating_theta_path.html b/classegoa_1_1_dominating_theta_path.html new file mode 100644 index 00000000..0797b789 --- /dev/null +++ b/classegoa_1_1_dominating_theta_path.html @@ -0,0 +1,1787 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +List of all members
+
egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination > Class Template Referencefinal
+
+
+ +

Class for dominating theta path. + More...

+ +

#include <DominatingThetaPath.hpp>

+ + + + + + + + + + + + + + + + + + +

+Public Types

using TGraph = GraphType
 
using TVertex = typename GraphType::TVertex
 
using TVertexId = typename GraphType::TVertexId
 
using TEdge = typename GraphType::TEdge
 
using TEdgeId = typename GraphType::TEdgeId
 
using TLabel = LabelType
 
using TQueue = QueueType
 
using TLabelSet = LabelSetType
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 DominatingThetaPath (TGraph const &graph)
 Constructs the object.
 
 DominatingThetaPath (TGraph const &graph, TVertexId source)
 Constructs the object.
 
Execute the DTP Algorithm
void Run ()
 Run the DTP algorithm.
 
Access information
Types::real Result (Subgraph< TGraph const > &resultSubgraph, TVertexId const target)
 Extracts the subgraph formed by the DTPs from the source to the given target.
 
Types::real Result (std::vector< std::vector< TVertexId > > &parent, TVertexId const target)
 Extract result graph and value.
 
Types::count NumberOfLabels ()
 Current number of labels.
 
Modifiers
void Source (TVertexId source)
 Set the source.
 
void Clear ()
 Clear all data structures.
 
IO::DtpRuntimeRow & Statistic ()
 Setter for the statistic.
 
IO::DtpRuntimeRow const & Statistic () const
 Getter for the statistic.
 
Compute Path Numbers
void TotalNumberOfPathsThroughVertex (std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)
 Total number of $\dtp$ paths through a vertex.
 
void NumberOfPathsThroughVertex (TVertexId target, std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)
 Number of $\dtp$ paths at each vertex.
 
void TotalNumberOfPathsThroughEdge (std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)
 Total number of $\dtp$ paths through an edge.
 
void NumberOfPathsThroughEdge (TVertexId target, std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)
 Number of $\dtp$ paths through an edge.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Accessors
TVertexId VertexIdOf (TLabel const &label) const
 Access vertex identifier of a label.
 
TLabelSet const & LabelSetAt (TVertexId const vertexId) const
 Getter for the set of labels $\labels(\vertex)$ of a vertex $\vertex$.
 
TLabelSet & LabelSetAt (TVertexId const vertexId)
 Setter for the set of labels $\labels(\vertex)$ of a vertex $\vertex$.
 
TLabel & LabelAt (TVertexId const vertexId, Types::labelId const labelId)
 The label $\labelu$ at a vertex $\vertex$ with vertexId and the label's identifier labelId.
 
Label Set L(v) and Queue Q Operators
bool QueueEmpty () const
 Check if the main queue is empty.
 
void Insert (TLabel const &label)
 Adds a label to the main queue.
 
void UpdateQueueWith (TLabel const &newLabel)
 Update queue with new label $\labelu_{\mathrm{new}}$.
 
TLabel QueueDeleteMinimum ()
 Delete the minimum key from the queue $\queue$.
 
bool LabelSetEmptyAt (TVertexId const vertexId) const
 Check if a label set $\labels(\vertex)$ is empty at vertex $\vertex$.
 
bool LabelSetEmptyAt (TLabel const &label) const
 Check if a label set $\labels(\vertex)$ is empty at vertex $\vertex$.
 
Types::labelId UpdateLabelSet (TLabelSet &labelSet)
 Update a label set $\labels(\vertex)$ at a vertex $\vertex$.
 
Types::labelId UpdateLabelSetAt (TVertexId vertexId)
 Update a label set at a vertex.
 
Label operations
void SetParentOf (TLabel &label, TLabel const &previousLabel)
 Sets the parent of label $\labelu$ to previousLabel $\labelu_{p}$.
 
bool MergeLabelAt (TVertexId vertexId, TLabel &label)
 Merge label $\labelu$ with the set of labels. $\labels(\vertex)$ at vertex $\vertex$.
 
bool ProduceCycle (TLabel &label, std::pair< TLabel, bool > &&pair)
 Check if the new label $\labelu_{\mathrm{new}}$ produces a cycle.
 
+ + + + + + + + + +

+Private Attributes

TGraph const & graph_
 
std::vector< TLabelSet > labelSets_
 
TQueue queue_
 
IO::DtpRuntimeRow dtpRuntimeRow_
 
+

Detailed Description

+
template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+class egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >

Class for dominating theta path.

+
Todo:
Usage example
+
Template Parameters
+ + + + + + +
GraphTypeThe graph type, e.g., StaticGraph<Vertices::ElectricalProperties, Edges::ElectricalProperties>.
LabelTypeThe label type such as Label, SusceptanceNormLabel, and VoltageAngleDifferenceLabel.
QueueTypeThe priority queue type such as BinaryHeap.
LabelSetTypeThe label set type representing the bucket Bucket.
DominationThe domination criterion DominationCriterion, e.g., DominationCriterion::strict.
+
+
+
See also
StaticGraph
+
+Label, SusceptanceNormLabel, VoltageAngleDifferenceLabel
+
+BinaryHeap
+
+Bucket
+ +

Definition at line 58 of file DominatingThetaPath.hpp.

+

Member Typedef Documentation

+ +

◆ TEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TEdge = typename GraphType::TEdge
+
+

The edge type.

+ +

Definition at line 65 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TEdgeId = typename GraphType::TEdgeId
+
+

The edge identifier type.

+ +

Definition at line 66 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TGraph = GraphType
+
+

The graph type.
+

+ +

Definition at line 62 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TLabel

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TLabel = LabelType
+
+

The label type.

+ +

Definition at line 68 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TLabelSet

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TLabelSet = LabelSetType
+
+

The label set type represented by a bucket.

+ +

Definition at line 70 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TQueue

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TQueue = QueueType
+
+

The priority queue type.

+ +

Definition at line 69 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TVertex = typename GraphType::TVertex
+
+

The vertex type.

+ +

Definition at line 63 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + +
using egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TVertexId = typename GraphType::TVertexId
+
+

The vertex identifier type.

+ +

Definition at line 64 of file DominatingThetaPath.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ DominatingThetaPath() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::DominatingThetaPath (TGraph const & graph)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + +
graphThe graph structure.
+
+
+ +

Definition at line 82 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_, and egoa::IO::DtpRuntimeRow::NameOfProblem.

+ +
+
+ +

◆ DominatingThetaPath() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::DominatingThetaPath (TGraph const & graph,
TVertexId source 
)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + + +
graphThe graph structure.
[in]sourceThe source's vertex identifier.
+
+
+ +

Definition at line 98 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Clear(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Source().

+ +
+
+

Member Function Documentation

+ +

◆ Clear()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Clear ()
+ 		+inline
+
+ +

Clear all data structures.

+ +

Definition at line 336 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_, and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_.

+ +
+
+ +

◆ Insert()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Insert (TLabel const & label)
+ 		+inlineprivate
+
+ +

Adds a label to the main queue.

+
Precondition
A precondition to that method is that the label set of the label's label vertex was updated. Thus, this method should only be called by UpdateLabelSet() or UpdateLabelSetAt().
+
Parameters
+ + +
labelThe label.
+
+
+ +

Definition at line 602 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_.

+ +
+
+ +

◆ LabelAt()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TLabel & egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelAt (TVertexId const vertexId,
Types::labelId const labelId 
)
+ 		+inlineprivate
+
+ +

The label $\labelu$ at a vertex $\vertex$ with vertexId and the label's identifier labelId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier of vertex $\vertex$.
[in]labelIdThe label identifier of label $\labelu$.
+
+
+
Returns
The label $\labelu$.
+ +

Definition at line 569 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ LabelSetAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
TLabelSet & egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetAt (TVertexId const vertexId)
+ 		+inlineprivate
+
+ +

Setter for the set of labels $\labels(\vertex)$ of a vertex $\vertex$.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The set of labels $\labels(\vertex)$ for the vertex.
+ +

Definition at line 554 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ LabelSetAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
TLabelSet const & egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetAt (TVertexId const vertexId) const
+ 		+inlineprivate
+
+ +

Getter for the set of labels $\labels(\vertex)$ of a vertex $\vertex$.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The set of labels $\labels(\vertex)$ for the vertex.
+ +

Definition at line 539 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ LabelSetEmptyAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
bool egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetEmptyAt (TLabel const & label) const
+ 		+inlineprivate
+
+ +

Check if a label set $\labels(\vertex)$ is empty at vertex $\vertex$.

+
Parameters
+ + +
labelThe label $\labelu$.
+
+
+
Returns
True if the label set $\labels(\vertex)$ is empty, False otherwise.
+ +

Definition at line 677 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetEmptyAt(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::VertexIdOf().

+ +
+
+ +

◆ LabelSetEmptyAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
bool egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetEmptyAt (TVertexId const vertexId) const
+ 		+inlineprivate
+
+ +

Check if a label set $\labels(\vertex)$ is empty at vertex $\vertex$.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier of vertex $\vertex$.
+
+
+
Returns
True if the label set is empty, False otherwise.
+ +

Definition at line 662 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ MergeLabelAt()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::MergeLabelAt (TVertexId vertexId,
TLabel & label 
)
+ 		+inlineprivate
+
+ +

Merge label $\labelu$ with the set of labels. $\labels(\vertex)$ at vertex $\vertex$.

+

Checks if the new label $\labelu_{\mathrm{new}}$ is dominated by any label in $\labels(\vertex)$ and delete dominated labels. If $\labelu_{\mathrm{new}}$ is dominated by another label it is marked as invalid.

+
Parameters
+ + + +
[in]vertexIdThe vertex $\vertex$ with set of labels $\labels(\vertex)$.
labelStructThe label that should be merged into the set of labels $\labels(\vertex)$.
+
+
+
Returns
True if the merging was successful, False otherwise.
+ +

Definition at line 765 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ NumberOfLabels()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
Types::count egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfLabels ()
+ 		+inline
+
+ +

Current number of labels.

+
Returns
Total number of labels
+ +

Definition at line 300 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ NumberOfPathsThroughEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughEdge (TVertexId target,
std::vector< Types::count > & numberOfPathsPerEdge,
std::vector< Types::real > & relativeNumberOfPathsPerEdge 
)
+ 		+inline
+
+ +

Number of $\dtp$ paths through an edge.

+

Note that this should not be used for a normal Dijkstra implementation as the labels are always optimal. However, here the labels are not always possible and we do nod see a faster implementation to calculate the number of paths faster.

+
Parameters
+ + + + +
[in]targetThe target for which we count the paths.
numberOfPathsThe number of paths (note that this field will be resized).
relativeNumberOfPathsPerEdgeThe edge score per thread (if we run the algorithm parallel).
+
+
+
Todo:
Use DAG property of label paths.
+ +

Definition at line 471 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelAt(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetAt(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ NumberOfPathsThroughVertex()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughVertex (TVertexId target,
std::vector< Types::count > & numberOfPathsPerVertex,
std::vector< Types::real > & relativeNumberOfPathsPerVertex 
)
+ 		+inline
+
+ +

Number of $\dtp$ paths at each vertex.

+

This methods counts the number of paths through a vertex. However, a label path counts only once, which is realized by the marked flag.

+
Parameters
+ + + +
[in]targetThe target for which we count the paths.
numberOfPathsThe number of paths. (Note that this field will be resized to the number of vertices in the graph if not already done.)
+
+
+
Todo:
Use DAG property of label paths.
+ +

Definition at line 402 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelAt(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetAt(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ ProduceCycle()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::ProduceCycle (TLabel & label,
std::pair< TLabel, bool > && pair 
)
+ 		+inlineprivate
+
+ +

Check if the new label $\labelu_{\mathrm{new}}$ produces a cycle.

+

The term std::get<1>(pair) just says if the vertex could be inserted into the set of vertices. If True it does not produce a cycle, otherwise (meaning False) it produces a cycle. The latter means that the vertex was already in the set of vertices. Thus, the term (meaning std::get<1>(pair)) is negated.

+
Parameters
+ + + +
labelThe new label $\labelu_{\mathrm{new}}$.
pairThe pair should be used with "label + edge" or "edge + label".
+
+
+
Returns
True if the new label produces a cycle, False otherwise.
+ +

Definition at line 785 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ QueueDeleteMinimum()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
TLabel egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::QueueDeleteMinimum ()
+ 		+inlineprivate
+
+ +

Delete the minimum key from the queue $\queue$.

+

Remove the top element of the queue and push the top element of the same bucket to the queue (forward top element to the main queue).

+
Returns
Label that has the minimum key
+
See also
TQueue
+ +

Definition at line 639 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelSetEmptyAt(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_, and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateLabelSetAt().

+ +
+
+ +

◆ QueueEmpty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
bool egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::QueueEmpty () const
+ 		+inlineprivate
+
+ +

Check if the main queue is empty.

+
Returns
True if the main queue is empty, False otherwise.
+ +

Definition at line 588 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_.

+ +
+
+ +

◆ Result() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Result (std::vector< std::vector< TVertexId > > & parent,
TVertexId const target 
)
+ 		+inline
+
+ +

Extract result graph and value.

+

The path is constructed from source to sink for each label that is optimal at the target. Note that the optimality is defined by the labels in the label set.

+
Parameters
+ + + +
parentThe parent pointer.
[in]targetThe target vertex t.
+
+
+
Returns
The optimal value.
+ +

Definition at line 260 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelAt(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ Result() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Result (Subgraph< TGraph const > & resultSubgraph,
TVertexId const target 
)
+ 		+inline
+
+ +

Extracts the subgraph formed by the DTPs from the source to the given target.

+
Parameters
+ + + +
[out]resultSubgraphThe resulting subgraph formed by all DTPs from the source to the target.
[in]targetThe target vertex.
+
+
+
Returns
The voltage angle difference from the source to the target vertex.
+ +

Definition at line 191 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::LabelAt(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Run ()
+ 		+inline
+
+ +

Run the DTP algorithm.

+ +

Definition at line 114 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_, egoa::IO::DtpRuntimeRow::GlobalElapsedMilliseconds, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::MergeLabelAt(), egoa::IO::DtpRuntimeRow::Name, egoa::IO::DtpRuntimeRow::NumberOfEdges, egoa::IO::DtpRuntimeRow::NumberOfEdgesProducingNoCycle, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfLabels(), egoa::IO::DtpRuntimeRow::NumberOfLabels, egoa::IO::DtpRuntimeRow::NumberOfRelaxedEdges, egoa::IO::DtpRuntimeRow::NumberOfScannedEdges, egoa::IO::DtpRuntimeRow::NumberOfVertices, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::ProduceCycle(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::QueueDeleteMinimum(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::QueueEmpty(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::SetParentOf(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateQueueWith().

+ +
+
+ +

◆ SetParentOf()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::SetParentOf (TLabel & label,
TLabel const & previousLabel 
)
+ 		+inlineprivate
+
+ +

Sets the parent of label $\labelu$ to previousLabel $\labelu_{p}$.

+
Parameters
+ + + +
labelThe current label $\labelu$.
previousLabelThe previous label $\labelu_p$
+
+
+ +

Definition at line 742 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ Source()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Source (TVertexId source)
+ 		+inline
+
+ +

Set the source.

+
Parameters
+ + +
[in]sourceThe source
+
+
+ +

Definition at line 321 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Clear(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_, egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Insert(), egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_, and egoa::IO::DtpRuntimeRow::SourceId.

+ +
+
+ +

◆ Statistic() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
IO::DtpRuntimeRow & egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Statistic ()
+ 		+inline
+
+ +

Setter for the statistic.

+
Returns
The current statistic representing a row.
+ +

Definition at line 352 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_.

+ +
+
+ +

◆ Statistic() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + +
IO::DtpRuntimeRow const & egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Statistic () const
+ 		+inline
+
+ +

Getter for the statistic.

+
Returns
The current statistic representing a row.
+ +

Definition at line 362 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_.

+ +
+
+ +

◆ TotalNumberOfPathsThroughEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TotalNumberOfPathsThroughEdge (std::vector< Types::count > & numberOfPathsPerEdge,
std::vector< Types::real > & relativeNumberOfPathsPerEdge 
)
+ 		+inline
+
+ +

Total number of $\dtp$ paths through an edge.

+
Parameters
+ + + +
numberOfPathsPerEdgeThe total number of paths per edge.
relativeNumberOfPathsPerEdgeThe total relative number of paths per edge.
+
+
+ +

Definition at line 444 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughEdge().

+ +
+
+ +

◆ TotalNumberOfPathsThroughVertex()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::TotalNumberOfPathsThroughVertex (std::vector< Types::count > & numberOfPathsPerVertex,
std::vector< Types::real > & relativeNumberOfPathsPerVertex 
)
+ 		+inline
+
+ +

Total number of $\dtp$ paths through a vertex.

+
Parameters
+ + + +
numberOfPathsPerVertexThe total number of paths per vertex.
relativeNumberOfPathsPerVertexThe total relative number of paths per vertex.
+
+
+ +

Definition at line 378 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_, and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughVertex().

+ +
+
+ +

◆ UpdateLabelSet()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
Types::labelId egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateLabelSet (TLabelSet & labelSet)
+ 		+inlineprivate
+
+ +

Update a label set $\labels(\vertex)$ at a vertex $\vertex$.

+

Remove a label $\labelu$ associated with a vertex $\vertex$ from the queue has to trigger an update (#labelSet.Pop()) of the label set $\labels(\vertex)$ at a vertex $\vertex$.

+
Precondition
As a precondition QueueDeleteMinimum() has to be called.
+
Parameters
+ + +
labelSetThe label set $\labels(\vertex)$ at a vertex $\vertex$.
+
+
+ +

Definition at line 697 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Insert().

+ +
+
+ +

◆ UpdateLabelSetAt()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
Types::labelId egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateLabelSetAt (TVertexId vertexId)
+ 		+inlineprivate
+
+ +

Update a label set at a vertex.

+

Removing a label $\labelu$ associated with a vertex $\vertex$ from the queue has to trigger an update (#labelSet.Pop()) of the label bucket at vertex $\vertex$.

+
Precondition
As a precondition QueueDeleteMinimum() has do be called.
+
Parameters
+ + +
[in]vertexIdThe vertex identifier of vertex $\vertex$.
+
+
+
See also
DominatingThetaPath::UpdateBucket
+ +

Definition at line 724 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_, and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateLabelSet().

+ +
+
+ +

◆ UpdateQueueWith()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
void egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::UpdateQueueWith (TLabel const & newLabel)
+ 		+inlineprivate
+
+ +

Update queue with new label $\labelu_{\mathrm{new}}$.

+

If there is no label of the label's vertex the label will be added to the queue. However, if the new label $\labelu_{\mathrm{new}}$ is better than the existing one the key is changed to the new label $\labelu_{\mathrm{new}}$. Otherwise, nothing is happening.

+
Parameters
+ + +
newLabelThe new label $\labelu_{\mathrm{new}}$.
+
+
+ +

Definition at line 618 of file DominatingThetaPath.hpp.

+ +

References egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::Insert(), and egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_.

+ +
+
+ +

◆ VertexIdOf()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + + + + + +
TVertexId egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::VertexIdOf (TLabel const & label) const
+ 		+inlineprivate
+
+ +

Access vertex identifier of a label.

+
Parameters
+ + +
labelThe label
+
+
+
Returns
The vertex identifier.
+ +

Definition at line 526 of file DominatingThetaPath.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ dtpRuntimeRow_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + +
IO::DtpRuntimeRow egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::dtpRuntimeRow_
+ 		+private
+
+

To measure quality and time information.

+ +

Definition at line 799 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + +
TGraph const& egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::graph_
+ 		+private
+
+

The graph $\graph = (\vertices,\edges)$ on which the DTP is calculated.

+ +

Definition at line 795 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ labelSets_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + +
std::vector<TLabelSet> egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::labelSets_
+ 		+private
+
+

At each vertex $\vertex\in\vertices$ there is a set of labels $\labels(\vertex)$.

+ +

Definition at line 796 of file DominatingThetaPath.hpp.

+ +
+
+ +

◆ queue_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >, typename LabelType = VoltageAngleDifferenceLabel< typename GraphType::TEdge >, typename QueueType = MappingBinaryHeap< typename GraphType::TVertexId, LabelType >, typename LabelSetType = Bucket< BinaryHeap< LabelType > >, DominationCriterion Domination = DominationCriterion::strict>
+ + + + + +
+ + + + +
TQueue egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::queue_
+ 		+private
+
+

The priority queue $\queue$.

+ +

Definition at line 797 of file DominatingThetaPath.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_dynamic_graph-members.html b/classegoa_1_1_dynamic_graph-members.html new file mode 100644 index 00000000..00f118ba --- /dev/null +++ b/classegoa_1_1_dynamic_graph-members.html @@ -0,0 +1,194 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::DynamicGraph< VertexProperties, EdgeProperties > Member List
+
+
+ +

This is the complete list of members for egoa::DynamicGraph< VertexProperties, EdgeProperties >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
AddVertex(TVertexProperties &properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
AddVertex(TVertexProperties const &properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
AddVertex(TVertexProperties &&properties)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
DegreeAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
DynamicGraph(Types::name name="")egoa::DynamicGraph< VertexProperties, EdgeProperties >inlineexplicit
Edge(Types::vertexId source, Types::vertexId target)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(Types::vertexId source, Types::vertexId target) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(int source, int target)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(char source, char target)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(char source, int target)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(int source, char target)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(int source, int target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(char source, char target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(int source, char target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edge(char source, int target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(Types::edgeId id)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(Types::edgeId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(int index)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(char index)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(int index) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeAt(char index) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeExists(Types::edgeId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
edgeExists_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
EdgeId(Types::vertexId source, Types::vertexId target) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeId(int source, int target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeId(char source, char target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeId(int source, char target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeId(char source, int target) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeIdsAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edges()egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Edges() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
edges_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
for_all_edge_identifiers(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edge_tuples(FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edge_tuples(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges(FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(TVertex const &vertex, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(TVertex const &vertex, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(Types::vertexId vertexId, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(Types::vertexId vertexId, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_identifiers(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_tuples(FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_tuples(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_vertices(FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_all_vertices(FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(TVertex const &vertex, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(TVertex const &vertex, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(Types::vertexId vertexId, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(Types::vertexId vertexId, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(TVertex const &vertex, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(TVertex const &vertex, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(Types::vertexId vertexId, FUNCTION function)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(Types::vertexId vertexId, FUNCTION function) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
InDegreeAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
inEdgeIds_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
InEdgeIdsAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MapEdges(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MapVertices(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MaxDegree(Types::vertexId &id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MaxDegree() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MinDegree(Types::vertexId &id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
MinDegree() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Name() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
name_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
NeighborsOf(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
NumberOfEdges() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
numberOfEdges_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
NumberOfVertices() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
numberOfVertices_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
OutDegreeAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
outEdgeIds_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
OutEdgeIdsAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
RemoveAllIncidentEdgesAt(Types::vertexId id)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
RemoveEdgeAt(Types::edgeId id)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
RemoveVertexAt(Types::vertexId id)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
TConstEdgesView typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TConstVerticesView typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TEdge typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TEdgeId typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TEdgeProperties typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TEdgesView typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TGraph typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TVertex typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TVertexId typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TVertexProperties typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
TVerticesView typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >
UpdateEdges()egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
UpdateVertices()egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(Types::vertexId id)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(int id)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(char id)=delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(int id) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexAt(char id) const =delete (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >)egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
VertexExists(Types::vertexId id) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
vertexExists_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
VertexId(TVertex const &vertex) constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Vertices()egoa::DynamicGraph< VertexProperties, EdgeProperties >inline
Vertices() constegoa::DynamicGraph< VertexProperties, EdgeProperties >inline
vertices_egoa::DynamicGraph< VertexProperties, EdgeProperties >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_dynamic_graph.html b/classegoa_1_1_dynamic_graph.html new file mode 100644 index 00000000..69d766eb --- /dev/null +++ b/classegoa_1_1_dynamic_graph.html @@ -0,0 +1,4127 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::DynamicGraph< VertexProperties, EdgeProperties > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::DynamicGraph< VertexProperties, EdgeProperties > Class Template Reference
+
+
+ +

A graph data structure that supports adding and removing vertices and edges. + More...

+ +

#include <DynamicGraph.hpp>

+ + + + + +

+Classes

class  OmittingVectorView
 A view on a vector, in which some elements are invalid. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using TGraph = DynamicGraph< VertexProperties, EdgeProperties >
 
using TVertexProperties = VertexProperties
 
using TVertex = Vertices::Vertex< TVertexProperties >
 
using TVertexId = Types::vertexId
 
using TEdgeProperties = EdgeProperties
 
using TEdge = Edges::Edge< TEdgeProperties >
 
using TEdgeId = Types::edgeId
 
using TVerticesView = OmittingVectorView< TVertex, false >
 
using TConstVerticesView = OmittingVectorView< TVertex, true >
 
using TEdgesView = OmittingVectorView< TEdge, false >
 
using TConstEdgesView = OmittingVectorView< TEdge, true >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 DynamicGraph (Types::name name="")
 The constructor.
 
Getter and setter
Types::name Name () const
 The name of the graph.
 
Types::count NumberOfVertices () const
 The number of vertices $n = |\vertices|$ in the graph.
 
Types::count NumberOfEdges () const
 The number of edges $m = |\edges|$ in the graph.
 
Vertex related methods
TVerticesView Vertices ()
 A view on the vertices.
 
TConstVerticesView Vertices () const
 A view on the vertices.
 
bool VertexExists (Types::vertexId id) const
 Whether a vertex with identifier id exists in the graph.
 
TVertex & VertexAt (Types::vertexId id)
 The vertex with identifier id.
 
TVertex const & VertexAt (Types::vertexId id) const
 The vertex with identifier id.
 
+TVertex & VertexAt (int id)=delete
 
+TVertex & VertexAt (char id)=delete
 
+const TVertex & VertexAt (int id) const =delete
 
+const TVertex & VertexAt (char id) const =delete
 
Types::vertexId VertexId (TVertex const &vertex) const
 The vertex identifier of a vertex object.
 
Types::vertexId AddVertex (TVertexProperties &properties)
 Adds a vertex.
 
Types::vertexId AddVertex (TVertexProperties const &properties)
 Adds a vertex.
 
Types::vertexId AddVertex (TVertexProperties &&properties)
 Adds a vertex.
 
void RemoveVertexAt (Types::vertexId id)
 Remove a vertex and all incident edges.
 
template<typename FUNCTION >
auto MapVertices (FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>
 Applies function to all vertices and collects the result in a vector.
 
std::vector< Types::vertexId > NeighborsOf (Types::vertexId id) const
 Neighbors of a vertex.
 
void NeighborsOf (Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const
 Neighbors of a vertex.
 
Types::count InDegreeAt (Types::vertexId id) const
 The indegree of the vertex with identifier id.
 
Types::count OutDegreeAt (Types::vertexId id) const
 The outdegree of the vertex with identifier id.
 
Types::count DegreeAt (Types::vertexId id) const
 The degree of the vertex with identifier id.
 
std::vector< Types::edgeId > const & InEdgeIdsAt (Types::vertexId id) const
 The identifiers of all incoming edges.
 
std::vector< Types::edgeId > const & OutEdgeIdsAt (Types::vertexId id) const
 The identifiers of all outgoing edges.
 
std::vector< Types::edgeId > EdgeIdsAt (Types::vertexId id) const
 All edge identifiers of edges incident to a vertex.
 
void EdgeIdsAt (Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const
 All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.
 
Edge Related Methods
TEdgesView Edges ()
 A view on the edges.
 
TConstEdgesView Edges () const
 A view on the edges.
 
bool EdgeExists (Types::edgeId id) const
 Whether an edge with identifier id exists.
 
TEdge & EdgeAt (Types::edgeId id)
 The edge with identifier id.
 
TEdge const & EdgeAt (Types::edgeId id) const
 The edge with identifier id.
 
Types::edgeId EdgeId (Types::vertexId source, Types::vertexId target) const
 Searches for the identifier of the edge $(\vertexa, + \vertexb)$.
 
TEdge & Edge (Types::vertexId source, Types::vertexId target)
 Searches for an edge $(\vertexa, \vertexb)$.
 
const TEdge & Edge (Types::vertexId source, Types::vertexId target) const
 Searches for an edge $(\vertexa, \vertexb)$.
 
Types::edgeId AddEdge (Types::vertexId source, Types::vertexId target, TEdgeProperties &properties)
 Adds an edge to the set of edges $\edges$.
 
Types::edgeId AddEdge (Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)
 Adds an edge to the set of edges $\edges$.
 
Types::edgeId AddEdge (Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)
 Adds an edge to the set of edges $\edges$.
 
void RemoveEdgeAt (Types::edgeId id)
 Removes the edge with identifier id.
 
void RemoveAllIncidentEdgesAt (Types::vertexId id)
 Removes all incident edges at the vertex with identifier id.
 
template<typename FUNCTION >
auto MapEdges (FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>
 Applies function to all edges and collects the result in a vector.
 
+TEdge & EdgeAt (int index)=delete
 
+TEdge & EdgeAt (char index)=delete
 
+const TEdge & EdgeAt (int index) const =delete
 
+const TEdge & EdgeAt (char index) const =delete
 
+Types::edgeId EdgeId (int source, int target) const =delete
 
+Types::edgeId EdgeId (char source, char target) const =delete
 
+Types::edgeId EdgeId (int source, char target) const =delete
 
+Types::edgeId EdgeId (char source, int target) const =delete
 
+TEdge & Edge (int source, int target)=delete
 
+TEdge & Edge (char source, char target)=delete
 
+TEdge & Edge (char source, int target)=delete
 
+TEdge & Edge (int source, char target)=delete
 
+const TEdge & Edge (int source, int target) const =delete
 
+const TEdge & Edge (char source, char target) const =delete
 
+const TEdge & Edge (int source, char target) const =delete
 
+const TEdge & Edge (char source, int target) const =delete
 
Update Methods
void UpdateVertices ()
 Update vertices.
 
void UpdateEdges ()
 Deletes all edges that were marked as deleted.
 
Graph Properties
Types::count MinDegree (Types::vertexId &id) const
 The minimum degree of the graph $\graph$.
 
Types::count MinDegree () const
 The minimum degree of the graph $\graph$.
 
Types::count MaxDegree (Types::vertexId &id) const
 The maximum degree of the graph $\graph$.
 
Types::count MaxDegree () const
 The maximum degree of the graph $\graph$.
 
Vertex Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_identifiers (FUNCTION function) const
 The for loop over all vertex identifiers in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertices (FUNCTION function)
 The for loop over all vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertices (FUNCTION function) const
 The for loop over all vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_tuples (FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_tuples (FUNCTION function) const
 The for loop over all pairs of vertex identifiers and vertex objects in the graph.
 
Edge loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_identifiers (FUNCTION function) const
 The for loop over all indentifiers of edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges (FUNCTION function)
 The for loop over all edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges (FUNCTION function) const
 The for loop over all edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_tuples (FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_tuples (FUNCTION function) const
 The for loop over all pairs of edge identifiers and edge objects in the graph.
 
Neighborhood Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex object.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all edges at a vertex object.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all edges at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all edges at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all outgoing edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all outgoing edges.
 
+ + + + + + + + + + + + + + + + + + + +

+Private Attributes

Types::name name_
 
std::vector< TVertex > vertices_
 
std::vector< bool > vertexExists_
 
Types::count numberOfVertices_ = 0
 
std::vector< TEdge > edges_
 
std::vector< bool > edgeExists_
 
Types::count numberOfEdges_ = 0
 
std::vector< std::vector< Types::edgeId > > inEdgeIds_
 
std::vector< std::vector< Types::edgeId > > outEdgeIds_
 
+

Detailed Description

+
template<typename VertexProperties, typename EdgeProperties>
+class egoa::DynamicGraph< VertexProperties, EdgeProperties >

A graph data structure that supports adding and removing vertices and edges.

+

Both VertexProperties and EdgeProperties must be able to store an identifier, which can be accessed in the following way. Here, vertex and constVertex are objects of type VertexProperties and VertexProperties const, respectively, and vId is of type Types::vertexId. Similarly, edge and constEdge are objects of type EdgeProperties and EdgeProperties const, respectively, and eId is of type Types::edgeId.

+ + + + + + + + + + + + + + + +
Operation Effect
vertex.Identifier() = vId;
+
egoa::DynamicGraph::for_all_vertex_identifiers
void for_all_vertex_identifiers(FUNCTION function) const
The for loop over all vertex identifiers in the graph.
Definition DynamicGraph.hpp:1106
+
The identifier of vertex is set to vId.
Types::vertexId vId = constVertex.Identifier();
+
vId is set to the identifier of vertex.
edge.Identifier() = eId;
+
The identifier of edge is set to eId.
Types::edgeId eId = constEdge.Identifier();
+
eId is set to the identifier of edge.
Types::vertexId vId = constEdge.Source();
+
vId is set to the identifier of the source of edge.
Types::vertexId vId = constEdge.Target();
+
vId is set to the identifier of the target of edge.
+
Template Parameters
+ + + +
VertexPropertiesThe type of the vertices.
EdgePropertiesThe type of the edges.
+
+
+ +

Definition at line 50 of file DynamicGraph.hpp.

+

Member Typedef Documentation

+ +

◆ TConstEdgesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TConstEdgesView = OmittingVectorView<TEdge, true>
+
+ +

Definition at line 68 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TConstVerticesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TConstVerticesView = OmittingVectorView<TVertex, true>
+
+ +

Definition at line 66 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TEdge = Edges::Edge<TEdgeProperties>
+
+ +

Definition at line 62 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TEdgeId

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TEdgeId = Types::edgeId
+
+ +

Definition at line 63 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TEdgeProperties = EdgeProperties
+
+ +

Definition at line 61 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TEdgesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TEdgesView = OmittingVectorView<TEdge, false>
+
+ +

Definition at line 67 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TGraph = DynamicGraph<VertexProperties, EdgeProperties>
+
+ +

Definition at line 55 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TVertex = Vertices::Vertex<TVertexProperties>
+
+ +

Definition at line 58 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TVertexId = Types::vertexId
+
+ +

Definition at line 59 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TVertexProperties = VertexProperties
+
+ +

Definition at line 57 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TVerticesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::TVerticesView = OmittingVectorView<TVertex, false>
+
+ +

Definition at line 65 of file DynamicGraph.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ DynamicGraph()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
egoa::DynamicGraph< VertexProperties, EdgeProperties >::DynamicGraph (Types::name name = "")
+ 		+inlineexplicit
+
+ +

The constructor.

+
Parameters
+ + +
[in]nameThe name of the graph. The default value is "".
+
+
+ +

Definition at line 75 of file DynamicGraph.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddEdge() [1/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddEdge (Types::vertexId source,
Types::vertexId target,
TEdgeProperties && properties 
)
+ 		+inline
+
+ +

Adds an edge to the set of edges $\edges$.

+
Precondition
Source and target of the edge are existing vertices.
+
Parameters
+ + + + +
[in]sourceThe source vertex identifier.
[in]targetThe target vertex identifier.
propertiesThe vertex properties.
+
+
+
Returns
The edge identifier.
+ +

Definition at line 689 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ AddEdge() [2/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddEdge (Types::vertexId source,
Types::vertexId target,
TEdgeProperties & properties 
)
+ 		+inline
+
+ +

Adds an edge to the set of edges $\edges$.

+

The identifier of the edge passed as argument is set to the ID of the edge in the graph.

+
Precondition
Source and target of the edge are existing vertices.
+
Parameters
+ + +
edgeThe edge object.
+
+
+
Returns
The edge identifier.
+ +

Definition at line 649 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddEdge(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ AddEdge() [3/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddEdge (Types::vertexId source,
Types::vertexId target,
TEdgeProperties const & properties 
)
+ 		+inline
+
+ +

Adds an edge to the set of edges $\edges$.

+
Precondition
Source and target of the edge are existing vertices.
+
Parameters
+ + + + +
[in]sourceThe source vertex identifier.
[in]targetThe target vertex identifier.
propertiesThe vertex properties.
+
+
+
Returns
The edge identifier.
+ +

Definition at line 669 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddEdge(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ AddVertex() [1/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddVertex (TVertexProperties && properties)
+ 		+inline
+
+ +

Adds a vertex.

+
Parameters
+ + +
propertiesThe vertex properties.
+
+
+
Returns
The identifier of the vertex.
+ +

Definition at line 228 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ AddVertex() [2/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddVertex (TVertexProperties & properties)
+ 		+inline
+
+ +

Adds a vertex.

+

The identifier of the vertex passed as argument is set to the identifier of the vertex in the graph.

+
Parameters
+ + +
propertiesThe vertex properties.
+
+
+
Returns
The identifier of the vertex.
+ +

Definition at line 204 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddVertex(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ AddVertex() [3/3]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddVertex (TVertexProperties const & properties)
+ 		+inline
+
+ +

Adds a vertex.

+
Parameters
+ + +
propertiesThe vertex properties.
+
+
+
Returns
The identifier of the vertex.
+ +

Definition at line 216 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::AddVertex(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ DegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::DegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The degree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of incident edges.
+ +

Definition at line 389 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::InDegreeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutDegreeAt(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ Edge() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TEdge & egoa::DynamicGraph< VertexProperties, EdgeProperties >::Edge (Types::vertexId source,
Types::vertexId target 
)
+ 		+inline
+
+ +

Searches for an edge $(\vertexa, \vertexb)$.

+
Precondition
Both source and target are identifiers of existing vertices, and there is an edge from source to target.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa, \vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa, \vertexb)$.
+
+
+
Returns
The edge $(\vertexa, \vertexb)$.
+ +

Definition at line 602 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeId(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ Edge() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
const TEdge & egoa::DynamicGraph< VertexProperties, EdgeProperties >::Edge (Types::vertexId source,
Types::vertexId target 
) const
+ 		+inline
+
+ +

Searches for an edge $(\vertexa, \vertexb)$.

+
Precondition
Both source and target are identifiers of existing vertices, and there is an edge from source to target.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa, \vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa, \vertexb)$.
+
+
+
Returns
The edge $(\vertexa, \vertexb)$.
+ +

Definition at line 627 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeId(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TEdge & egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt (Types::edgeId id)
+ 		+inline
+
+ +

The edge with identifier id.

+
Precondition
The edge with identifier id exists.
+
Parameters
+ + +
[in]idThe edge identifier.
+
+
+
Returns
The edge object with identifier id.
+ +

Definition at line 528 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ EdgeAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TEdge const & egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt (Types::edgeId id) const
+ 		+inline
+
+ +

The edge with identifier id.

+
Precondition
The edge with identifier id exists.
+
Parameters
+ + +
[in]idThe edge identifier.
+
+
+
Returns
The edge object with identifier id.
+ +

Definition at line 543 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ EdgeExists()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
bool egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeExists (Types::edgeId id) const
+ 		+inline
+
+ +

Whether an edge with identifier id exists.

+

Time complexity: $O(1)$.

+
Parameters
+ + +
[in]idThe edge identifier.
+
+
+
Returns
true if an edge with identifier id exists, false otherwise.
+ +

Definition at line 514 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ EdgeId()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeId (Types::vertexId source,
Types::vertexId target 
) const
+ 		+inline
+
+ +

Searches for the identifier of the edge $(\vertexa, + \vertexb)$.

+

If no such edge exists, Const::NONE is returned.

+
Precondition
Both source and target are identifiers of existing vertices.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa,\vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa,\vertexb)$.
+
+
+
Returns
The edge identifier, or Const::NONE if the edge does not exist.
+ +

Definition at line 564 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::InDegreeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutDegreeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeIdsAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

All edge identifiers of edges incident to a vertex.

+

The order of the identifiers is unspecified.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The edge identifiers at a vertex id.
+ +

Definition at line 435 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeIdsAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeIdsAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeIdsAt (Types::vertexId id,
std::vector< Types::edgeId > & edgeIds 
) const
+ 		+inline
+
+ +

All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.

+

The order of the identifiers is unspecified.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + + +
[in]idThe vertex id
edgeIdsThe vector to which the edge identifiers are appended.
+
+
+ +

Definition at line 454 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ Edges() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TEdgesView egoa::DynamicGraph< VertexProperties, EdgeProperties >::Edges ()
+ 		+inline
+
+ +

A view on the edges.

+

The edges can be modified via this view. 

        If an edge is added or removed, the view is still valid but
+        the iterators obtained via this view are invalid.
+
+        If the graph is destroyed, all views are invalid and calling
+        member functions on them has undefined behavior.
+
+

Definition at line 481 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_.

+ +
+
+ +

◆ Edges() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TConstEdgesView egoa::DynamicGraph< VertexProperties, EdgeProperties >::Edges () const
+ 		+inline
+
+ +

A view on the edges.

+

The edges cannot be modified via this view. 

        If an edge is added or removed, the view is still valid but
+        the iterators obtained via this view are invalid.
+
+        If the graph is destroyed, all views are invalid and calling
+        member functions on them has undefined behavior.
+
+

Definition at line 498 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_.

+ +
+
+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edge_identifiers (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all indentifiers of edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
[]( Types::edgeId edgeId )
+
{
+
// Do something with the edge identifier.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1235 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edge_tuples() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edge_tuples (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
egoa::Edges::Edge
Class for edge.
Definition Edge.hpp:27
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1308 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edge_tuples() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edge_tuples (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1333 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy..
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1259 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1283 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all edges at a vertex object.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1364 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all edges at a vertex object.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1390 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all edges at a vertex.

+

This is a loop over incoming and outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1419 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_all_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_edges_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all edges at a vertex.

+

This is a loop over incoming and outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1449 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all vertex identifiers in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type Types::vertexId e.g.,
[]( Types::vertexId vertexId )
+
{
+
// Do something with the vertex identifier.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1106 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertex_tuples() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_tuples (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all pairs of vertex identifiers and vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TVertex, e.g.,
[]( Types::vertexId id, TVertex const & vertex )
+
{
+
// Do something with the vertex identifier and object.
+
}
+
egoa::Vertices::Vertex
Class for a vertex.
Definition Vertex.hpp:29
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1180 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertex_tuples() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_tuples (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all pairs of vertex identifiers and vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TVertex, e.g.,
[]( Types::vertexId id, TVertex const & vertex )
+
{
+
// Do something with the vertex identifier and object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1206 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertices() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertices (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type TVertex e.g.,
[]( TVertex & vertex )
+
{
+
// Do something with the vertex object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1130 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertices() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertices (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type TVertex e.g.,
[]( TVertex const & vertex )
+
{
+
// Do something with the vertex object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1154 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_in_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId
+
+
+ +

Definition at line 1477 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_in_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId
+
+
+ +

Definition at line 1503 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_in_edges_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe identifier of the vertex
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId.
+
+
+ +

Definition at line 1532 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_in_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_in_edges_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe identifier of the vertex
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId.
+
+
+ +

Definition at line 1562 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_out_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_out_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all outgoing edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1590 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_out_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_out_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all outgoing edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1617 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_out_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_out_edges_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1646 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_out_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_out_edges_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1676 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ InDegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::InDegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The indegree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of incoming edges.
+ +

Definition at line 359 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ InEdgeIdsAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > const & egoa::DynamicGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

The identifiers of all incoming edges.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The identifiers of the incoming edges at vertex id.
+ +

Definition at line 404 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ MapEdges()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
auto egoa::DynamicGraph< VertexProperties, EdgeProperties >::MapEdges (FUNCTION function) const -> std::vector<decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()))> +
+ 		+inline
+
+ +

Applies function to all edges and collects the result in a vector.

+
Parameters
+ + +
[in]functionThe function that is applied to all edges.
TResult function(Types::edgeId, TEdge)
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+
Returns
A vector containing the results of the applications of function to all edges.
+ +

Definition at line 799 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ MapVertices()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
auto egoa::DynamicGraph< VertexProperties, EdgeProperties >::MapVertices (FUNCTION function) const -> std::vector<decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()))> +
+ 		+inline
+
+ +

Applies function to all vertices and collects the result in a vector.

+
Parameters
+ + +
[in]functionThe function that is applied to all edges.
TResult function(Types::vertexId, TVertex)
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+
Returns
A vector containing the results of the applications of function to all vertices.
+ +

Definition at line 277 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ MaxDegree() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::MaxDegree () const
+ 		+inline
+
+ +

The maximum degree of the graph $\graph$.

+

The maximum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Returns
The maximum degree.
+ +

Definition at line 1076 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::MaxDegree().

+ +
+
+ +

◆ MaxDegree() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::MaxDegree (Types::vertexId & id) const
+ 		+inline
+
+ +

The maximum degree of the graph $\graph$.

+

The maximum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Parameters
+ + +
[in/out]id The vertex identifier with the maximum degree. If there are multiple vertices with the maximum degree, the one with the smallest identifier is returned. If the graph is empty, id is set to Const::NONE.
+
+
+
Returns
The maximum degree.
+ +

Definition at line 1050 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::DegreeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::Vertices().

+ +
+
+ +

◆ MinDegree() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::MinDegree () const
+ 		+inline
+
+ +

The minimum degree of the graph $\graph$.

+

The minimum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Returns
The minimum degree.
+ +

Definition at line 1031 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::MinDegree().

+ +
+
+ +

◆ MinDegree() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::MinDegree (Types::vertexId & id) const
+ 		+inline
+
+ +

The minimum degree of the graph $\graph$.

+

The minimum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Parameters
+ + +
[in/out]id The vertex identifier with the minimum degree. If there are multiple vertices with the minimum degree, the one with the smallest identifier is returned. If the graph is empty, id is set to Const::NONE.
+
+
+
Returns
The minimum degree.
+ +

Definition at line 1004 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::DegreeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::Vertices().

+ +
+
+ +

◆ Name()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::name egoa::DynamicGraph< VertexProperties, EdgeProperties >::Name () const
+ 		+inline
+
+ +

The name of the graph.

+ +

Definition at line 85 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::name_.

+ +
+
+ +

◆ NeighborsOf() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::vertexId > egoa::DynamicGraph< VertexProperties, EdgeProperties >::NeighborsOf (Types::vertexId id) const
+ 		+inline
+
+ +

Neighbors of a vertex.

+

A vector containing the identifiers of the neighbors of the given vertex is returned. The order of the neighbors is unspecified.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe id of a vertex
+
+
+
Returns
The vertex identifiers of all neighbors.
+ +

Definition at line 305 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::NeighborsOf(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ NeighborsOf() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::NeighborsOf (Types::vertexId id,
std::vector< Types::vertexId > & vertexIds 
) const
+ 		+inline
+
+ +

Neighbors of a vertex.

+

The neighbors of the vertex are appended to the vector vertexId. The order of the neighbors is unspecified.

+

Time complexity: $O(|\vertices|)$.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + + +
[in]idThe vertex identifier.
vertexIdsThe vector to which the identifiers of the neighbors are appended.
+
+
+ +

Definition at line 327 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ NumberOfEdges()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfEdges () const
+ 		+inline
+
+ +

The number of edges $m = |\edges|$ in the graph.

+ +

Definition at line 93 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_.

+ +
+
+ +

◆ NumberOfVertices()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfVertices () const
+ 		+inline
+
+ +

The number of vertices $n = |\vertices|$ in the graph.

+ +

Definition at line 89 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_.

+ +
+
+ +

◆ OutDegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutDegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The outdegree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of outgoing edges.
+ +

Definition at line 374 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ OutEdgeIdsAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > const & egoa::DynamicGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

The identifiers of all outgoing edges.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The identifiers of the outgoing edges at vertex id.
+ +

Definition at line 419 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ RemoveAllIncidentEdgesAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::RemoveAllIncidentEdgesAt (Types::vertexId id)
+ 		+inline
+
+ +

Removes all incident edges at the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
idThe identifier of the vertex.
+
+
+ +

Definition at line 747 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ RemoveEdgeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::RemoveEdgeAt (Types::edgeId id)
+ 		+inline
+
+ +

Removes the edge with identifier id.

+
Precondition
There is an edge with identifier id in the graph.
+
Parameters
+ + +
idThe identifier of the edge.
+
+
+ +

Definition at line 722 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_.

+ +
+
+ +

◆ RemoveVertexAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::RemoveVertexAt (Types::vertexId id)
+ 		+inline
+
+ +

Remove a vertex and all incident edges.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
idThe identifier of the vertex to remove.
+
+
+ +

Definition at line 253 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::RemoveAllIncidentEdgesAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_.

+ +
+
+ +

◆ UpdateEdges()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::UpdateEdges ()
+ 		+inline
+
+ +

Deletes all edges that were marked as deleted.

+

Afterwards, the edges use the identifiers between 0 and $m-1$. 

    Time complexity: @f$O(1)@f$ if no edge is marked as deleted,
+                     @f$O(|\edges|)@f$ otherwise. Here,
+                     @f$\edges@f$ includes both active
+                     edges and edges that were marked as
+                     deleted.
+
+

Definition at line 918 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::Edges(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfEdges(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_.

+ +
+
+ +

◆ UpdateVertices()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
void egoa::DynamicGraph< VertexProperties, EdgeProperties >::UpdateVertices ()
+ 		+inline
+
+ +

Update vertices.

+

Shrink vertex array

+ +

Definition at line 842 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_, egoa::Edges::Edge< PropertiesType >::source_, egoa::Edges::Edge< PropertiesType >::target_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ VertexAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TVertex & egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexAt (Types::vertexId id)
+ 		+inline
+
+ +

The vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+

param[in] id The identifier of the vertex.

+
Returns
The vertex object.
+ +

Definition at line 155 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ VertexAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TVertex const & egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexAt (Types::vertexId id) const
+ 		+inline
+
+ +

The vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+

param[in] id The identifier of the vertex.

+
Returns
The vertex object.
+ +

Definition at line 170 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ VertexExists()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
bool egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexExists (Types::vertexId id) const
+ 		+inline
+
+ +

Whether a vertex with identifier id exists in the graph.

+
Parameters
+ + +
[in]idThe identifier of the vertex.
+
+
+
Returns
true if a vertex with identifier id exists, false otherwise.
+ +

Definition at line 141 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_.

+ +
+
+ +

◆ VertexId()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::DynamicGraph< VertexProperties, EdgeProperties >::VertexId (TVertex const & vertex) const
+ 		+inline
+
+ +

The vertex identifier of a vertex object.

+

Calls vertex.Identifier().

+
Parameters
+ + +
vertexThe vertex.
+
+
+
Returns
The vertex identifier.
+ +

Definition at line 190 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ Vertices() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TVerticesView egoa::DynamicGraph< VertexProperties, EdgeProperties >::Vertices ()
+ 		+inline
+
+ +

A view on the vertices.

+

The vertices can be modified via this view. 

        If a vertex is added or removed, the view is still valid but
+        the iterators obtained via this view are invalid.
+
+        If the graph is destroyed, all views are invalid and calling
+        member functions on them has undefined behavior.
+
+

Definition at line 109 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ Vertices() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TConstVerticesView egoa::DynamicGraph< VertexProperties, EdgeProperties >::Vertices () const
+ 		+inline
+
+ +

A view on the vertices.

+

The vertices cannot be modified via this view. 

        If a vertex is added or removed, the view is still valid but
+        the iterators obtained via this view are invalid.
+
+        If the graph is destroyed, all views are invalid and calling
+        member functions on them has undefined behavior.
+
+

Definition at line 126 of file DynamicGraph.hpp.

+ +

References egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_, egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_, and egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+

Member Data Documentation

+ +

◆ edgeExists_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<bool> egoa::DynamicGraph< VertexProperties, EdgeProperties >::edgeExists_
+ 		+private
+
+

Exists edge for lazy updating

+ +

Definition at line 1820 of file DynamicGraph.hpp.

+ +
+
+ +

◆ edges_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<TEdge> egoa::DynamicGraph< VertexProperties, EdgeProperties >::edges_
+ 		+private
+
+

Vector of edges

+ +

Definition at line 1819 of file DynamicGraph.hpp.

+ +
+
+ +

◆ inEdgeIds_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector< std::vector<Types::edgeId> > egoa::DynamicGraph< VertexProperties, EdgeProperties >::inEdgeIds_
+ 		+private
+
+

Ids of the incoming edges per vertex

+ +

Definition at line 1823 of file DynamicGraph.hpp.

+ +
+
+ +

◆ name_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
Types::name egoa::DynamicGraph< VertexProperties, EdgeProperties >::name_
+ 		+private
+
+

Name of the graph

+ +

Definition at line 1813 of file DynamicGraph.hpp.

+ +
+
+ +

◆ numberOfEdges_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfEdges_ = 0
+ 		+private
+
+

Number of edges

+ +

Definition at line 1821 of file DynamicGraph.hpp.

+ +
+
+ +

◆ numberOfVertices_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::numberOfVertices_ = 0
+ 		+private
+
+

Number of vertices

+ +

Definition at line 1817 of file DynamicGraph.hpp.

+ +
+
+ +

◆ outEdgeIds_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector< std::vector<Types::edgeId> > egoa::DynamicGraph< VertexProperties, EdgeProperties >::outEdgeIds_
+ 		+private
+
+

Ids of the outgoing edges per vertex

+ +

Definition at line 1824 of file DynamicGraph.hpp.

+ +
+
+ +

◆ vertexExists_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<bool> egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertexExists_
+ 		+private
+
+

Exists vertex for lazy updating

+ +

Definition at line 1816 of file DynamicGraph.hpp.

+ +
+
+ +

◆ vertices_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<TVertex> egoa::DynamicGraph< VertexProperties, EdgeProperties >::vertices_
+ 		+private
+
+

Vector of vertices

+ +

Definition at line 1815 of file DynamicGraph.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view-members.html b/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view-members.html new file mode 100644 index 00000000..f8043390 --- /dev/null +++ b/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view-members.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const > Member List
+
+
+ +

This is the complete list of members for egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
begin() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
counter_ (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
elementVector_ (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
empty() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
end() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
existsVector_ (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
OmittingVectorView(TVector *elementVector, std::vector< bool > const *existsVector, Types::count const *counter)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inlineexplicit
operator[](Types::index index) const (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
rbegin() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
rend() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
size() const noexcept (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >inline
TElement typedef (defined in egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >)egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
TIterator typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >
TReference typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >
TReverseIterator typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >
TUnderlyingIterator typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
TUnderlyingReverseIterator typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
TVector typedefegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html b/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html new file mode 100644 index 00000000..81968391 --- /dev/null +++ b/classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html @@ -0,0 +1,704 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Types | +Private Attributes | +List of all members
+
egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const > Class Template Reference
+
+
+ +

A view on a vector, in which some elements are invalid. + More...

+ + + + + + + + +

+Public Types

using TIterator = OmittingIterator< TUnderlyingIterator, typename std::vector< bool >::const_iterator >
 
using TReverseIterator = OmittingIterator< TUnderlyingReverseIterator, typename std::vector< bool >::const_reverse_iterator >
 
using TReference = typename std::conditional< Const, TElement const &, TElement & >::type
 
+ + + + + + + + + + + + + + + + + + +

+Public Member Functions

 OmittingVectorView (TVector *elementVector, std::vector< bool > const *existsVector, Types::count const *counter)
 Constructs a view to the vector pointed to by elementVector.
 
TIterator begin () const noexcept
 
TIterator end () const noexcept
 
TReverseIterator rbegin () const noexcept
 
TReverseIterator rend () const noexcept
 
bool empty () const noexcept
 
Types::count size () const noexcept
 
TReference operator[] (Types::index index) const
 
+ + + + + + + + + +

+Private Types

using TElement = ElementType
 
using TVector = typename std::conditional< Const, std::vector< TElement > const, std::vector< TElement > >::type
 
using TUnderlyingIterator = typename std::conditional< Const, typename TVector::const_iterator, typename TVector::iterator >::type
 
using TUnderlyingReverseIterator = typename std::conditional< Const, typename TVector::const_reverse_iterator, typename TVector::reverse_iterator >::type
 
+ + + + + + + +

+Private Attributes

TVector * elementVector_
 
std::vector< bool > const * existsVector_
 
Types::count const * counter_
 
+

Detailed Description

+
template<typename VertexProperties, typename EdgeProperties>
+template<typename ElementType, bool Const>
+class egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >

A view on a vector, in which some elements are invalid.

+

To distiguish between valid and invalid elements, a std::vector<bool> is given.

+
Template Parameters
+ + + +
ElementType{ description }
Const{ description }
+
+
+ +

Definition at line 1696 of file DynamicGraph.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TElement = ElementType
+ 		+private
+
+ +

Definition at line 1698 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TIterator

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TIterator = OmittingIterator< TUnderlyingIterator, typename std::vector<bool>::const_iterator>
+
+

The type of the iterator.

+ +

Definition at line 1724 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TReference

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TReference = typename std::conditional<Const, TElement const &, TElement & >::type
+
+

The type of references to the element.

+ +

Definition at line 1736 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TReverseIterator

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TReverseIterator = OmittingIterator< TUnderlyingReverseIterator, typename std::vector<bool>::const_reverse_iterator>
+
+

The type of the reverse iterator.

+ +

Definition at line 1730 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TUnderlyingIterator

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TUnderlyingIterator = typename std::conditional<Const, typename TVector::const_iterator, typename TVector::iterator >::type
+ 		+private
+
+

The type of the iterators of the underlying vector.

+ +

Definition at line 1709 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TUnderlyingReverseIterator

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TUnderlyingReverseIterator = typename std::conditional<Const, typename TVector::const_reverse_iterator, typename TVector::reverse_iterator >::type
+ 		+private
+
+

The type of the reverse iterators of the underlying vector.

+ +

Definition at line 1716 of file DynamicGraph.hpp.

+ +
+
+ +

◆ TVector

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::TVector = typename std::conditional<Const, std::vector<TElement> const, std::vector<TElement> >::type
+ 		+private
+
+

The type of the underlying vector.

+ +

Definition at line 1702 of file DynamicGraph.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ OmittingVectorView()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::OmittingVectorView (TVector * elementVector,
std::vector< bool > const * existsVector,
Types::count const * counter 
)
+ 		+inlineexplicit
+
+ +

Constructs a view to the vector pointed to by elementVector.

+

Elements for which the corresponding entry of existsVector is false are omitted.

+
Parameters
+ + + + +
elementVectorThe vector of all elements.
existsVectorThe vector that indicates for each element whether it is valid.
counterA pointer to a counter that counts the number of valid elements.
+
+
+ +

Definition at line 1752 of file DynamicGraph.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TIterator egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1760 of file DynamicGraph.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
bool egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::empty () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1788 of file DynamicGraph.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TIterator egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1767 of file DynamicGraph.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + + +
TReference egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::operator[] (Types::index index) const
+ 		+inline
+
+ +

Definition at line 1791 of file DynamicGraph.hpp.

+ +
+
+ +

◆ rbegin()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TReverseIterator egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1774 of file DynamicGraph.hpp.

+ +
+
+ +

◆ rend()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TReverseIterator egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1781 of file DynamicGraph.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
Types::count egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1789 of file DynamicGraph.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ counter_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
Types::count const* egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::counter_
+ 		+private
+
+ +

Definition at line 1800 of file DynamicGraph.hpp.

+ +
+
+ +

◆ elementVector_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
TVector* egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::elementVector_
+ 		+private
+
+ +

Definition at line 1798 of file DynamicGraph.hpp.

+ +
+
+ +

◆ existsVector_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
std::vector<bool> const* egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >::existsVector_
+ 		+private
+
+ +

Definition at line 1799 of file DynamicGraph.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation.html b/classegoa_1_1_edges_1_1_carrier_differentiation.html new file mode 100644 index 00000000..e5329be5 --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::CarrierDifferentiation< CarrierType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::CarrierDifferentiation< CarrierType > Class Template Reference
+
+
+

Detailed Description

+
template<Edges::CarrierDifferentiationType CarrierType>
+class egoa::Edges::CarrierDifferentiation< CarrierType >
+

Definition at line 21 of file ElectricalProperties.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4-members.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4-members.html new file mode 100644 index 00000000..e895f1ca --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC > Member List
+
+
+ +

This is the complete list of members for egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >, including all inherited members.

+ + + + +
Conductance(TEdge const &edge)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >inlinestatic
Susceptance(TEdge const &edge)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >inlinestatic
TEdge typedef (defined in egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html new file mode 100644 index 00000000..bc054a5f --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html @@ -0,0 +1,213 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC > Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC > Class Reference
+
+
+ + + + + + + + +

+Static Public Member Functions

static Types::real Conductance (TEdge const &edge)
 Conductance for the AC network.
 
static Types::real Susceptance (TEdge const &edge)
 Susceptance for the AC network.
 
+ + + +

+Private Types

typedef ElectricalProperties TEdge
 
+

Detailed Description

+
+

Definition at line 428 of file ElectricalProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TEdge

+ +
+
+ + + + + +
+ + + + +
typedef ElectricalProperties egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::TEdge
+ 		+private
+
+ +

Definition at line 429 of file ElectricalProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Conductance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Conductance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Conductance for the AC network.

+

This represents the "standard" conductance calculated by $r / (r^2 + x^2)$.

+
Parameters
+ + +
edgeThe edge
+
+
+
Returns
The AC conductance g(u, v)
+ +

Definition at line 440 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Susceptance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Susceptance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Susceptance for the AC network.

+

This represents the "standard" susceptance calculated by $x / (r^2 + x^2)$.

+

For more details see Zimmerman, R. D., & Murillo-s, C. E. (2011). Matpower 4.1 User’s Manual. Power Systems Engineering Research Center (Pserc). http://doi.org/http://www.pserc.cornell.edu/matpower/manual.pdf

+
Parameters
+ + +
edgeThe edge
+
+
+
Returns
The AC susceptance b(u, v)
+ +

Definition at line 465 of file ElectricalProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4-members.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4-members.html new file mode 100644 index 00000000..fd13544a --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC > Member List
+
+
+ +

This is the complete list of members for egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >, including all inherited members.

+ + + + +
Conductance(TEdge const &edge)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >inlinestatic
Susceptance(TEdge const &edge)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >inlinestatic
TEdge typedef (defined in egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html new file mode 100644 index 00000000..6c399e17 --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html @@ -0,0 +1,221 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC > Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC > Class Reference
+
+
+ +

Class for carrier differentiation. + More...

+ +

#include <ElectricalProperties.hpp>

+ + + + + + + + +

+Static Public Member Functions

static Types::real Conductance (TEdge const &edge)
 Conductance for the DC approximation of an AC network.
 
static Types::real Susceptance (TEdge const &edge)
 Susceptance for the DC approximation of an AC network.
 
+ + + +

+Private Types

typedef ElectricalProperties TEdge
 
+

Detailed Description

+

Class for carrier differentiation.

+

For the carrier differentiation we distinguish between DC and AC carrier. Dependent on the carrier the computation for the susceptance and conductance changes.

+ +

Definition at line 484 of file ElectricalProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TEdge

+ +
+
+ + + + + +
+ + + + +
typedef ElectricalProperties egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::TEdge
+ 		+private
+
+ +

Definition at line 485 of file ElectricalProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Conductance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Conductance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Conductance for the DC approximation of an AC network.

+

For the DC-Approximation the resistance becomes r = 0. Thus, the conductance term $r / (r^2 + x^2)$ becomes 0. Note that this is often overseen in other tools.

+
Parameters
+ + +
edgeThe edge.
+
+
+
Returns
Conductance g(u, v) of the DC approximation.
+ +

Definition at line 497 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Susceptance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Susceptance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Susceptance for the DC approximation of an AC network.

+

For the DC-Approximation r = 0. Thus, the term $x /(r^2 + + x^2)$ becomes $1 / x$. Note that this is often overseen in other tools.

+

For more details see Zimmerman, R. D., & Murillo-s, C. E. (2011). Matpower 4.1 User’s Manual. Power Systems Engineering Research Center (Pserc). http://doi.org/http://www.pserc.cornell.edu/matpower/manual.pdf

+
Parameters
+ + +
edgeThe edge.
+
+
+
Returns
Susceptance b(u, v) of the DC approximation.
+ +

Definition at line 518 of file ElectricalProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4-members.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4-members.html new file mode 100644 index 00000000..aacaa737 --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown > Member List
+
+
+ +

This is the complete list of members for egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >, including all inherited members.

+ + + + +
Conductance(TEdge const &edge) (defined in egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >inlinestatic
Susceptance(TEdge const &edge) (defined in egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >inlinestatic
TEdge typedef (defined in egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >)egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4.html b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4.html new file mode 100644 index 00000000..4a355d03 --- /dev/null +++ b/classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4.html @@ -0,0 +1,197 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown > Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown > Class Reference
+
+
+ +

Class for carrier differentiation. + More...

+ +

#include <ElectricalProperties.hpp>

+ + + + + + +

+Static Public Member Functions

static Types::real Conductance (TEdge const &edge)
 
static Types::real Susceptance (TEdge const &edge)
 
+ + + +

+Private Types

typedef ElectricalProperties TEdge
 
+

Detailed Description

+

Class for carrier differentiation.

+

Detailed information of the susceptance b and conductance g can be extracted from the data itself.

+ +

Definition at line 534 of file ElectricalProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TEdge

+ +
+
+ + + + + +
+ + + + +
typedef ElectricalProperties egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >::TEdge
+ 		+private
+
+ +

Definition at line 535 of file ElectricalProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Conductance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >::Conductance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Definition at line 537 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Susceptance()

+ +
+
+ + + + + +
+ + + + + + + + +
static Types::real egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >::Susceptance (TEdge const & edge)
+ 		+inlinestatic
+
+ +

Definition at line 541 of file ElectricalProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_edge-members.html b/classegoa_1_1_edges_1_1_edge-members.html new file mode 100644 index 00000000..917cd585 --- /dev/null +++ b/classegoa_1_1_edges_1_1_edge-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::Edge< PropertiesType > Member List
+
+
+ +

This is the complete list of members for egoa::Edges::Edge< PropertiesType >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
Edge(Types::edgeId identifier, Types::vertexId source, Types::vertexId target, TProperties properties) (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
egoa::DynamicGraph (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >friend
Identifier() const (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
identifier_egoa::Edges::Edge< PropertiesType >private
operator!=egoa::Edges::Edge< PropertiesType >friend
operator==egoa::Edges::Edge< PropertiesType >friend
Other(Types::vertexId vertexId) constegoa::Edges::Edge< PropertiesType >inline
Properties() (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
Properties() const (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
properties_egoa::Edges::Edge< PropertiesType >private
Source() const (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
source_egoa::Edges::Edge< PropertiesType >private
swapegoa::Edges::Edge< PropertiesType >friend
Target() const (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >inline
target_egoa::Edges::Edge< PropertiesType >private
TProperties typedef (defined in egoa::Edges::Edge< PropertiesType >)egoa::Edges::Edge< PropertiesType >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_edge.html b/classegoa_1_1_edges_1_1_edge.html new file mode 100644 index 00000000..ebb7d6d1 --- /dev/null +++ b/classegoa_1_1_edges_1_1_edge.html @@ -0,0 +1,708 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::Edge< PropertiesType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
egoa::Edges::Edge< PropertiesType > Class Template Reference
+
+
+ +

Class for edge. + More...

+ +

#include <Edge.hpp>

+ + + + +

+Public Types

using TProperties = PropertiesType
 
+ + + + + + + + + + + + + + + + + + +

+Public Member Functions

Types::vertexId Other (Types::vertexId vertexId) const
 Return the adjacent vertex to vertexId.
 
Constructors and Destructor
 Edge (Types::edgeId identifier, Types::vertexId source, Types::vertexId target, TProperties properties)
 
Getter and setter
Types::index Identifier () const
 
Types::vertexId Source () const
 
Types::vertexId Target () const
 
TProperties & Properties ()
 
TProperties const & Properties () const
 
+ + + + + + + + + + +

+Private Attributes

Member
Types::edgeId identifier_
 
Types::vertexId source_
 
Types::vertexId target_
 
TProperties properties_
 
+ + + + + + + + + + + + + + +

+Friends

template<typename , typename >
class egoa::DynamicGraph
 
void swap (Edge &lhs, Edge &rhs)
 Swap two edges.
 
Comparators
bool operator== (Edge const &lhs, Edge const &rhs)
 Comparator.
 
bool operator!= (Edge const &lhs, Edge const &rhs)
 Comparator.
 
+

Detailed Description

+
template<typename PropertiesType>
+class egoa::Edges::Edge< PropertiesType >

Class for edge.

+
Template Parameters
+ + +
PropertiesTypeThe type of the edge's properties.
+
+
+ +

Definition at line 27 of file Edge.hpp.

+

Member Typedef Documentation

+ +

◆ TProperties

+ +
+
+
+template<typename PropertiesType >
+ + + + +
using egoa::Edges::Edge< PropertiesType >::TProperties = PropertiesType
+
+ +

Definition at line 29 of file Edge.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Edge()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::Edges::Edge< PropertiesType >::Edge (Types::edgeId identifier,
Types::vertexId source,
Types::vertexId target,
TProperties properties 
)
+ 		+inline
+
+ +

Definition at line 35 of file Edge.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Identifier()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::index egoa::Edges::Edge< PropertiesType >::Identifier () const
+ 		+inline
+
+ +

Definition at line 49 of file Edge.hpp.

+ +
+
+ +

◆ Other()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::Edges::Edge< PropertiesType >::Other (Types::vertexId vertexId) const
+ 		+inline
+
+ +

Return the adjacent vertex to vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The vertex identifier of the adjacent vertex.
+ +

Definition at line 64 of file Edge.hpp.

+ +
+
+ +

◆ Properties() [1/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
TProperties & egoa::Edges::Edge< PropertiesType >::Properties ()
+ 		+inline
+
+ +

Definition at line 53 of file Edge.hpp.

+ +
+
+ +

◆ Properties() [2/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
TProperties const & egoa::Edges::Edge< PropertiesType >::Properties () const
+ 		+inline
+
+ +

Definition at line 54 of file Edge.hpp.

+ +
+
+ +

◆ Source()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::Edges::Edge< PropertiesType >::Source () const
+ 		+inline
+
+ +

Definition at line 50 of file Edge.hpp.

+ +
+
+ +

◆ Target()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::Edges::Edge< PropertiesType >::Target () const
+ 		+inline
+
+ +

Definition at line 51 of file Edge.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ egoa::DynamicGraph

+ +
+
+
+template<typename PropertiesType >
+
+template<typename , typename >
+ + + + + +
+ + + + +
friend class egoa::DynamicGraph
+ 		+friend
+
+ +

Definition at line 118 of file Edge.hpp.

+ +
+
+ +

◆ operator!=

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (Edge< PropertiesType > const & lhs,
Edge< PropertiesType > const & rhs 
)
+ 		+friend
+
+ +

Comparator.

+
Parameters
+ + + +
lhsThe left edge.
rhsThe right edge.
+
+
+
Returns
false if the edges are the same, true otherwise.
+ +

Definition at line 111 of file Edge.hpp.

+ +
+
+ +

◆ operator==

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (Edge< PropertiesType > const & lhs,
Edge< PropertiesType > const & rhs 
)
+ 		+friend
+
+ +

Comparator.

+
Parameters
+ + + +
lhsThe left edge.
rhsThe right edge.
+
+
+
Returns
true if the edges are the same, false otherwise.
+ +

Definition at line 95 of file Edge.hpp.

+ +
+
+ +

◆ swap

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (Edge< PropertiesType > & lhs,
Edge< PropertiesType > & rhs 
)
+ 		+friend
+
+ +

Swap two edges.

+
Parameters
+ + + +
lhsThe left hand side.
rhsThe right hand side.
+
+
+ +

Definition at line 75 of file Edge.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ identifier_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
Types::edgeId egoa::Edges::Edge< PropertiesType >::identifier_
+ 		+private
+
+

Unique identifier of the vertex.

+ +

Definition at line 123 of file Edge.hpp.

+ +
+
+ +

◆ properties_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
TProperties egoa::Edges::Edge< PropertiesType >::properties_
+ 		+private
+
+

Property of the vertex.
+

+ +

Definition at line 126 of file Edge.hpp.

+ +
+
+ +

◆ source_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
Types::vertexId egoa::Edges::Edge< PropertiesType >::source_
+ 		+private
+
+

The source vertex.

+ +

Definition at line 124 of file Edge.hpp.

+ +
+
+ +

◆ target_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
Types::vertexId egoa::Edges::Edge< PropertiesType >::target_
+ 		+private
+
+

The target vertex.

+ +

Definition at line 125 of file Edge.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Graphs/Edges/Edge.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_electrical_properties-members.html b/classegoa_1_1_edges_1_1_electrical_properties-members.html new file mode 100644 index 00000000..0e3245e4 --- /dev/null +++ b/classegoa_1_1_edges_1_1_electrical_properties-members.html @@ -0,0 +1,172 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Edges::ElectricalProperties Member List
+
+
+ +

This is the complete list of members for egoa::Edges::ElectricalProperties, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AngleShift() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
AngleShift() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
angleShift_egoa::Edges::ElectricalPropertiesprivate
CapitalCost() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
CapitalCost() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
capitalCost_egoa::Edges::ElectricalPropertiesprivate
Charge() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Charge() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
charge_egoa::Edges::ElectricalPropertiesprivate
Conductance() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Conductance(Types::real conductance) (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
conductance_egoa::Edges::ElectricalPropertiesprivate
ElectricalProperties() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
ElectricalProperties(Types::name name) (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Header(std::ostream &outputStream)egoa::Edges::ElectricalPropertiesinlinestatic
HeaderLong(std::ostream &outputStream)egoa::Edges::ElectricalPropertiesinlinestatic
Length() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Length() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
length_egoa::Edges::ElectricalPropertiesprivate
Line(std::ostream &outputStream, Types::name sourceName, Types::name targetName, Types::real baseMva=1) constegoa::Edges::ElectricalPropertiesinline
Name() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Name() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
name_egoa::Edges::ElectricalPropertiesprivate
NominalApparentPower() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
NominalApparentPower() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
nominalApparentPower_egoa::Edges::ElectricalPropertiesprivate
NominalApparentPowerBound() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
NominalApparentPowerBound() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
nominalApparentPowerBound_egoa::Edges::ElectricalPropertiesprivate
NominalApparentPowerExtendable() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
NominalApparentPowerExtendable() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
nominalApparentPowerExtendable_egoa::Edges::ElectricalPropertiesprivate
NominalVoltage() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
NominalVoltage() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
nominalVoltage_egoa::Edges::ElectricalPropertiesprivate
NumberOfParallelLines() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
NumberOfParallelLines() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
numberOfParallelLines_egoa::Edges::ElectricalPropertiesprivate
operator!=egoa::Edges::ElectricalPropertiesfriend
operator<<egoa::Edges::ElectricalPropertiesfriend
operator==egoa::Edges::ElectricalPropertiesfriend
Reactance() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Reactance() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
reactance_egoa::Edges::ElectricalPropertiesprivate
Resistance() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Resistance() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
resistance_egoa::Edges::ElectricalPropertiesprivate
Status() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Status() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
status_egoa::Edges::ElectricalPropertiesprivate
Susceptance() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Susceptance(Types::real susceptance) (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
susceptance_egoa::Edges::ElectricalPropertiesprivate
swapegoa::Edges::ElectricalPropertiesfriend
TapRatio() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
TapRatio() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
tapRatio_egoa::Edges::ElectricalPropertiesprivate
TapRatioCosThetaShift() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
TapRatioCosThetaShift() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
tapRatioCosThetaShift_egoa::Edges::ElectricalPropertiesprivate
TapRatioSinThetaShift() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
TapRatioSinThetaShift() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
tapRatioSinThetaShift_egoa::Edges::ElectricalPropertiesprivate
TBound typedef (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesprivate
TerrainFactor() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
TerrainFactor() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
terrainFactor_egoa::Edges::ElectricalPropertiesprivate
ThermalLimit() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
ThermalLimit() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
thermalLimitA_egoa::Edges::ElectricalPropertiesprivate
ThermalLimitB() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
ThermalLimitB() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
thermalLimitB_egoa::Edges::ElectricalPropertiesprivate
ThermalLimitC() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
ThermalLimitC() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
thermalLimitC_egoa::Edges::ElectricalPropertiesprivate
ThetaBound() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
ThetaBound() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
thetaBound_egoa::Edges::ElectricalPropertiesprivate
Type() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Type() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
type_ (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesprivate
Weight() const (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
Weight() (defined in egoa::Edges::ElectricalProperties)egoa::Edges::ElectricalPropertiesinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_edges_1_1_electrical_properties.html b/classegoa_1_1_edges_1_1_electrical_properties.html new file mode 100644 index 00000000..3be80b19 --- /dev/null +++ b/classegoa_1_1_edges_1_1_electrical_properties.html @@ -0,0 +1,2672 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Edges::ElectricalProperties Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +Private Attributes | +Friends | +List of all members
+
egoa::Edges::ElectricalProperties Class Reference
+
+
+ +

Class having all edge electrical properties (branch properties). + More...

+ +

#include <ElectricalProperties.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Types::real CapitalCost () const
 
Types::real & CapitalCost ()
 
Types::real Length () const
 
Types::real & Length ()
 
Types::count NumberOfParallelLines () const
 
Types::count & NumberOfParallelLines ()
 
Types::real NominalApparentPower () const
 
Types::real & NominalApparentPower ()
 
Types::real NominalVoltage () const
 
Types::real & NominalVoltage ()
 
TBound NominalApparentPowerBound () const
 
TBound & NominalApparentPowerBound ()
 
bool NominalApparentPowerExtendable () const
 
bool & NominalApparentPowerExtendable ()
 
Types::real TerrainFactor () const
 
Types::real & TerrainFactor ()
 
Constructors and Destructor
 ElectricalProperties (Types::name name)
 
Getter and setter
Types::string Name () const
 
Types::string & Name ()
 
bool Status () const
 
bool & Status ()
 
Edges::ElectricalEdgeType Type () const
 
Edges::ElectricalEdgeType & Type ()
 
Types::real Resistance () const
 
Types::real & Resistance ()
 
Types::real Reactance () const
 
Types::real & Reactance ()
 
template<Edges::CarrierDifferentiationType CarrierType>
Types::real Conductance () const
 
void Conductance (Types::real conductance)
 
template<Edges::CarrierDifferentiationType CarrierType>
Types::real Susceptance () const
 
void Susceptance (Types::real susceptance)
 
Types::real Weight () const
 
Types::real & Weight ()
 
Types::real Charge () const
 
Types::real & Charge ()
 
Types::real ThermalLimit () const
 
Types::real & ThermalLimit ()
 
Types::real ThermalLimitB () const
 
Types::real & ThermalLimitB ()
 
Types::real ThermalLimitC () const
 
Types::real & ThermalLimitC ()
 
Types::real TapRatio () const
 
Types::real & TapRatio ()
 
Types::real AngleShift () const
 
Types::real & AngleShift ()
 
Types::real TapRatioCosThetaShift () const
 
Types::real & TapRatioCosThetaShift ()
 
Types::real TapRatioSinThetaShift () const
 
Types::real & TapRatioSinThetaShift ()
 
TBound ThetaBound () const
 
TBound & ThetaBound ()
 
+ + + +

+Private Types

using TBound = Bound<>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Types::string name_
 
bool status_
 
Edges::ElectricalEdgeType type_
 
TBound thetaBound_
 
Types::real conductance_
 
Types::real susceptance_
 
Types::real charge_
 
Types::real capitalCost_
 
Types::real length_
 
Types::count numberOfParallelLines_
 
Types::real nominalApparentPower_
 
Types::real nominalVoltage_
 
TBound nominalApparentPowerBound_
 
bool nominalApparentPowerExtendable_
 
Types::real terrainFactor_
 
Branch impedance @f$ Z = R + j X @f$ in p.u.
Note
A line with impedance 0 can be removed unless it is a jumper line.
+
Types::real resistance_
 
Types::real reactance_
 
Line MVA ratings

Three MVA ratings with Rate A being the lowest one.

+
Types::real thermalLimitA_
 
Types::real thermalLimitB_
 
Types::real thermalLimitC_
 
Transformer
Types::real tapRatio_
 
Types::real angleShift_
 
Types::real tapRatioCosThetaShift_
 
Types::real tapRatioSinThetaShift_
 
+ + + + + + + + + + + +

+Friends

void swap (ElectricalProperties &lhs, ElectricalProperties &rhs)
 Swapping the members of two ElectricalProperties.
 
Comparators
bool operator== (ElectricalProperties const &lhs, ElectricalProperties const &rhs)
 Comparator.
 
bool operator!= (ElectricalProperties const &lhs, ElectricalProperties const &rhs)
 Comparator.
 
+ + + + + + + + + + + + + +

Output

void Line (std::ostream &outputStream, Types::name sourceName, Types::name targetName, Types::real baseMva=1) const
 Line out stream.
 
std::ostream & operator<< (std::ostream &outputStream, ElectricalProperties const &rhs)
 Writes the electrical property to an output stream.
 
static void HeaderLong (std::ostream &outputStream)
 Header out stream.
 
static void Header (std::ostream &outputStream)
 Header out stream.
 
+

Detailed Description

+

Class having all edge electrical properties (branch properties).

+

DOI: 10.1109/TPAS.1973.293571

+ +

Definition at line 27 of file ElectricalProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+ + + + + +
+ + + + +
using egoa::Edges::ElectricalProperties::TBound = Bound<>
+ 		+private
+
+ +

Definition at line 29 of file ElectricalProperties.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ElectricalProperties() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
egoa::Edges::ElectricalProperties::ElectricalProperties ()
+ 		+inline
+
+ +

Definition at line 36 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ElectricalProperties() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
egoa::Edges::ElectricalProperties::ElectricalProperties (Types::name name)
+ 		+inline
+
+ +

Definition at line 64 of file ElectricalProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AngleShift() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::AngleShift ()
+ 		+inline
+
+ +

Definition at line 208 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ AngleShift() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::AngleShift () const
+ 		+inline
+
+ +

Definition at line 207 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ CapitalCost() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::CapitalCost ()
+ 		+inline
+
+ +

Definition at line 223 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ CapitalCost() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::CapitalCost () const
+ 		+inline
+
+ +

Definition at line 222 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Charge() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::Charge ()
+ 		+inline
+
+ +

Definition at line 193 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Charge() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Charge () const
+ 		+inline
+
+ +

Definition at line 192 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Conductance() [1/2]

+ +
+
+
+template<Edges::CarrierDifferentiationType CarrierType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Conductance () const
+ 		+inline
+
+ +

Definition at line 182 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Conductance() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void egoa::Edges::ElectricalProperties::Conductance (Types::real conductance)
+ 		+inline
+
+ +

Definition at line 183 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Header()

+ +
+
+ + + + + +
+ + + + + + + + +
static void egoa::Edges::ElectricalProperties::Header (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Header out stream.

+

List all IEEE standard input data.

+
Parameters
+ + +
outputStreamThe stream to write data to, e.g., std::cout.
+
+
+ +

Definition at line 283 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ HeaderLong()

+ +
+
+ + + + + +
+ + + + + + + + +
static void egoa::Edges::ElectricalProperties::HeaderLong (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Header out stream.

+

List all IEEE standard input data.

+
Parameters
+ + +
outputStreamThe stream to write data to, e.g., std::cout.
+
+
+ +

Definition at line 257 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Length() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::Length ()
+ 		+inline
+
+ +

Definition at line 226 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Length() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Length () const
+ 		+inline
+
+ +

Definition at line 225 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Line()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::Edges::ElectricalProperties::Line (std::ostream & outputStream,
Types::name sourceName,
Types::name targetName,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Line out stream.

+

List all IEEE standard input data.

+
Parameters
+ + + + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]sourceNameThe source name
[in]targetNameThe target name
[in]baseMvaThe base mva
+
+
+ +

Definition at line 312 of file ElectricalProperties.hpp.

+ +

References egoa::Bound< BoundType >::Maximum(), and egoa::Bound< BoundType >::Minimum().

+ +
+
+ +

◆ Name() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::string & egoa::Edges::ElectricalProperties::Name ()
+ 		+inline
+
+ +

Definition at line 167 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Name() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::string egoa::Edges::ElectricalProperties::Name () const
+ 		+inline
+
+ +

Definition at line 166 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPower() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::NominalApparentPower ()
+ 		+inline
+
+ +

Definition at line 232 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPower() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::NominalApparentPower () const
+ 		+inline
+
+ +

Definition at line 231 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPowerBound() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
TBound & egoa::Edges::ElectricalProperties::NominalApparentPowerBound ()
+ 		+inline
+
+ +

Definition at line 238 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPowerBound() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
TBound egoa::Edges::ElectricalProperties::NominalApparentPowerBound () const
+ 		+inline
+
+ +

Definition at line 237 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPowerExtendable() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
bool & egoa::Edges::ElectricalProperties::NominalApparentPowerExtendable ()
+ 		+inline
+
+ +

Definition at line 241 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalApparentPowerExtendable() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
bool egoa::Edges::ElectricalProperties::NominalApparentPowerExtendable () const
+ 		+inline
+
+ +

Definition at line 240 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalVoltage() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::NominalVoltage ()
+ 		+inline
+
+ +

Definition at line 235 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalVoltage() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::NominalVoltage () const
+ 		+inline
+
+ +

Definition at line 234 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NumberOfParallelLines() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count & egoa::Edges::ElectricalProperties::NumberOfParallelLines ()
+ 		+inline
+
+ +

Definition at line 229 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NumberOfParallelLines() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count egoa::Edges::ElectricalProperties::NumberOfParallelLines () const
+ 		+inline
+
+ +

Definition at line 228 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Reactance() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::Reactance ()
+ 		+inline
+
+ +

Definition at line 179 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Reactance() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Reactance () const
+ 		+inline
+
+ +

Definition at line 178 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Resistance() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::Resistance ()
+ 		+inline
+
+ +

Definition at line 176 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Resistance() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Resistance () const
+ 		+inline
+
+ +

Definition at line 175 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Status() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
bool & egoa::Edges::ElectricalProperties::Status ()
+ 		+inline
+
+ +

Definition at line 170 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Status() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
bool egoa::Edges::ElectricalProperties::Status () const
+ 		+inline
+
+ +

Definition at line 169 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Susceptance() [1/2]

+ +
+
+
+template<Edges::CarrierDifferentiationType CarrierType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Susceptance () const
+ 		+inline
+
+ +

Definition at line 186 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Susceptance() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void egoa::Edges::ElectricalProperties::Susceptance (Types::real susceptance)
+ 		+inline
+
+ +

Definition at line 187 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatio() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::TapRatio ()
+ 		+inline
+
+ +

Definition at line 205 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatio() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::TapRatio () const
+ 		+inline
+
+ +

Definition at line 204 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatioCosThetaShift() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::TapRatioCosThetaShift ()
+ 		+inline
+
+ +

Definition at line 211 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatioCosThetaShift() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::TapRatioCosThetaShift () const
+ 		+inline
+
+ +

Definition at line 210 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatioSinThetaShift() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::TapRatioSinThetaShift ()
+ 		+inline
+
+ +

Definition at line 214 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TapRatioSinThetaShift() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::TapRatioSinThetaShift () const
+ 		+inline
+
+ +

Definition at line 213 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TerrainFactor() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::TerrainFactor ()
+ 		+inline
+
+ +

Definition at line 244 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TerrainFactor() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::TerrainFactor () const
+ 		+inline
+
+ +

Definition at line 243 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimit() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::ThermalLimit ()
+ 		+inline
+
+ +

Definition at line 196 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimit() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::ThermalLimit () const
+ 		+inline
+
+ +

Definition at line 195 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimitB() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::ThermalLimitB ()
+ 		+inline
+
+ +

Definition at line 199 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimitB() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::ThermalLimitB () const
+ 		+inline
+
+ +

Definition at line 198 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimitC() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::ThermalLimitC ()
+ 		+inline
+
+ +

Definition at line 202 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThermalLimitC() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::ThermalLimitC () const
+ 		+inline
+
+ +

Definition at line 201 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThetaBound() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
TBound & egoa::Edges::ElectricalProperties::ThetaBound ()
+ 		+inline
+
+ +

Definition at line 218 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ ThetaBound() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
TBound egoa::Edges::ElectricalProperties::ThetaBound () const
+ 		+inline
+
+ +

Definition at line 217 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Type() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Edges::ElectricalEdgeType & egoa::Edges::ElectricalProperties::Type ()
+ 		+inline
+
+ +

Definition at line 173 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Type() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Edges::ElectricalEdgeType egoa::Edges::ElectricalProperties::Type () const
+ 		+inline
+
+ +

Definition at line 172 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Weight() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real & egoa::Edges::ElectricalProperties::Weight ()
+ 		+inline
+
+ +

Definition at line 190 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Weight() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::real egoa::Edges::ElectricalProperties::Weight () const
+ 		+inline
+
+ +

Definition at line 189 of file ElectricalProperties.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator!=

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (ElectricalProperties const & lhs,
ElectricalProperties const & rhs 
)
+ 		+friend
+
+ +

Comparator.

+
Parameters
+ + + +
lhsThe left edge.
rhsThe right edge.
+
+
+
Returns
false if the edges are the same, true otherwise.
+ +

Definition at line 156 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ operator<<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
ElectricalProperties const & rhs 
)
+ 		+friend
+
+ +

Writes the electrical property to an output stream.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]rhsThe electrical property.
+
+
+
Returns
The output stream.
+ +

Definition at line 345 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ operator==

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (ElectricalProperties const & lhs,
ElectricalProperties const & rhs 
)
+ 		+friend
+
+ +

Comparator.

+
Parameters
+ + + +
lhsThe left edge.
rhsThe right edge.
+
+
+
Returns
true if the edges are the same, false otherwise.
+ +

Definition at line 118 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ swap

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (ElectricalProperties & lhs,
ElectricalProperties & rhs 
)
+ 		+friend
+
+ +

Swapping the members of two ElectricalProperties.

+
Parameters
+ + + +
lhsLeft ElectricalProperties
rhsRight ElectricalProperties
+
+
+ +

Definition at line 77 of file ElectricalProperties.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ angleShift_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::angleShift_
+ 		+private
+
+

in rad, transformer phase shift angle, known as theta shift (angle shift) representing final angle, if it is positive it represents a delay.

+ +

Definition at line 405 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ capitalCost_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::capitalCost_
+ 		+private
+
+

in Dollar, capital cost

+ +

Definition at line 412 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ charge_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::charge_
+ 		+private
+
+

in p.u., total line charging susceptance (b) 0 unless the transmission line has been combined with a transformer then add a line charging

+ +

Definition at line 386 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ conductance_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::conductance_
+ 		+private
+
+

in p.u., conductance g, not included in IEEE data

+ +

Definition at line 384 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ length_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::length_
+ 		+private
+
+

in ?, length of a branch

+ +

Definition at line 413 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ name_

+ +
+
+ + + + + +
+ + + + +
Types::string egoa::Edges::ElectricalProperties::name_
+ 		+private
+
+

Name of the branch

+ +

Definition at line 367 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ nominalApparentPower_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::nominalApparentPower_
+ 		+private
+
+

in MW or MVAr, nominal apparent power

+ +

Definition at line 415 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ nominalApparentPowerBound_

+ +
+
+ + + + + +
+ + + + +
TBound egoa::Edges::ElectricalProperties::nominalApparentPowerBound_
+ 		+private
+
+

in MW or MVAr, minimum/maximum nominal apparent power

+ +

Definition at line 417 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ nominalApparentPowerExtendable_

+ +
+
+ + + + + +
+ + + + +
bool egoa::Edges::ElectricalProperties::nominalApparentPowerExtendable_
+ 		+private
+
+

in MW or VAr, nominal apparent power

+ +

Definition at line 418 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ nominalVoltage_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::nominalVoltage_
+ 		+private
+
+

in V, nominal voltage, basekv

+ +

Definition at line 416 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ numberOfParallelLines_

+ +
+
+ + + + + +
+ + + + +
Types::count egoa::Edges::ElectricalProperties::numberOfParallelLines_
+ 		+private
+
+

in -, number of parallel lines

+ +

Definition at line 414 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ reactance_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::reactance_
+ 		+private
+
+

in p.u., reactance x

+ +

Definition at line 382 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ resistance_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::resistance_
+ 		+private
+
+

in p.u., resistance r

+ +

Definition at line 381 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ status_

+ +
+
+ + + + + +
+ + + + +
bool egoa::Edges::ElectricalProperties::status_
+ 		+private
+
+

in {0,1}, on/off status of a branch, i.e. closed or open circuit

+ +

Definition at line 369 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ susceptance_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::susceptance_
+ 		+private
+
+

in p.u., susceptance b, not included in IEEE data

+ +

Definition at line 385 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ tapRatio_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::tapRatio_
+ 		+private
+
+

in -, tap ratio representing final ratio, transformer off nominal turns ratio, i non-zero (taps at source and impedance at target meaning $ r = x = b = 0 $, $ tap = |V(source)|/|V(target)|) $, tap = 0 indicates transmission line rather than transformer, i.e., tap = 1

+ +

Definition at line 401 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ tapRatioCosThetaShift_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::tapRatioCosThetaShift_
+ 		+private
+
+

Tap ratio . cos(theta shift)

+ +

Definition at line 407 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ tapRatioSinThetaShift_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::tapRatioSinThetaShift_
+ 		+private
+
+

Tap ratio . sin(theta shift)

+ +

Definition at line 408 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ terrainFactor_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::terrainFactor_
+ 		+private
+
+

in -, terrain factor

+ +

Definition at line 419 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ thermalLimitA_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::thermalLimitA_
+ 		+private
+
+

in MVA, standard thermal line limit (long term rating)

+ +

Definition at line 394 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ thermalLimitB_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::thermalLimitB_
+ 		+private
+
+

in MVA, first emergency thermal line limit (short term rating)

+ +

Definition at line 395 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ thermalLimitC_

+ +
+
+ + + + + +
+ + + + +
Types::real egoa::Edges::ElectricalProperties::thermalLimitC_
+ 		+private
+
+

in MVA, second emergency thermal line limit (emergency rating)

+ +

Definition at line 396 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ thetaBound_

+ +
+
+ + + + + +
+ + + + +
TBound egoa::Edges::ElectricalProperties::thetaBound_
+ 		+private
+
+

in rad, minimum/maximum angle difference, theta(source) - theta(target) = delta theta; Thermal limit bound

+ +

Definition at line 374 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ type_

+ +
+
+ + + + + +
+ + + + +
Edges::ElectricalEdgeType egoa::Edges::ElectricalProperties::type_
+ 		+private
+
+ +

Definition at line 371 of file ElectricalProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_gurobi_solver.html b/classegoa_1_1_gurobi_solver.html new file mode 100644 index 00000000..3189a1e6 --- /dev/null +++ b/classegoa_1_1_gurobi_solver.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::GurobiSolver< CallbackType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::GurobiSolver< CallbackType > Class Template Reference
+
+
+

Detailed Description

+
template<typename CallbackType>
+class egoa::GurobiSolver< CallbackType >
+

Definition at line 17 of file CallbackEmpty.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_dtp_runtime_collection-members.html b/classegoa_1_1_i_o_1_1_dtp_runtime_collection-members.html new file mode 100644 index 00000000..89878a3f --- /dev/null +++ b/classegoa_1_1_i_o_1_1_dtp_runtime_collection-members.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::IO::DtpRuntimeCollection Member List
+
+
+ +

This is the complete list of members for egoa::IO::DtpRuntimeCollection, including all inherited members.

+ + + + + + + + +
Clear()egoa::IO::DtpRuntimeCollectioninline
Collection() const (defined in egoa::IO::DtpRuntimeCollection)egoa::IO::DtpRuntimeCollectioninline
collection_ (defined in egoa::IO::DtpRuntimeCollection)egoa::IO::DtpRuntimeCollectionprivate
operator+=(TRow const &rhs)egoa::IO::DtpRuntimeCollectioninline
operator<< (defined in egoa::IO::DtpRuntimeCollection)egoa::IO::DtpRuntimeCollectionfriend
TRow typedef (defined in egoa::IO::DtpRuntimeCollection)egoa::IO::DtpRuntimeCollection
WriteCollectionToFileWith(Types::string const filename, bool overwrite=true)egoa::IO::DtpRuntimeCollectioninline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_dtp_runtime_collection.html b/classegoa_1_1_i_o_1_1_dtp_runtime_collection.html new file mode 100644 index 00000000..85776db8 --- /dev/null +++ b/classegoa_1_1_i_o_1_1_dtp_runtime_collection.html @@ -0,0 +1,355 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IO::DtpRuntimeCollection Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +List of all members
+
egoa::IO::DtpRuntimeCollection Class Reference
+
+
+ +

A collections of DtpRuntimeRow objects for multiple runs of the DTP-algorithm. + More...

+ +

#include <DtpRuntimeCollection.hpp>

+ + + + +

+Public Types

using TRow = DtpRuntimeRow
 
+ + + + + + + + + + + +

+Public Member Functions

Modifying content
DtpRuntimeCollection & operator+= (TRow const &rhs)
 Adds a DtpRuntimeRow to the collection.
 
void Clear ()
 Clears the content of the collection.
 
Accessors
std::vector< TRow > const & Collection () const
 
+ + + +

+Private Attributes

std::vector< TRow > collection_
 
+ + + + + + +

Output

void WriteCollectionToFileWith (Types::string const filename, bool overwrite=true)
 Writes the data in the collection to a file.
 
std::ostream & operator<< (std::ostream &os, DtpRuntimeCollection const &collection)
 
+

Detailed Description

+

A collections of DtpRuntimeRow objects for multiple runs of the DTP-algorithm.

+ +

Definition at line 23 of file DtpRuntimeCollection.hpp.

+

Member Typedef Documentation

+ +

◆ TRow

+ +
+
+ + + + +
using egoa::IO::DtpRuntimeCollection::TRow = DtpRuntimeRow
+
+ +

Definition at line 25 of file DtpRuntimeCollection.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Clear()

+ +
+
+ + + + + +
+ + + + + + + +
void egoa::IO::DtpRuntimeCollection::Clear ()
+ 		+inline
+
+ +

Clears the content of the collection.

+ +

Definition at line 45 of file DtpRuntimeCollection.hpp.

+ +
+
+ +

◆ Collection()

+ +
+
+ + + + + +
+ + + + + + + +
std::vector< TRow > const & egoa::IO::DtpRuntimeCollection::Collection () const
+ 		+inline
+
+ +

Definition at line 53 of file DtpRuntimeCollection.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + +
+ + + + + + + + +
DtpRuntimeCollection & egoa::IO::DtpRuntimeCollection::operator+= (TRow const & rhs)
+ 		+inline
+
+ +

Adds a DtpRuntimeRow to the collection.

+
Parameters
+ + +
rhsThe row to add.
+
+
+
Returns
*this.
+ +

Definition at line 36 of file DtpRuntimeCollection.hpp.

+ +
+
+ +

◆ WriteCollectionToFileWith()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::DtpRuntimeCollection::WriteCollectionToFileWith (Types::string const filename,
bool overwrite = true 
)
+ 		+inline
+
+ +

Writes the data in the collection to a file.

+

If overwrite == true or the file is empty, a header is written before the content. Otherwise, onlye the content is written.

+
Parameters
+ + + +
[in]filenameThe filename
[in]overwritetrue if the content of the file shall be overwritten, false if the content shall be appended to the file.
+
+
+ +

Definition at line 82 of file DtpRuntimeCollection.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
DtpRuntimeCollection const & collection 
)
+ 		+friend
+
+ +

Definition at line 61 of file DtpRuntimeCollection.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ collection_

+ +
+
+ + + + + +
+ + + + +
std::vector<TRow> egoa::IO::DtpRuntimeCollection::collection_
+ 		+private
+
+ +

Definition at line 108 of file DtpRuntimeCollection.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_dtp_runtime_row-members.html b/classegoa_1_1_i_o_1_1_dtp_runtime_row-members.html new file mode 100644 index 00000000..a633792f --- /dev/null +++ b/classegoa_1_1_i_o_1_1_dtp_runtime_row-members.html @@ -0,0 +1,107 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::IO::DtpRuntimeRow Member List
+
+
+ +

This is the complete list of members for egoa::IO::DtpRuntimeRow, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
Clear() (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinline
Content(std::ostream &os) const (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinline
DtpRuntimeRow() (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinline
GlobalElapsedMillisecondsegoa::IO::DtpRuntimeRow
Header(std::ostream &os) (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinlinestatic
Nameegoa::IO::DtpRuntimeRow
NameOfProblemegoa::IO::DtpRuntimeRow
NumberOfEdgesegoa::IO::DtpRuntimeRow
NumberOfEdgesProducingNoCycleegoa::IO::DtpRuntimeRow
NumberOfGeneratorsegoa::IO::DtpRuntimeRow
NumberOfLabelsegoa::IO::DtpRuntimeRow
NumberOfLoadsegoa::IO::DtpRuntimeRow
NumberOfRelaxedEdgesegoa::IO::DtpRuntimeRow
NumberOfScannedEdgesegoa::IO::DtpRuntimeRow
NumberOfVerticesegoa::IO::DtpRuntimeRow
operator+=(const DtpRuntimeRow &rhs) (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinline
operator<< (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowfriend
SourceIdegoa::IO::DtpRuntimeRow
WriteRowToFileWith(Types::string const filename, bool overwrite=false) (defined in egoa::IO::DtpRuntimeRow)egoa::IO::DtpRuntimeRowinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_dtp_runtime_row.html b/classegoa_1_1_i_o_1_1_dtp_runtime_row.html new file mode 100644 index 00000000..c75c940f --- /dev/null +++ b/classegoa_1_1_i_o_1_1_dtp_runtime_row.html @@ -0,0 +1,575 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IO::DtpRuntimeRow Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Public Attributes | +Friends | +List of all members
+
egoa::IO::DtpRuntimeRow Class Reference
+
+
+ +

Statistics about one execution of the DTP algorithm. + More...

+ +

#include <DtpRuntimeRow.hpp>

+ + + + + + + + + + +

+Public Member Functions

void Clear ()
 
void Content (std::ostream &os) const
 
DtpRuntimeRow & operator+= (const DtpRuntimeRow &rhs)
 
void WriteRowToFileWith (Types::string const filename, bool overwrite=false)
 
+ + + +

+Static Public Member Functions

static void Header (std::ostream &os)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Attributes

Types::string NameOfProblem
 
Types::name Name
 
Types::vertexId SourceId
 
Types::count NumberOfVertices
 
Types::count NumberOfGenerators
 
Types::count NumberOfLoads
 
Types::count NumberOfEdges
 
Types::count NumberOfEdgesProducingNoCycle
 
Types::count NumberOfRelaxedEdges
 
Types::count NumberOfScannedEdges
 
Types::count NumberOfLabels
 
Types::real GlobalElapsedMilliseconds
 
+ + + +

+Friends

std::ostream & operator<< (std::ostream &os, DtpRuntimeRow &dtpRuntimeRow)
 
+

Detailed Description

+

Statistics about one execution of the DTP algorithm.

+
See also
egoa::DominatingThetaPath
+ +

Definition at line 25 of file DtpRuntimeRow.hpp.

+

Constructor & Destructor Documentation

+ +

◆ DtpRuntimeRow()

+ +
+
+ + + + + +
+ + + + + + + +
egoa::IO::DtpRuntimeRow::DtpRuntimeRow ()
+ 		+inline
+
+ +

Definition at line 44 of file DtpRuntimeRow.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Clear()

+ +
+
+ + + + + +
+ + + + + + + +
void egoa::IO::DtpRuntimeRow::Clear ()
+ 		+inline
+
+ +

Definition at line 63 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ Content()

+ +
+
+ + + + + +
+ + + + + + + + +
void egoa::IO::DtpRuntimeRow::Content (std::ostream & os) const
+ 		+inline
+
+ +

Definition at line 102 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ Header()

+ +
+
+ + + + + +
+ + + + + + + + +
static void egoa::IO::DtpRuntimeRow::Header (std::ostream & os)
+ 		+inlinestatic
+
+ +

Definition at line 78 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + +
+ + + + + + + + +
DtpRuntimeRow & egoa::IO::DtpRuntimeRow::operator+= (const DtpRuntimeRow & rhs)
+ 		+inline
+
+ +

Definition at line 126 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ WriteRowToFileWith()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::DtpRuntimeRow::WriteRowToFileWith (Types::string const filename,
bool overwrite = false 
)
+ 		+inline
+
+ +

Definition at line 145 of file DtpRuntimeRow.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
DtpRuntimeRow & dtpRuntimeRow 
)
+ 		+friend
+
+ +

Definition at line 138 of file DtpRuntimeRow.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ GlobalElapsedMilliseconds

+ +
+
+ + + + +
Types::real egoa::IO::DtpRuntimeRow::GlobalElapsedMilliseconds
+
+

The total runtime.

+ +

Definition at line 42 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ Name

+ +
+
+ + + + +
Types::name egoa::IO::DtpRuntimeRow::Name
+
+

The name of the instance.

+ +

Definition at line 28 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NameOfProblem

+ +
+
+ + + + +
Types::string egoa::IO::DtpRuntimeRow::NameOfProblem
+
+

The name of the problem that is solved.

+ +

Definition at line 27 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfEdges

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfEdges
+
+

The number of edges.

+ +

Definition at line 35 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfEdgesProducingNoCycle

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfEdgesProducingNoCycle
+
+

The number of edges that produce not a cycle.

+ +

Definition at line 37 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfGenerators

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfGenerators
+
+

The number of generators.

+ +

Definition at line 33 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfLabels

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfLabels
+
+

The number of labels.

+ +

Definition at line 40 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfLoads

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfLoads
+
+

The number of loads.

+ +

Definition at line 34 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfRelaxedEdges

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfRelaxedEdges
+
+

The number of relaxed edges.

+ +

Definition at line 38 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfScannedEdges

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfScannedEdges
+
+

The number of scanned edges.

+ +

Definition at line 39 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ NumberOfVertices

+ +
+
+ + + + +
Types::count egoa::IO::DtpRuntimeRow::NumberOfVertices
+
+

The number of vertices.

+ +

Definition at line 32 of file DtpRuntimeRow.hpp.

+ +
+
+ +

◆ SourceId

+ +
+
+ + + + +
Types::vertexId egoa::IO::DtpRuntimeRow::SourceId
+
+

The source identifier.

+ +

Definition at line 30 of file DtpRuntimeRow.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_geo_json_writer-members.html b/classegoa_1_1_i_o_1_1_geo_json_writer-members.html new file mode 100644 index 00000000..5f8b82e0 --- /dev/null +++ b/classegoa_1_1_i_o_1_1_geo_json_writer-members.html @@ -0,0 +1,134 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::IO::GeoJsonWriter< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::IO::GeoJsonWriter< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GeoJsonWriter(Types::count indent=4, bool readable=true)egoa::IO::GeoJsonWriter< GraphType >inlineexplicit
Indent(std::ostream &os, Types::count depth=1)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
indent_ (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
NewLine(std::ostream &os)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
PropertyTemplate(std::ostream &os, std::string lhs, T const &rhs, bool last=false, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
Readable()egoa::IO::GeoJsonWriter< GraphType >inlineprivate
readable_ (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TBound typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TEdge typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TEdgeProperties typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TGeneratorProperties typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TGraph typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TLoadProperties typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TNetwork typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TVertex typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TVertexProperties typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
TVertexType typedef (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >private
write(TNetwork const &network, std::string const &filename)egoa::IO::GeoJsonWriter< GraphType >inline
write(TNetwork const &network, std::ostream &outputStream)egoa::IO::GeoJsonWriter< GraphType >inline
WriteEdgeProperties(std::ostream &os, TEdgeProperties const &edgeProperty, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFeatureBegin(std::ostream &os, Types::count indent=1)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFeatureCollection(std::ostream &os)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFeatureEnd(std::ostream &os, bool last=false, Types::count indent=1)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFeaturesBegin(std::ostream &os)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFeaturesEnd(std::ostream &os, bool last=false, Types::count indent=0)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteFooter(std::ostream &os, Types::count indent=0)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteGenerators(std::ostream &os, TNetwork const &network, bool last=false, Types::count indent=1)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteGeometry(std::ostream &os, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteGraph(std::ostream &os, TGraph const &graph)egoa::IO::GeoJsonWriter< GraphType >inline
WriteHeader(std::ostream &os)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteLineContent(std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=4)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteLineFooter(std::ostream &os, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteLineHeader(std::ostream &os, Types::count indent=3)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteLines(std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteLinesGeometryObject(std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePoint(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePoint(std::ostream &os, TGraph const &graph, Types::vertexId vertexId, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePoint(std::ostream &os, TVertex const &vertex, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePointCoordinate(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePointCoordinate(std::ostream &os, TGraph const &graph, Types::vertexId vertexId)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePointCoordinate(std::ostream &os, TVertex const &vertex)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePropertiesBegin(std::ostream &os, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WritePropertiesEnd(std::ostream &os, bool last=false, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteVertexProperties(std::ostream &os, TVertexProperties const &vertexProperty, Types::count indent=2)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
WriteVertices(std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=1)egoa::IO::GeoJsonWriter< GraphType >inlineprivate
~GeoJsonWriter() (defined in egoa::IO::GeoJsonWriter< GraphType >)egoa::IO::GeoJsonWriter< GraphType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_geo_json_writer.html b/classegoa_1_1_i_o_1_1_geo_json_writer.html new file mode 100644 index 00000000..f5d2d044 --- /dev/null +++ b/classegoa_1_1_i_o_1_1_geo_json_writer.html @@ -0,0 +1,2385 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IO::GeoJsonWriter< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +Private Attributes | +List of all members
+
egoa::IO::GeoJsonWriter< GraphType > Class Template Referencefinal
+
+
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and destructor
 GeoJsonWriter (Types::count indent=4, bool readable=true)
 Constructs a new instance.
 
Write Graph
bool WriteGraph (std::ostream &os, TGraph const &graph)
 Writes a graph.
 
Writer
bool write (TNetwork const &network, std::string const &filename)
 Write GeoJSON using the filename.
 
bool write (TNetwork const &network, std::ostream &outputStream)
 Write GeoJSON using the output stream.
 
+ + + + + + + + + + + + + + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TNetwork = PowerGrid< GraphType >
 
using TVertex = typename TGraph::TVertex
 
using TVertexProperties = typename TGraph::TVertexProperties
 
using TVertexType = typename TVertexProperties::TVertexType
 
using TGeneratorProperties = typename TNetwork::TGeneratorProperties
 
using TLoadProperties = typename TNetwork::TLoadProperties
 
using TEdge = typename TGraph::TEdge
 
using TEdgeProperties = typename TGraph::TEdgeProperties
 
using TBound = Bound<>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Auxiliary
void Indent (std::ostream &os, Types::count depth=1)
 Add indent to the output stream.
 
void NewLine (std::ostream &os)
 Add new line to the output stream.
 
bool Readable ()
 Write a readable GeoJson.
 
Writer Methods
void WriteHeader (std::ostream &os)
 Writes a header.
 
void WriteFooter (std::ostream &os, Types::count indent=0)
 Writes a footer.
 
void WriteFeatureBegin (std::ostream &os, Types::count indent=1)
 Writes a feature begin.
 
void WriteFeatureEnd (std::ostream &os, bool last=false, Types::count indent=1)
 Writes a feature end.
 
void WritePropertiesBegin (std::ostream &os, Types::count indent=2)
 Writes a properties begin.
 
void WriteVertexProperties (std::ostream &os, TVertexProperties const &vertexProperty, Types::count indent=2)
 Writes vertex properties.
 
void WriteEdgeProperties (std::ostream &os, TEdgeProperties const &edgeProperty, Types::count indent=2)
 Writes edge properties.
 
template<typename T >
void PropertyTemplate (std::ostream &os, std::string lhs, T const &rhs, bool last=false, Types::count indent=2)
 Standard JSON key : value pair template.
 
void WritePropertiesEnd (std::ostream &os, bool last=false, Types::count indent=2)
 Writes a properties end.
 
void WriteFeatureCollection (std::ostream &os)
 Writes a feature collection.
 
void WriteFeaturesBegin (std::ostream &os)
 Writes a features begin.
 
void WriteFeaturesEnd (std::ostream &os, bool last=false, Types::count indent=0)
 Writes a features end.
 
void WriteGeometry (std::ostream &os, Types::count indent=2)
 Writes a geometry.
 
Point Writer
void WriteVertices (std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=1)
 Writes points.
 
void WriteGenerators (std::ostream &os, TNetwork const &network, bool last=false, Types::count indent=1)
 Writes points.
 
void WritePoint (std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)
 Writes a GeoJson point.
 
void WritePoint (std::ostream &os, TGraph const &graph, Types::vertexId vertexId, Types::count indent=2)
 Writes a GeoJson point.
 
void WritePoint (std::ostream &os, TVertex const &vertex, Types::count indent=2)
 Writes a GeoJson point.
 
void WritePointCoordinate (std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)
 Writes a point coordinate.
 
void WritePointCoordinate (std::ostream &os, TGraph const &graph, Types::vertexId vertexId)
 Writes a point coordinate.
 
void WritePointCoordinate (std::ostream &os, TVertex const &vertex)
 Writes a point coordinate.
 
Line Writer
void WriteLines (std::ostream &os, TGraph const &graph, bool last=false, Types::count indent=2)
 Writes lines.
 
void WriteLinesGeometryObject (std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=2)
 Writes a lines geometry object.
 
void WriteLineHeader (std::ostream &os, Types::count indent=3)
 Writes a line header.
 
void WriteLineContent (std::ostream &os, TVertex const &sourceVertex, TVertex const &targetVertex, Types::count indent=4)
 Writes a line content.
 
void WriteLineFooter (std::ostream &os, Types::count indent=2)
 Writes a line footer.
 
+ + + + + +

+Private Attributes

Types::count const indent_
 
bool readable_
 
+

Detailed Description

+
template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+class egoa::IO::GeoJsonWriter< GraphType >
+

Definition at line 27 of file GeojsonWriter.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TBound = Bound<>
+ 		+private
+
+ +

Definition at line 44 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TEdge = typename TGraph::TEdge
+ 		+private
+
+ +

Definition at line 40 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TEdgeProperties = typename TGraph::TEdgeProperties
+ 		+private
+
+ +

Definition at line 41 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TGeneratorProperties = typename TNetwork::TGeneratorProperties
+ 		+private
+
+ +

Definition at line 37 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 31 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TLoadProperties = typename TNetwork::TLoadProperties
+ 		+private
+
+ +

Definition at line 38 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TNetwork = PowerGrid<GraphType>
+ 		+private
+
+ +

Definition at line 32 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 34 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TVertexProperties = typename TGraph::TVertexProperties
+ 		+private
+
+ +

Definition at line 35 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IO::GeoJsonWriter< GraphType >::TVertexType = typename TVertexProperties::TVertexType
+ 		+private
+
+ +

Definition at line 36 of file GeojsonWriter.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ GeoJsonWriter()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::IO::GeoJsonWriter< GraphType >::GeoJsonWriter (Types::count indent = 4,
bool readable = true 
)
+ 		+inlineexplicit
+
+ +

Constructs a new instance.

+
Parameters
+ + + +
filenameThe filename.
[in]indentIf true the file has a proper layout, otherwise its representation is compact.
+
+
+ +

Definition at line 59 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ ~GeoJsonWriter()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
egoa::IO::GeoJsonWriter< GraphType >::~GeoJsonWriter ()
+ 		+inline
+
+ +

Definition at line 65 of file GeojsonWriter.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Indent()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::Indent (std::ostream & os,
Types::count depth = 1 
)
+ 		+inlineprivate
+
+ +

Add indent to the output stream.

+
Parameters
+ + + +
osThe output stream.
[in]depthThe indent number.
+
+
+ +

Definition at line 104 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Readable().

+ +
+
+ +

◆ NewLine()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::NewLine (std::ostream & os)
+ 		+inlineprivate
+
+ +

Add new line to the output stream.

+
Parameters
+ + +
osThe output stream.
+
+
+ +

Definition at line 119 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Readable().

+ +
+
+ +

◆ PropertyTemplate()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::PropertyTemplate (std::ostream & os,
std::string lhs,
T const & rhs,
bool last = false,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Standard JSON key : value pair template.

+
Precondition
The right hand-side object has to support the output stream operator.
+
Parameters
+ + + + + + +
osThe output stream.
[in]lhsThe left hand side.
rhsThe right hand side.
[in]lastThe last.
[in]indentThe indent.
+
+
+
Template Parameters
+ + +
TType of the right hand-side.
+
+
+ +

Definition at line 326 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ Readable()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::IO::GeoJsonWriter< GraphType >::Readable ()
+ 		+inlineprivate
+
+ +

Write a readable GeoJson.

+
Returns
@true if the GeoJson will have indents and newlines, @false compact representation without any indents and newlines.
+ +

Definition at line 134 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ write() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::IO::GeoJsonWriter< GraphType >::write (TNetwork const & network,
std::ostream & outputStream 
)
+ 		+inline
+
+ +

Write GeoJSON using the output stream.

+
Parameters
+ + + +
networkThe network.
OutputStreamThe output stream to write data.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 726 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteGraph().

+ +
+
+ +

◆ write() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::IO::GeoJsonWriter< GraphType >::write (TNetwork const & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Write GeoJSON using the filename.

+
Parameters
+ + + +
networkThe network.
filenameThe filename.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 706 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteGraph().

+ +
+
+ +

◆ WriteEdgeProperties()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteEdgeProperties (std::ostream & os,
TEdgeProperties const & edgeProperty,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes edge properties.

+
Parameters
+ + + + +
osThe output stream.
edgePropertyThe edge property.
[in]indentThe indent.
+
+
+ +

Definition at line 268 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ WriteFeatureBegin()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureBegin (std::ostream & os,
Types::count indent = 1 
)
+ 		+inlineprivate
+
+ +

Writes a feature begin.

+
Parameters
+ + + +
osThe output stream.
[in]indentThe indent.
+
+
+ +

Definition at line 175 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteFeatureCollection()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureCollection (std::ostream & os)
+ 		+inlineprivate
+
+ +

Writes a feature collection.

+
Parameters
+ + +
osThe output stream.
+
+
+ +

Definition at line 368 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteFeatureEnd()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureEnd (std::ostream & os,
bool last = false,
Types::count indent = 1 
)
+ 		+inlineprivate
+
+ +

Writes a feature end.

+
Parameters
+ + + + +
osThe output stream.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 194 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteFeaturesBegin()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFeaturesBegin (std::ostream & os)
+ 		+inlineprivate
+
+ +

Writes a features begin.

+
Parameters
+ + +
osThe output stream.
+
+
+ +

Definition at line 379 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteFeaturesEnd()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFeaturesEnd (std::ostream & os,
bool last = false,
Types::count indent = 0 
)
+ 		+inlineprivate
+
+ +

Writes a features end.

+
Parameters
+ + + + +
osThe output stream.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 392 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteFooter()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteFooter (std::ostream & os,
Types::count indent = 0 
)
+ 		+inlineprivate
+
+ +

Writes a footer.

+
Parameters
+ + + +
osThe operating system
[in]indentThe indent
+
+
+ +

Definition at line 161 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteGenerators()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteGenerators (std::ostream & os,
TNetwork const & network,
bool last = false,
Types::count indent = 1 
)
+ 		+inlineprivate
+
+ +

Writes points.

+
Parameters
+ + + + + +
osThe output stream.
graphThe graph.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 452 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ WriteGeometry()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteGeometry (std::ostream & os,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a geometry.

+
Parameters
+ + + +
osThe output stream.
[in]indentThe indent.
+
+
+ +

Definition at line 409 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent().

+ +
+
+ +

◆ WriteGraph()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::IO::GeoJsonWriter< GraphType >::WriteGraph (std::ostream & os,
TGraph const & graph 
)
+ 		+inline
+
+ +

Writes a graph.

+
Parameters
+ + + +
osThe output stream.
graphThe graph.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 79 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureCollection(), egoa::IO::GeoJsonWriter< GraphType >::WriteFeaturesBegin(), egoa::IO::GeoJsonWriter< GraphType >::WriteFeaturesEnd(), egoa::IO::GeoJsonWriter< GraphType >::WriteFooter(), egoa::IO::GeoJsonWriter< GraphType >::WriteHeader(), egoa::IO::GeoJsonWriter< GraphType >::WriteLines(), and egoa::IO::GeoJsonWriter< GraphType >::WriteVertices().

+ +
+
+ +

◆ WriteHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteHeader (std::ostream & os)
+ 		+inlineprivate
+
+ +

Writes a header.

+
Parameters
+ + +
osThe output stream.
+
+
+ +

Definition at line 149 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteLineContent()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteLineContent (std::ostream & os,
TVertex const & sourceVertex,
TVertex const & targetVertex,
Types::count indent = 4 
)
+ 		+inlineprivate
+
+ +

Writes a line content.

+
Parameters
+ + + + +
osThe output stream.
graphThe graph.
[in]indentThe indent.
+
+
+ +

Definition at line 659 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), egoa::IO::GeoJsonWriter< GraphType >::NewLine(), and egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate().

+ +
+
+ +

◆ WriteLineFooter()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteLineFooter (std::ostream & os,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a line footer.

+
Parameters
+ + + +
osThe output stream.
[in]indentThe indent.
+
+
+ +

Definition at line 683 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteLineHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteLineHeader (std::ostream & os,
Types::count indent = 3 
)
+ 		+inlineprivate
+
+ +

Writes a line header.

+
Parameters
+ + + +
osThe output stream.
[in]indentThe indent.
+
+
+ +

Definition at line 639 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteLines()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteLines (std::ostream & os,
TGraph const & graph,
bool last = false,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes lines.

+
Parameters
+ + + + + +
osThe output stream.
graphThe graph.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 594 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteEdgeProperties(), egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureBegin(), egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureEnd(), egoa::IO::GeoJsonWriter< GraphType >::WriteLinesGeometryObject(), egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesBegin(), and egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesEnd().

+ +
+
+ +

◆ WriteLinesGeometryObject()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteLinesGeometryObject (std::ostream & os,
TVertex const & sourceVertex,
TVertex const & targetVertex,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a lines geometry object.

+
Parameters
+ + + + +
osThe output stream.
graphThe graph.
[in]indentThe indent.
+
+
+ +

Definition at line 622 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteGeometry(), egoa::IO::GeoJsonWriter< GraphType >::WriteLineContent(), egoa::IO::GeoJsonWriter< GraphType >::WriteLineFooter(), and egoa::IO::GeoJsonWriter< GraphType >::WriteLineHeader().

+ +
+
+ +

◆ WritePoint() [1/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePoint (std::ostream & os,
TGraph const & graph,
Types::vertexId vertexId,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a GeoJson point.

+
Parameters
+ + + + +
osThe output stream.
graphThe graph.
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 503 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WritePoint().

+ +
+
+ +

◆ WritePoint() [2/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePoint (std::ostream & os,
TVertex const & vertex,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a GeoJson point.

+
Parameters
+ + + +
osThe output stream.
vertexThe vertex.
+
+
+ +

Definition at line 520 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WritePoint().

+ +
+
+ +

◆ WritePoint() [3/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePoint (std::ostream & os,
Types::real xCoordinate,
Types::real yCoordinate,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a GeoJson point.

+
Parameters
+ + + + +
osThe output stream.
[in]xCoordinateThe coordinate.
[in]yCoordinateThe y coordinate.
+
+
+ +

Definition at line 474 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), egoa::IO::GeoJsonWriter< GraphType >::NewLine(), egoa::IO::GeoJsonWriter< GraphType >::WriteGeometry(), and egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate().

+ +
+
+ +

◆ WritePointCoordinate() [1/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate (std::ostream & os,
TGraph const & graph,
Types::vertexId vertexId 
)
+ 		+inlineprivate
+
+ +

Writes a point coordinate.

+
Parameters
+ + + + +
osThe output stream.
graphThe graph
[in]vertexIdThe vertex identifier
+
+
+ +

Definition at line 558 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate().

+ +
+
+ +

◆ WritePointCoordinate() [2/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate (std::ostream & os,
TVertex const & vertex 
)
+ 		+inlineprivate
+
+ +

Writes a point coordinate.

+
Parameters
+ + + +
osThe output stream.
vertexThe vertex
+
+
+ +

Definition at line 573 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate().

+ +
+
+ +

◆ WritePointCoordinate() [3/3]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePointCoordinate (std::ostream & os,
Types::real xCoordinate,
Types::real yCoordinate,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a point coordinate.

+
Parameters
+ + + + +
osThe output stream.
[in]xCoordinateThe coordinate
[in]yCoordinateThe y coordinate
+
+
+ +

Definition at line 537 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent().

+ +
+
+ +

◆ WritePropertiesBegin()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesBegin (std::ostream & os,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a properties begin.

+
Parameters
+ + + +
osThe output stream.
[in]indentThe indent.
+
+
+ +

Definition at line 211 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WritePropertiesEnd()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesEnd (std::ostream & os,
bool last = false,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes a properties end.

+
Parameters
+ + + + +
osThe output stream.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 351 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::Indent(), and egoa::IO::GeoJsonWriter< GraphType >::NewLine().

+ +
+
+ +

◆ WriteVertexProperties()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteVertexProperties (std::ostream & os,
TVertexProperties const & vertexProperty,
Types::count indent = 2 
)
+ 		+inlineprivate
+
+ +

Writes vertex properties.

+
Parameters
+ + + + +
osThe output stream.
vertexPropertyThe vertex property.
[in]indentThe indent.
+
+
+ +

Definition at line 227 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ WriteVertices()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::GeoJsonWriter< GraphType >::WriteVertices (std::ostream & os,
TGraph const & graph,
bool last = false,
Types::count indent = 1 
)
+ 		+inlineprivate
+
+ +

Writes points.

+
Parameters
+ + + + + +
osThe output stream.
graphThe graph.
[in]lastThe last.
[in]indentThe indent.
+
+
+ +

Definition at line 429 of file GeojsonWriter.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureBegin(), egoa::IO::GeoJsonWriter< GraphType >::WriteFeatureEnd(), egoa::IO::GeoJsonWriter< GraphType >::WritePoint(), egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesBegin(), egoa::IO::GeoJsonWriter< GraphType >::WritePropertiesEnd(), and egoa::IO::GeoJsonWriter< GraphType >::WriteVertexProperties().

+ +
+
+

Member Data Documentation

+ +

◆ indent_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::count const egoa::IO::GeoJsonWriter< GraphType >::indent_
+ 		+private
+
+ +

Definition at line 734 of file GeojsonWriter.hpp.

+ +
+
+ +

◆ readable_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType> , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
bool egoa::IO::GeoJsonWriter< GraphType >::readable_
+ 		+private
+
+ +

Definition at line 735 of file GeojsonWriter.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_solver_runtime_collection-members.html b/classegoa_1_1_i_o_1_1_solver_runtime_collection-members.html new file mode 100644 index 00000000..84778f52 --- /dev/null +++ b/classegoa_1_1_i_o_1_1_solver_runtime_collection-members.html @@ -0,0 +1,111 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::IO::SolverRuntimeCollection Member List
+
+
+ +

This is the complete list of members for egoa::IO::SolverRuntimeCollection, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
AddMeta(Types::name name, Types::count nrVertices, Types::count nrEdges) (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
avg (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
ComputeStatistics() (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
Dump(ostream &os) (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
Dump(std::string const filename, bool const overwrite=true) const (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
DumpLine(Types::string const filename, TRow const &info, bool const overwrite=false) const (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
filename_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
information (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
max (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
min (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
name_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
NumberOfEdges() const (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
NumberOfEdges() (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
numberOfEdges_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
NumberOfVertices() const (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
NumberOfVertices() (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
numberOfVertices_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
operator+=(TRow &rhs) (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
problemName_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
SolverRuntimeCollection() (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
SolverRuntimeCollection(Types::string filename, bool verbose, Types::string name) (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectioninline
TRow typedef (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollection
verbose_ (defined in egoa::IO::SolverRuntimeCollection)egoa::IO::SolverRuntimeCollectionprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_i_o_1_1_solver_runtime_collection.html b/classegoa_1_1_i_o_1_1_solver_runtime_collection.html new file mode 100644 index 00000000..e8670eb0 --- /dev/null +++ b/classegoa_1_1_i_o_1_1_solver_runtime_collection.html @@ -0,0 +1,801 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IO::SolverRuntimeCollection Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
egoa::IO::SolverRuntimeCollection Class Reference
+
+
+ + + + +

+Public Types

using TRow = SolverRuntimeRow
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Types::count NumberOfVertices () const
 
Types::count & NumberOfVertices ()
 
Types::count NumberOfEdges () const
 
Types::count & NumberOfEdges ()
 
Constructor and destructor
 SolverRuntimeCollection (Types::string filename, bool verbose, Types::string name)
 
Operators
SolverRuntimeCollection & operator+= (TRow &rhs)
 
void AddMeta (Types::name name, Types::count nrVertices, Types::count nrEdges)
 
void ComputeStatistics ()
 
Output
void Dump (ostream &os)
 
void DumpLine (Types::string const filename, TRow const &info, bool const overwrite=false) const
 
void Dump (std::string const filename, bool const overwrite=true) const
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Member
vector< TRow > information
 
TRow min
 
TRow max
 
TRow avg
 
Types::name filename_
 
bool verbose_
 
Types::name problemName_
 
Types::name name_
 
Types::count numberOfVertices_
 
Types::count numberOfEdges_
 
+

Detailed Description

+
+

Definition at line 24 of file SolverRuntimeCollection.hpp.

+

Member Typedef Documentation

+ +

◆ TRow

+ +
+
+ + + + +
using egoa::IO::SolverRuntimeCollection::TRow = SolverRuntimeRow
+
+ +

Definition at line 26 of file SolverRuntimeCollection.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ SolverRuntimeCollection() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
egoa::IO::SolverRuntimeCollection::SolverRuntimeCollection ()
+ 		+inline
+
+ +

Definition at line 32 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ SolverRuntimeCollection() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::IO::SolverRuntimeCollection::SolverRuntimeCollection (Types::string filename,
bool verbose,
Types::string name 
)
+ 		+inline
+
+ +

Definition at line 42 of file SolverRuntimeCollection.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddMeta()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::SolverRuntimeCollection::AddMeta (Types::name name,
Types::count nrVertices,
Types::count nrEdges 
)
+ 		+inline
+
+ +

Definition at line 71 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ ComputeStatistics()

+ +
+
+ + + + + +
+ + + + + + + +
void egoa::IO::SolverRuntimeCollection::ComputeStatistics ()
+ 		+inline
+
+ +

Definition at line 85 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ Dump() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void egoa::IO::SolverRuntimeCollection::Dump (ostream & os)
+ 		+inline
+
+ +

Definition at line 109 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ Dump() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::IO::SolverRuntimeCollection::Dump (std::string const filename,
bool const overwrite = true 
) const
+ 		+inline
+
+ +

Definition at line 194 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ DumpLine()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::IO::SolverRuntimeCollection::DumpLine (Types::string const filename,
TRow const & info,
bool const overwrite = false 
) const
+ 		+inline
+
+ +

Definition at line 173 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ NumberOfEdges() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count & egoa::IO::SolverRuntimeCollection::NumberOfEdges ()
+ 		+inline
+
+ +

Definition at line 220 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ NumberOfEdges() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count egoa::IO::SolverRuntimeCollection::NumberOfEdges () const
+ 		+inline
+
+ +

Definition at line 219 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ NumberOfVertices() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count & egoa::IO::SolverRuntimeCollection::NumberOfVertices ()
+ 		+inline
+
+ +

Definition at line 217 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ NumberOfVertices() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
Types::count egoa::IO::SolverRuntimeCollection::NumberOfVertices () const
+ 		+inline
+
+ +

Definition at line 216 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + +
+ + + + + + + + +
SolverRuntimeCollection & egoa::IO::SolverRuntimeCollection::operator+= (TRow & rhs)
+ 		+inline
+
+ +

Definition at line 59 of file SolverRuntimeCollection.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ avg

+ +
+
+ + + + + +
+ + + + +
TRow egoa::IO::SolverRuntimeCollection::avg
+ 		+private
+
+ +

Definition at line 227 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ filename_

+ +
+
+ + + + + +
+ + + + +
Types::name egoa::IO::SolverRuntimeCollection::filename_
+ 		+private
+
+ +

Definition at line 229 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ information

+ +
+
+ + + + + +
+ + + + +
vector<TRow> egoa::IO::SolverRuntimeCollection::information
+ 		+private
+
+ +

Definition at line 226 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ max

+ +
+
+ + + + + +
+ + + + +
TRow egoa::IO::SolverRuntimeCollection::max
+ 		+private
+
+ +

Definition at line 227 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ min

+ +
+
+ + + + + +
+ + + + +
TRow egoa::IO::SolverRuntimeCollection::min
+ 		+private
+
+ +

Definition at line 227 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ name_

+ +
+
+ + + + + +
+ + + + +
Types::name egoa::IO::SolverRuntimeCollection::name_
+ 		+private
+
+ +

Definition at line 233 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ numberOfEdges_

+ +
+
+ + + + + +
+ + + + +
Types::count egoa::IO::SolverRuntimeCollection::numberOfEdges_
+ 		+private
+
+ +

Definition at line 236 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ numberOfVertices_

+ +
+
+ + + + + +
+ + + + +
Types::count egoa::IO::SolverRuntimeCollection::numberOfVertices_
+ 		+private
+
+ +

Definition at line 235 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ problemName_

+ +
+
+ + + + + +
+ + + + +
Types::name egoa::IO::SolverRuntimeCollection::problemName_
+ 		+private
+
+ +

Definition at line 232 of file SolverRuntimeCollection.hpp.

+ +
+
+ +

◆ verbose_

+ +
+
+ + + + + +
+ + + + +
bool egoa::IO::SolverRuntimeCollection::verbose_
+ 		+private
+
+ +

Definition at line 230 of file SolverRuntimeCollection.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_ieee_cdf_matlab_parser-members.html b/classegoa_1_1_ieee_cdf_matlab_parser-members.html new file mode 100644 index 00000000..de6e383a --- /dev/null +++ b/classegoa_1_1_ieee_cdf_matlab_parser-members.html @@ -0,0 +1,114 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::IeeeCdfMatlabParser< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::IeeeCdfMatlabParser< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
genericTimestamp_ (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
genericWeighting_ (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
IeeeCdfMatlabParser(std::istream &input_stream) (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >inlineexplicit
init() (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
initialized_ (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
input_stream_ (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
mapVertexName2Id_ (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
read(TNetwork &network) (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >inline
readBaseMva(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
readBranchMatrix(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
readBusMatrix(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
readCaseName(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
readGeneratorMatrix(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
readNetwork(TNetwork &network)egoa::IeeeCdfMatlabParser< GraphType >inlineprivate
TBound typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TEdgeProperties typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TElectricalEdge typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TElectricalVertex typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TGeneratorProperties typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TLoadProperties typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TNetwork typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
toLower(std::string &str) (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >inlineprivatestatic
toUpper(std::string &str) (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >inlineprivatestatic
TVertex typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TVertexProperties typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
TVertexType typedef (defined in egoa::IeeeCdfMatlabParser< GraphType >)egoa::IeeeCdfMatlabParser< GraphType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_ieee_cdf_matlab_parser.html b/classegoa_1_1_ieee_cdf_matlab_parser.html new file mode 100644 index 00000000..c7c12dbc --- /dev/null +++ b/classegoa_1_1_ieee_cdf_matlab_parser.html @@ -0,0 +1,954 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IeeeCdfMatlabParser< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +Private Member Functions | +Static Private Member Functions | +Private Attributes | +List of all members
+
egoa::IeeeCdfMatlabParser< GraphType > Class Template Referencefinal
+
+
+ + + + + + +

+Public Member Functions

 IeeeCdfMatlabParser (std::istream &input_stream)
 
bool read (TNetwork &network)
 
+ + + + + + + + + + + + + + + + + + + + + +

+Private Types

using TElectricalVertex = typename GraphType::TVertex
 
using TVertexProperties = typename TElectricalVertex::TProperties
 
using TVertex = typename GraphType::TVertex
 
using TVertexType = typename TVertexProperties::TVertexType
 
using TGeneratorProperties = Vertices::GeneratorProperties< TVertexType >
 
using TLoadProperties = Vertices::LoadProperties< TVertexType >
 
using TElectricalEdge = typename GraphType::TEdge
 
using TEdgeProperties = typename TElectricalEdge::TProperties
 
using TBound = Bound<>
 
using TNetwork = PowerGrid< GraphType >
 
+ + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

void init ()
 
void readBaseMva (TNetwork &network)
 Read base MVA from an m-file in IEEE Common Data Format.
 
void readCaseName (TNetwork &network)
 Read the name of the case.
 
void readBusMatrix (TNetwork &network)
 Read the bus matrix.
 
void readBranchMatrix (TNetwork &network)
 Read the branch matrix.
 
void readGeneratorMatrix (TNetwork &network)
 Read generator matrix.
 
bool readNetwork (TNetwork &network)
 Gammelig.
 
+ + + + + +

+Static Private Member Functions

static void toUpper (std::string &str)
 
static void toLower (std::string &str)
 
+ + + + + + + + + + + +

+Private Attributes

std::istream & input_stream_
 
bool initialized_
 
std::unordered_map< Types::name, Types::index > mapVertexName2Id_
 
const Types::string genericTimestamp_ = "0000-00-00 00:00:00"
 
const Types::real genericWeighting_ = 1.0
 
+

Detailed Description

+
template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+class egoa::IeeeCdfMatlabParser< GraphType >
+

Definition at line 37 of file IeeeCdfMatlabParser.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TBound = Bound<>
+ 		+private
+
+ +

Definition at line 49 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TEdgeProperties = typename TElectricalEdge::TProperties
+ 		+private
+
+ +

Definition at line 48 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TElectricalEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TElectricalEdge = typename GraphType::TEdge
+ 		+private
+
+ +

Definition at line 47 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TElectricalVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TElectricalVertex = typename GraphType::TVertex
+ 		+private
+
+ +

Definition at line 39 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TGeneratorProperties = Vertices::GeneratorProperties<TVertexType>
+ 		+private
+
+ +

Definition at line 45 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TLoadProperties = Vertices::LoadProperties<TVertexType>
+ 		+private
+
+ +

Definition at line 46 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TNetwork = PowerGrid<GraphType>
+ 		+private
+
+ +

Definition at line 50 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TVertex = typename GraphType::TVertex
+ 		+private
+
+ +

Definition at line 41 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TVertexProperties = typename TElectricalVertex::TProperties
+ 		+private
+
+ +

Definition at line 40 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::IeeeCdfMatlabParser< GraphType >::TVertexType = typename TVertexProperties::TVertexType
+ 		+private
+
+ +

Definition at line 43 of file IeeeCdfMatlabParser.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ IeeeCdfMatlabParser()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
egoa::IeeeCdfMatlabParser< GraphType >::IeeeCdfMatlabParser (std::istream & input_stream)
+ 		+inlineexplicit
+
+ +

Definition at line 498 of file IeeeCdfMatlabParser.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ init()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::init ()
+ 		+inlineprivate
+
+ +

Definition at line 61 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ read()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::IeeeCdfMatlabParser< GraphType >::read (TNetwork & network)
+ 		+inline
+
+ +

Definition at line 504 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readBaseMva()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::readBaseMva (TNetwork & network)
+ 		+inlineprivate
+
+ +

Read base MVA from an m-file in IEEE Common Data Format.

+

This value is necessary for the per Unit system.

+
Parameters
+ + +
[in,out]networkThe parameter base MVA is changed in this method.
+
+
+ +

Definition at line 71 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readBranchMatrix()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::readBranchMatrix (TNetwork & network)
+ 		+inlineprivate
+
+ +

Read the branch matrix.

+

While reading each row of the matrix a arc is created and added to the network with edge.Conductance() = G not in data ( $ \frac{R}{|Z|} $, with $ |Z| = R^2 + X^2 $) edge.Susceptance() = B not in data ( $ \frac{X}{|Z|} $, with $ |Z| = R^2 + X^2 $) edge.Resistance() = r (or R for resistance) edge.Reactance() = x (or X for reactance) edge.Charge() = b (for charge) edge.ThermalLimit() = rateA (Standard line capacity/thermal line limit) edge.ThermalLimitB() = rateB (Emergency line capacity/thermal line limit) edge.ThermalLimitC() = rateC (Emergency line capacity/thermal line limit) edge.TapRatio() = ratio (tap ratio) edge.AngleShift() = angle.pi/180 (angle is transformed into radian $ \frac{angle^\circ\cdot\pi}{180^\circ} $ rad, since $ \pi = 180^\circ $) edge.cc = not in data ( $ ratio\cdot\cos\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $) edge.dd = not in data ( $ ratio\cdot\sin\left( \frac{angle^\circ\cdot\pi}{180^\circ} \right) $) edge.Status() = status edge.ThetaBound().Minimum() = angmin.pi/180 (angle is transformed into radian $ \frac{angmin^\circ\cdot\pi}{180^\circ} $ rad, since $ \pi = 180^\circ $) edge.ThetaBound().Maximum() = angmax.pi/180 (angle is transformed into radian $ \frac{angmax^\circ\cdot\pi}{180^\circ} $ rad, since $ \pi = 180^\circ $)

+

IGNORE: rateB, rateC

+
Parameters
+ + +
[in,out]networkNetowork with all arcs
+
+
+ +

Definition at line 270 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readBusMatrix()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::readBusMatrix (TNetwork & network)
+ 		+inlineprivate
+
+ +

Read the bus matrix.

+

While reading each line of the matrix a vertex is created and added to the network with vertex.Name() = bus_i, vertex.Type() = type, vertex.RealPowerLoad() = Pd / base_mva, vertex.ReactivePowerLoad() = Qd / base_mva, vertex.ShuntConductance() = Gs / base_mva, vertex.ShuntSusceptance() = Bs / base_mva, vertex.Area() = area, vertex.VoltageMagnitude() = Vm, vertex.VoltageAngleSnapshot() = Va, vertex.BaseKV = baseKV, vertex.Zone() = zone, vertex.MaximumVoltage() = Vmax, vertex.MinimumVoltage() = Vmin.

+
Parameters
+ + +
[in,out]networkAdd all buses to the network
+
+
+ +

Definition at line 120 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readCaseName()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::readCaseName (TNetwork & network)
+ 		+inlineprivate
+
+ +

Read the name of the case.

+

The name of the power grid, e.g. case14 for the 14 bus system.

+
Parameters
+ + +
[in,out]networkThe parameter changes the name of the network
+
+
+ +

Definition at line 88 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readGeneratorMatrix()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::IeeeCdfMatlabParser< GraphType >::readGeneratorMatrix (TNetwork & network)
+ 		+inlineprivate
+
+ +

Read generator matrix.

+

While reading each row of the matrix a generator is created and added to the network vertex.Name() = bus vertex.RealPower() = Pg / base_mva, vertex.ReactivePower() = Qg / base_mva, vertex.ReactivePowerBound().Maximum() = Qmax / base_mva, vertex.ReactivePowerBound().Minimum() = Qmin / base_mva, vertex.VoltageMagnitude() = Vg vertex.Mbase() = mBase vertex.Status() = status vertex.RealPowerBound().Maximum() = Pmax / base_mva, vertex.RealPowerBound().Minimum() = Pmin / base_mva, vertex.Pc1() = Pc1 vertex.Pc2() = Pc2 vertex.Qc1Bound().Minimum() = Qc1min vertex.Qc1Bound().Maximum() = Qc1max vertex.Qc2Bound().Minimum() = Qc2min vertex.Qc2Bound().Maximum() = Qc2max vertex.RampAgc() = ramp_agc vertex.Ramp10() = ramp_10 vertex.Ramp30() = ramp_30 vertex.RampQ() = ramp_q vertex.Apf() = apf

+
Parameters
+ + +
[in,out]networkNetwork with all generator
+
+
+ +

Definition at line 386 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ readNetwork()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::IeeeCdfMatlabParser< GraphType >::readNetwork (TNetwork & network)
+ 		+inlineprivate
+
+ +

Gammelig.

+
Todo:
add both possible function types
+

Gammelig

+
Parameters
+ + +
networkGammelig
+
+
+ +

Definition at line 486 of file IeeeCdfMatlabParser.hpp.

+ +

References egoa::IeeeCdfMatlabParser< GraphType >::readBaseMva(), egoa::IeeeCdfMatlabParser< GraphType >::readBranchMatrix(), egoa::IeeeCdfMatlabParser< GraphType >::readBusMatrix(), egoa::IeeeCdfMatlabParser< GraphType >::readCaseName(), and egoa::IeeeCdfMatlabParser< GraphType >::readGeneratorMatrix().

+ +
+
+ +

◆ toLower()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
static void egoa::IeeeCdfMatlabParser< GraphType >::toLower (std::string & str)
+ 		+inlinestaticprivate
+
+ +

Definition at line 57 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ toUpper()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
static void egoa::IeeeCdfMatlabParser< GraphType >::toUpper (std::string & str)
+ 		+inlinestaticprivate
+
+ +

Definition at line 53 of file IeeeCdfMatlabParser.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ genericTimestamp_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
const Types::string egoa::IeeeCdfMatlabParser< GraphType >::genericTimestamp_ = "0000-00-00 00:00:00"
+ 		+private
+
+ +

Definition at line 513 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ genericWeighting_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
const Types::real egoa::IeeeCdfMatlabParser< GraphType >::genericWeighting_ = 1.0
+ 		+private
+
+ +

Definition at line 514 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ initialized_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
bool egoa::IeeeCdfMatlabParser< GraphType >::initialized_
+ 		+private
+
+ +

Definition at line 510 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ input_stream_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::istream& egoa::IeeeCdfMatlabParser< GraphType >::input_stream_
+ 		+private
+
+ +

Definition at line 509 of file IeeeCdfMatlabParser.hpp.

+ +
+
+ +

◆ mapVertexName2Id_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType > , Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, Types::index> egoa::IeeeCdfMatlabParser< GraphType >::mapVertexName2Id_
+ 		+private
+
+ +

Definition at line 511 of file IeeeCdfMatlabParser.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_kruskal-members.html b/classegoa_1_1_kruskal-members.html new file mode 100644 index 00000000..dd0c530c --- /dev/null +++ b/classegoa_1_1_kruskal-members.html @@ -0,0 +1,105 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Kruskal< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::Kruskal< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
Comparator() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
comparator_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
Graph() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
Graph() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
graph_egoa::MST< GraphType >private
Kruskal(TGraph &graph, TComparator comparator) (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >inline
MST(TGraph &graph, TComparator comparator) (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inline
Result() constegoa::MST< GraphType >inline
Run() overrideegoa::Kruskal< GraphType >inlinevirtual
SetResult(std::vector< Types::edgeId > &&edges)egoa::MST< GraphType >inlineprotected
spanningTree_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
TComparator typedef (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >private
TEdge typedef (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >private
TGraph typedef (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >private
TSpanningTree typedef (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >private
~Kruskal() (defined in egoa::Kruskal< GraphType >)egoa::Kruskal< GraphType >inlinevirtual
~MST() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_kruskal.html b/classegoa_1_1_kruskal.html new file mode 100644 index 00000000..b6c35ae6 --- /dev/null +++ b/classegoa_1_1_kruskal.html @@ -0,0 +1,385 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Kruskal< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +List of all members
+
egoa::Kruskal< GraphType > Class Template Referencefinal
+
+
+ +

An implementation of Kruskal's algorithm for finding minimum spanning trees. + More...

+ +

#include <Kruskal.hpp>

+
+Inheritance diagram for egoa::Kruskal< GraphType >:
+
+
+ + +egoa::MST< GraphType > + +
+ + + + + + + + + + + + + +

+Public Member Functions

 Kruskal (TGraph &graph, TComparator comparator)
 
virtual void Run () override
 Kruskal's Algorithm.
 
- Public Member Functions inherited from egoa::MST< GraphType >
 MST (TGraph &graph, TComparator comparator)
 
Subgraph< TGraph > const & Result () const
 Returns the caluclated spanning tree after Run() has been called.
 
+ + + + + + + + + +

+Private Types

using TSpanningTree = MST< GraphType >
 
using TGraph = GraphType
 
using TEdge = typename TGraph::TEdge
 
using TComparator = std::function< bool(Types::edgeId, Types::edgeId)>
 
+ + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Types inherited from egoa::MST< GraphType >
using TGraph = GraphType
 
using TEdge = typename TGraph::TEdge
 
using TComparator = std::function< bool(Types::edgeId, Types::edgeId)>
 
- Protected Member Functions inherited from egoa::MST< GraphType >
void SetResult (std::vector< Types::edgeId > &&edges)
 Builds a subgraph object representing the spanning tree given by the edges.
 
GraphType const & Graph () const
 
GraphType & Graph ()
 
TComparator const & Comparator () const
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::Kruskal< GraphType >

An implementation of Kruskal's algorithm for finding minimum spanning trees.

+
Kuskal<TGraph> kruskal(graph, comparator);
+
kruskal.Run();
+
Subgraph<TGraph> spanningTree = kruskal.Result();
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 29 of file Kruskal.hpp.

+

Member Typedef Documentation

+ +

◆ TComparator

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TComparator = std::function<bool(Types::edgeId, Types::edgeId)>
+ 		+private
+
+ +

Definition at line 42 of file MST.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TEdge = typename TGraph::TEdge
+ 		+private
+
+ +

Definition at line 41 of file MST.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 40 of file MST.hpp.

+ +
+
+ +

◆ TSpanningTree

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::Kruskal< GraphType >::TSpanningTree = MST<GraphType>
+ 		+private
+
+ +

Definition at line 31 of file Kruskal.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Kruskal()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Kruskal< GraphType >::Kruskal (TGraph & graph,
TComparator comparator 
)
+ 		+inline
+
+ +

Definition at line 37 of file Kruskal.hpp.

+ +
+
+ +

◆ ~Kruskal()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual egoa::Kruskal< GraphType >::~Kruskal ()
+ 		+inlinevirtual
+
+ +

Definition at line 42 of file Kruskal.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Run()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual void egoa::Kruskal< GraphType >::Run ()
+ 		+inlineoverridevirtual
+
+ +

Kruskal's Algorithm.

+

Kruskal's algorithm runs in O(|E| lg |V|) using binary heaps and calculates a MST. It uses techniques that are also common for connected component algorithms.

+

Steps:

    +
  1. Increases the MST by exactly one edge in each iteration
    2. +
  2. It starts with |V| components
    3. +
  3. In each iteration the number of connected components shrinks by 1
    4. +
  4. To manage the connected components it uses a disjoint-set data structure
    5. +
+ +

Implements egoa::MST< GraphType >.

+ +

Definition at line 57 of file Kruskal.hpp.

+ +

References egoa::UnionFind::InSameComponent(), egoa::MST< GraphType >::SetResult(), and egoa::UnionFind::Union().

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_kruskal.png b/classegoa_1_1_kruskal.png new file mode 100644 index 00000000..420139d6 Binary files /dev/null and b/classegoa_1_1_kruskal.png differ diff --git a/classegoa_1_1_label-members.html b/classegoa_1_1_label-members.html new file mode 100644 index 00000000..bedea6af --- /dev/null +++ b/classegoa_1_1_label-members.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Label< ElementType, VertexSetContainer, PointerType > Member List
+
+
+ +

This is the complete list of members for egoa::Label< ElementType, VertexSetContainer, PointerType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Index() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Index()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
index_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Label(Types::vertexId vertexId)egoa::Label< ElementType, VertexSetContainer, PointerType >inline
Label(Label const &label)=defaultegoa::Label< ElementType, VertexSetContainer, PointerType >
operator<<egoa::Label< ElementType, VertexSetContainer, PointerType >friend
PreviousLabel() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousLabel()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousLabelId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
PreviousVertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousVertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousVertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
TElement typedefegoa::Label< ElementType, VertexSetContainer, PointerType >
TLabel typedefegoa::Label< ElementType, VertexSetContainer, PointerType >
TPointer typedef (defined in egoa::Label< ElementType, VertexSetContainer, PointerType >)egoa::Label< ElementType, VertexSetContainer, PointerType >
TVertexId typedefegoa::Label< ElementType, VertexSetContainer, PointerType >
TVertexSet typedefegoa::Label< ElementType, VertexSetContainer, PointerType >
Valid() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Valid()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
valid_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Vertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Vertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
vertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
~Label()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_label.html b/classegoa_1_1_label.html new file mode 100644 index 00000000..5439aad4 --- /dev/null +++ b/classegoa_1_1_label.html @@ -0,0 +1,963 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Label< ElementType, VertexSetContainer, PointerType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +Friends | +List of all members
+
egoa::Label< ElementType, VertexSetContainer, PointerType > Class Template Reference
+
+
+ +

Interface for label. + More...

+ +

#include <Label.hpp>

+
+Inheritance diagram for egoa::Label< ElementType, VertexSetContainer, PointerType >:
+
+
+ + +egoa::SusceptanceNormLabel< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId > +egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > +egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > + +
+ + + + + + + + + + + + +

+Public Types

using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
using TPointer = PointerType
 
using TLabel = Label< TElement, TVertexSet, TPointer >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 Label (Types::vertexId vertexId)
 Constructs the label object.
 
 Label (Label const &label)=default
 Copy constructor.
 
 ~Label ()
 Destroys the label object.
 
Getter and Setter

In place addition.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
Label with added TElement.
+
Types::labelId Index () const
 Getter for the label identifier.
 
Types::labelId & Index ()
 Setter for the label identifier.
 
bool Valid () const
 Getter for the valid flag.
 
bool & Valid ()
 Setter for the valid flag.
 
Types::vertexId Vertex () const
 Getter for the value of the label.
 
Types::vertexId & Vertex ()
 Setter for the vertex identifier.
 
TPointer PreviousVertex () const
 Getter for the previous vertex.
 
TPointer & PreviousVertex ()
 Setter for the previous vertex.
 
TPointer PreviousLabel () const
 Getter and setter for the previous label.
 
TPointer & PreviousLabel ()
 Setter for the previous label.
 
+ + + + + + + + + + + +

+Private Attributes

Types::labelId index_
 
Types::vertexId vertexId_
 
bool valid_
 
TPointer previousVertexId_
 
TPointer previousLabelId_
 
+ + + + +

+Friends

std::ostream & operator<< (std::ostream &os, Label const &rhs)
 Output stream.
 
+

Detailed Description

+
template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+class egoa::Label< ElementType, VertexSetContainer, PointerType >

Interface for label.

+

This class represents an interface that has to implemented by all labels.

+
Template Parameters
+ + + + +
ElementTypeSome element type, e.g., an electrical edge.
VertexSetContainerContainer, e.g., unordered set to extract vertex conflicts, loops.
PointerTypeE.g., Types::vertexId.
+
+
+
See also
Edge::ElectricalEdge representing an ElementType interface.
+
+BucketElement representing an minimum interface requirement for a bucket.
+ +

Definition at line 34 of file Label.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TElement = ElementType
+
+

Some element to cover such as an edge.

+ +

Definition at line 39 of file Label.hpp.

+ +
+
+ +

◆ TLabel

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TLabel = Label<TElement,TVertexSet, TPointer>
+
+

The label's own type.

+ +

Definition at line 44 of file Label.hpp.

+ +
+
+ +

◆ TPointer

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TPointer = PointerType
+
+ +

Definition at line 42 of file Label.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexId = Types::vertexId
+
+

The vertex identifier type used in LabelStruct.

+ +

Definition at line 37 of file Label.hpp.

+ +
+
+ +

◆ TVertexSet

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexSet = VertexSetContainer
+
+

A hash map of TVertex.

+ +

Definition at line 40 of file Label.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Label() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::Label< ElementType, VertexSetContainer, PointerType >::Label (Types::vertexId vertexId)
+ 		+inline
+
+ +

Constructs the label object.

+

The label identifier and previous label/vertex identifiers are set to Const::NONE. The valid flag is set to True.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 59 of file Label.hpp.

+ +
+
+ +

◆ Label() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::Label< ElementType, VertexSetContainer, PointerType >::Label (Label< ElementType, VertexSetContainer, PointerType > const & label)
+ 		+default
+
+ +

Copy constructor.

+

Constructs the label object by using the values of the other label.

+
Parameters
+ + +
labelThe label.
+
+
+ +
+
+ +

◆ ~Label()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
egoa::Label< ElementType, VertexSetContainer, PointerType >::~Label ()
+ 		+inline
+
+ +

Destroys the label object.

+ +

Definition at line 81 of file Label.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Index() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::labelId & egoa::Label< ElementType, VertexSetContainer, PointerType >::Index ()
+ 		+inline
+
+ +

Setter for the label identifier.

+

This identifier is set while the label is moved to the processed elements in the bucket. Thus, the element will be fixed to this position.

+
this->Index() = 9;
+
egoa::Label::Index
Types::labelId Index() const
Getter for the label identifier.
Definition Label.hpp:131
+
Returns
The label's identifier.
+ +

Definition at line 148 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::index_.

+ +
+
+ +

◆ Index() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::labelId egoa::Label< ElementType, VertexSetContainer, PointerType >::Index () const
+ 		+inline
+
+ +

Getter for the label identifier.

+

This identifier represents the label's position, e.g., within the buckets processed elements.

Todo:
For the vertices and edges the equivalent function is called Identifier(), which is more in line with the nomenclature in the comments. However, the paramters are usually called index.
+
Returns
The label's identifier.
+ +

Definition at line 131 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::index_.

+ +
+
+ +

◆ PreviousLabel() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TPointer & egoa::Label< ElementType, VertexSetContainer, PointerType >::PreviousLabel ()
+ 		+inline
+
+ +

Setter for the previous label.

+
Todo:
It seems to be strange to call this a setter because it can also be used to "get" the value, e.g., the following code calls this member function but does not change the value:
+
Label<T> label = ...;
+
Types::labelId id = label.PreviousLabel():
+
egoa::Label
Interface for label.
Definition Label.hpp:34
+
egoa::Label::PreviousLabel
TPointer PreviousLabel() const
Getter and setter for the previous label.
Definition Label.hpp:239
+

e This applies to all other "getters" and "setters".

+
this->PreviousLabel() = 2;
+
Returns
Identifier of the previous label.
+ +

Definition at line 261 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::previousLabelId_.

+ +
+
+ +

◆ PreviousLabel() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TPointer egoa::Label< ElementType, VertexSetContainer, PointerType >::PreviousLabel () const
+ 		+inline
+
+ +

Getter and setter for the previous label.

+
Returns
Identifier of the previous label.
+ +

Definition at line 239 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::previousLabelId_.

+ +
+
+ +

◆ PreviousVertex() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TPointer & egoa::Label< ElementType, VertexSetContainer, PointerType >::PreviousVertex ()
+ 		+inline
+
+ +

Setter for the previous vertex.

+
this->PreviousVertex() = 41;
+
egoa::Label::PreviousVertex
TPointer PreviousVertex() const
Getter for the previous vertex.
Definition Label.hpp:215
+
Returns
Identifier of the previous vertex.
+ +

Definition at line 229 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::previousVertexId_.

+ +
+
+ +

◆ PreviousVertex() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TPointer egoa::Label< ElementType, VertexSetContainer, PointerType >::PreviousVertex () const
+ 		+inline
+
+ +

Getter for the previous vertex.

+
Returns
Identifier of the previous vertex.
+ +

Definition at line 215 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::previousVertexId_.

+ +
+
+ +

◆ Valid() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
bool & egoa::Label< ElementType, VertexSetContainer, PointerType >::Valid ()
+ 		+inline
+
+ +

Setter for the valid flag.

+
this->Valid() = false;
+
egoa::Label::Valid
bool Valid() const
Getter for the valid flag.
Definition Label.hpp:158
+
Returns
True if the label is valid, False otherwise.
+ +

Definition at line 172 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::valid_.

+ +
+
+ +

◆ Valid() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
bool egoa::Label< ElementType, VertexSetContainer, PointerType >::Valid () const
+ 		+inline
+
+ +

Getter for the valid flag.

+
Returns
True if the label is valid, False otherwise.
+ +

Definition at line 158 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::valid_.

+ +
+
+ +

◆ Vertex() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::vertexId & egoa::Label< ElementType, VertexSetContainer, PointerType >::Vertex ()
+ 		+inline
+
+ +

Setter for the vertex identifier.

+
this->Vertex() = 42;
+
egoa::Label::Vertex
Types::vertexId Vertex() const
Getter for the value of the label.
Definition Label.hpp:191
+
Returns
Vertex identifier.
+ +

Definition at line 205 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::vertexId_.

+ +
+
+ +

◆ Vertex() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::Label< ElementType, VertexSetContainer, PointerType >::Vertex () const
+ 		+inline
+
+ +

Getter for the value of the label.

+

Represents the total value of the label. This is comparable with an objective value.

+
Returns
The value of the label.
+

Getter for the vertex identifier.

+
Returns
Vertex identifier.
+ +

Definition at line 191 of file Label.hpp.

+ +

References egoa::Label< ElementType, VertexSetContainer, PointerType >::vertexId_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
Label< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Output stream.

+
Parameters
+ + + +
osThe output stream such as std::cout.
rhsThe right hand side Label.
+
+
+
Returns
The output stream.
+ +

Definition at line 276 of file Label.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ index_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
Types::labelId egoa::Label< ElementType, VertexSetContainer, PointerType >::index_
+ 		+private
+
+

The identifier of the label that is bucket dependent.

+ +

Definition at line 284 of file Label.hpp.

+ +
+
+ +

◆ previousLabelId_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
TPointer egoa::Label< ElementType, VertexSetContainer, PointerType >::previousLabelId_
+ 		+private
+
+

The identifier of the previous label.

+ +

Definition at line 290 of file Label.hpp.

+ +
+
+ +

◆ previousVertexId_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
TPointer egoa::Label< ElementType, VertexSetContainer, PointerType >::previousVertexId_
+ 		+private
+
+

The identifier of the previous vertex.

+ +

Definition at line 289 of file Label.hpp.

+ +
+
+ +

◆ valid_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
bool egoa::Label< ElementType, VertexSetContainer, PointerType >::valid_
+ 		+private
+
+

The valid flag that is True if the label is valid, False otherwise.

+ +

Definition at line 287 of file Label.hpp.

+ +
+
+ +

◆ vertexId_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
Types::vertexId egoa::Label< ElementType, VertexSetContainer, PointerType >::vertexId_
+ 		+private
+
+

The identifier of the vertex to which the label belongs.

+ +

Definition at line 285 of file Label.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_label.png b/classegoa_1_1_label.png new file mode 100644 index 00000000..13170573 Binary files /dev/null and b/classegoa_1_1_label.png differ diff --git a/classegoa_1_1_m_s_t-members.html b/classegoa_1_1_m_s_t-members.html new file mode 100644 index 00000000..6fbe43ce --- /dev/null +++ b/classegoa_1_1_m_s_t-members.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::MST< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::MST< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + +
Comparator() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
comparator_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
Graph() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
Graph() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
graph_egoa::MST< GraphType >private
MST(TGraph &graph, TComparator comparator) (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inline
operator<< (defined in egoa::MST< GraphType >)egoa::MST< GraphType >friend
Result() constegoa::MST< GraphType >inline
Run()=0 (defined in egoa::MST< GraphType >)egoa::MST< GraphType >pure virtual
SetResult(std::vector< Types::edgeId > &&edges)egoa::MST< GraphType >inlineprotected
spanningTree_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
TComparator typedef (defined in egoa::MST< GraphType >)egoa::MST< GraphType >protected
TEdge typedef (defined in egoa::MST< GraphType >)egoa::MST< GraphType >protected
TGraph typedef (defined in egoa::MST< GraphType >)egoa::MST< GraphType >protected
~MST() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_m_s_t.html b/classegoa_1_1_m_s_t.html new file mode 100644 index 00000000..28ce5d39 --- /dev/null +++ b/classegoa_1_1_m_s_t.html @@ -0,0 +1,632 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::MST< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Types | +Protected Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::MST< GraphType > Class Template Referenceabstract
+
+
+ +

Base class for minimum spanning tree algorithms. + More...

+ +

#include <MST.hpp>

+
+Inheritance diagram for egoa::MST< GraphType >:
+
+
+ + +egoa::Kruskal< GraphType > +egoa::Prim< GraphType > + +
+ + + + + + + + + +

+Public Member Functions

 MST (TGraph &graph, TComparator comparator)
 
virtual void Run ()=0
 
Subgraph< TGraph > const & Result () const
 Returns the caluclated spanning tree after Run() has been called.
 
+ + + + + + + +

+Protected Types

using TGraph = GraphType
 
using TEdge = typename TGraph::TEdge
 
using TComparator = std::function< bool(Types::edgeId, Types::edgeId)>
 
+ + + + + + + + + + + +

+Protected Member Functions

void SetResult (std::vector< Types::edgeId > &&edges)
 Builds a subgraph object representing the spanning tree given by the edges.
 
Getter and setter
GraphType const & Graph () const
 
GraphType & Graph ()
 
TComparator const & Comparator () const
 
+ + + + + + + +

+Private Attributes

GraphType & graph_
 
TComparator comparator_
 
Subgraph< TGraph > spanningTree_ {&graph_, {}, {}}
 
+ + + +

+Friends

std::ostream & operator<< (std::ostream &os, MST const &rhs)
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::MST< GraphType >

Base class for minimum spanning tree algorithms.

+

Typically, minimum spanning tree algorithms are used like this:

auto mstAlgorithm(graph, comparator);
+
mstAlgorithm.Run();
+
Subgraph<TGraph> mst = mstAlgorithm.Result();
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 38 of file MST.hpp.

+

Member Typedef Documentation

+ +

◆ TComparator

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TComparator = std::function<bool(Types::edgeId, Types::edgeId)>
+ 		+protected
+
+ +

Definition at line 42 of file MST.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TEdge = typename TGraph::TEdge
+ 		+protected
+
+ +

Definition at line 41 of file MST.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TGraph = GraphType
+ 		+protected
+
+ +

Definition at line 40 of file MST.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ MST()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::MST< GraphType >::MST (TGraph & graph,
TComparator comparator 
)
+ 		+inline
+
+ +

Definition at line 45 of file MST.hpp.

+ +
+
+ +

◆ ~MST()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual egoa::MST< GraphType >::~MST ()
+ 		+inlinevirtual
+
+ +

Definition at line 51 of file MST.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Comparator()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TComparator const & egoa::MST< GraphType >::Comparator () const
+ 		+inlineprotected
+
+ +

Definition at line 103 of file MST.hpp.

+ +
+
+ +

◆ Graph() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
GraphType & egoa::MST< GraphType >::Graph ()
+ 		+inlineprotected
+
+ +

Definition at line 101 of file MST.hpp.

+ +
+
+ +

◆ Graph() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
GraphType const & egoa::MST< GraphType >::Graph () const
+ 		+inlineprotected
+
+ +

Definition at line 100 of file MST.hpp.

+ +
+
+ +

◆ Result()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Subgraph< TGraph > const & egoa::MST< GraphType >::Result () const
+ 		+inline
+
+ +

Returns the caluclated spanning tree after Run() has been called.

+
Precondition
Run() has been called.
+
Returns
The subgraph representing the calculated spanning tree.
+ +

Definition at line 62 of file MST.hpp.

+ +
+
+ +

◆ Run()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual void egoa::MST< GraphType >::Run ()
+ 		+pure virtual
+
+ +

Implemented in egoa::Kruskal< GraphType >, and egoa::Prim< GraphType >.

+ +
+
+ +

◆ SetResult()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
void egoa::MST< GraphType >::SetResult (std::vector< Types::edgeId > && edges)
+ 		+inlineprotected
+
+ +

Builds a subgraph object representing the spanning tree given by the edges.

+
Parameters
+ + +
edgesThe edges in the spanning tree.
+
+
+ +

Definition at line 86 of file MST.hpp.

+ +

References egoa::MST< GraphType >::graph_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
MST< GraphType > const & rhs 
)
+ 		+friend
+
+ +

Definition at line 67 of file MST.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ comparator_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
TComparator egoa::MST< GraphType >::comparator_
+ 		+private
+
+ +

Definition at line 108 of file MST.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
GraphType& egoa::MST< GraphType >::graph_
+ 		+private
+
+

Undirected graph G = (V, E)

+ +

Definition at line 107 of file MST.hpp.

+ +
+
+ +

◆ spanningTree_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Subgraph<TGraph> egoa::MST< GraphType >::spanningTree_ {&graph_, {}, {}}
+ 		+private
+
+ +

Definition at line 109 of file MST.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/Algorithms/SpanningTree/MST.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_m_s_t.png b/classegoa_1_1_m_s_t.png new file mode 100644 index 00000000..079da975 Binary files /dev/null and b/classegoa_1_1_m_s_t.png differ diff --git a/classegoa_1_1_mapping_binary_heap-members.html b/classegoa_1_1_mapping_binary_heap-members.html new file mode 100644 index 00000000..ad30d663 --- /dev/null +++ b/classegoa_1_1_mapping_binary_heap-members.html @@ -0,0 +1,143 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::MappingBinaryHeap< ElementType, KeyType, MapType > Member List
+
+
+ +

This is the complete list of members for egoa::MappingBinaryHeap< ElementType, KeyType, MapType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
begin() const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
ChangeKey(const TElement &element, TKey newKey)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
Clear()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
Comparator() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
Comparator(std::function< bool(TKey const &, TKey const &)> comparator)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
comparator_egoa::MappingBinaryHeap< ElementType, KeyType, MapType >private
ComplyHeapProperty() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
ComplyHeapProperty(Types::index index) constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
Delete(TElement const &element)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
DeleteTop()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
ElementAt(Types::index index) (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
ElementAt(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
elementKeyPairs_egoa::MappingBinaryHeap< ElementType, KeyType, MapType >private
Emplace(Args &&... args)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
Empty() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
end() const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
for_all_elements(FUNCTION function) constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
HasChildren(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
HasKeyOf(TElement const &element) constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
HasLeftChild(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
HasParent(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
HasRightChild(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
IndexOf(TElement const &element) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
Insert(TElement element, TKey key)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
Insert(std::pair< TElement, TKey > pair)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
KeyAt(Types::index index) (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
KeyAt(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
KeyOf(TElement const &element) constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
LeftChildIdOf(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
MakeHeapProperty()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
map_egoa::MappingBinaryHeap< ElementType, KeyType, MapType >private
MappingBinaryHeap(TComparator comparator=std::less< TKey >(), TMap map=TMap())egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
MappingBinaryHeap(std::vector< std::pair< TElement, TKey > > elementsKeyPairs, TComparator comparator=std::less< TKey >(), TMap map=TMap())egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
MappingBinaryHeap(It first, It last, TComparator comparator=std::less< TKey >(), TMap map=TMap())egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
MaximumIndex() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
operator+=(std::pair< TElement, TKey > pair)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
ParentIdOf(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
Pop()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
RightChildIdOf(Types::index index) const (defined in egoa::MappingBinaryHeap< ElementType, KeyType, MapType >)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
SelectSwappableChildAt(Types::index index) constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
SiftDown()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
SiftDown(Types::index index)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
SiftUp()egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
SiftUp(Types::index index)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
Size() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
swapegoa::MappingBinaryHeap< ElementType, KeyType, MapType >friend
Swap(Types::index first, Types::index second)egoa::MappingBinaryHeap< ElementType, KeyType, MapType >inlineprivate
TComparator typedefegoa::MappingBinaryHeap< ElementType, KeyType, MapType >
TElement typedefegoa::MappingBinaryHeap< ElementType, KeyType, MapType >
TIterator typedefegoa::MappingBinaryHeap< ElementType, KeyType, MapType >
TKey typedefegoa::MappingBinaryHeap< ElementType, KeyType, MapType >
TMap typedefegoa::MappingBinaryHeap< ElementType, KeyType, MapType >
Top() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
TopElement() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
TopKey() constegoa::MappingBinaryHeap< ElementType, KeyType, MapType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_mapping_binary_heap.html b/classegoa_1_1_mapping_binary_heap.html new file mode 100644 index 00000000..d6be8470 --- /dev/null +++ b/classegoa_1_1_mapping_binary_heap.html @@ -0,0 +1,2315 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::MappingBinaryHeap< ElementType, KeyType, MapType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::MappingBinaryHeap< ElementType, KeyType, MapType > Class Template Reference
+
+
+ +

Class for binary heap data structure, in which elements are sorted by keys. + More...

+ +

#include <MappingBinaryHeap.hpp>

+ + + + + + + + + + + + + + + + + +

+Public Types

using TElement = ElementType
 The type of the elements in the heap.
 
using TKey = KeyType
 The type of the keys.
 
using TMap = MapType
 The type of the mapping from elements to indices.
 
using TIterator = typename std::vector< std::pair< TElement, TKey > >::const_iterator
 The type of the iterators.
 
using TComparator = std::function< bool(TKey const &, TKey const &)>
 The type of the comparator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<ExecutionPolicy Policy, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 Iterates over all elements in the heap.
 
Constructors
 MappingBinaryHeap (TComparator comparator=std::less< TKey >(), TMap map=TMap())
 Constructs an empty heap, in which the elements are sorted by their keys in increasing order.
 
 MappingBinaryHeap (std::vector< std::pair< TElement, TKey > > elementsKeyPairs, TComparator comparator=std::less< TKey >(), TMap map=TMap())
 Constructs an heap containing the given elements.
 
template<typename It >
 MappingBinaryHeap (It first, It last, TComparator comparator=std::less< TKey >(), TMap map=TMap())
 Constructs the heap filled with the element-key-pairs.
 
Element Access
std::pair< TElement, TKey > const & Top () const
 The element and the key at the top of the heap.
 
TElement const & TopElement () const
 The element at the top of the heap.
 
TKey const & TopKey () const
 The key of the element at the top of the heap.
 
TKey const & KeyOf (TElement const &element) const
 The key of the element.
 
bool HasKeyOf (TElement const &element) const
 Determines if the element exist in the heap.
 
Inserting Elements
void Insert (TElement element, TKey key)
 Inserts the element with the given key.
 
void Insert (std::pair< TElement, TKey > pair)
 Inserts the element with the given key.
 
MappingBinaryHeap & operator+= (std::pair< TElement, TKey > pair)
 Inserts the element with the given key.
 
template<typename... Args>
void Emplace (Args &&... args)
 Constructs an element-key-pair inplace.
 
Removing Elements
std::pair< TElement, TKey > DeleteTop ()
 Deletes the top element and returns it and its key.
 
void Pop ()
 Deletes the top element.
 
std::pair< TElement, TKey > Delete (TElement const &element)
 Deletes an element from the heap.
 
void Clear ()
 Removes all elements from the heap.
 
Updating Elements
void ChangeKey (const TElement &element, TKey newKey)
 Changes the key of the element.
 
Capacity
bool Empty () const
 Whether the heap is empty.
 
Types::count Size () const
 The number of elements in the heap.
 
Comparator
std::function< bool(TKey const &, TKey const &)> const & Comparator () const
 The comparator.
 
void Comparator (std::function< bool(TKey const &, TKey const &)> comparator)
 Changes the comparator.
 
Iteration
TIterator begin () const
 
TIterator end () const
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

TElement & ElementAt (Types::index index)
 
TElement const & ElementAt (Types::index index) const
 
TKey & KeyAt (Types::index index)
 
TKey const & KeyAt (Types::index index) const
 
Types::index LeftChildIdOf (Types::index index) const
 
Types::index RightChildIdOf (Types::index index) const
 
bool HasChildren (Types::index index) const
 
bool HasLeftChild (Types::index index) const
 
bool HasRightChild (Types::index index) const
 
Types::index ParentIdOf (Types::index index) const
 
bool HasParent (Types::index index) const
 
Types::index IndexOf (TElement const &element) const
 
Types::index MaximumIndex () const
 The largest index of elements in the heap.
 
void SiftUp ()
 Sifts the last element in the heap up.
 
void SiftUp (Types::index index)
 Sifts the element at index up.
 
void SiftDown ()
 Sifts the first element in the heap down.
 
void SiftDown (Types::index index)
 Sifts the element at index down.
 
void Swap (Types::index first, Types::index second)
 Swaps the elements and keys at the indices first and second and updates the mapping.
 
Types::index SelectSwappableChildAt (Types::index index) const
 Selects the smallest child, where smallest is measured according to the comparator.
 
bool ComplyHeapProperty () const
 Whether the heap property is fulfilled.
 
bool ComplyHeapProperty (Types::index index) const
 Whether the element at position index is smaller than its childred.
 
void MakeHeapProperty ()
 Ensures that the heap property is satisfied.
 
+ + + + + + + + + + +

+Private Attributes

std::vector< std::pair< TElement, TKey > > elementKeyPairs_
 Pairs of elements and their keys; ordered such that the heap property is satisfied.
 
TMap map_
 The mapping from elements to indices in elementKeyPairs_.
 
TComparator comparator_
 The comparator used to compare the keys.
 
+ + + + +

+Friends

void swap (MappingBinaryHeap &first, MappingBinaryHeap &second)
 Swaps the contents of two heaps.
 
+

Detailed Description

+
template<typename ElementType, typename KeyType, typename MapType = std::unordered_map<ElementType, Types::index>>
+class egoa::MappingBinaryHeap< ElementType, KeyType, MapType >

Class for binary heap data structure, in which elements are sorted by keys.

+

The elements and the keys are represented as separate objects. The heap supports changing the key of an element. The heap does not support having multiple keys for the same element.

+

Both the elements and the keys are stored in the heap.

+

A possible application is to store labels at the vertices of a graph. In this use case the elements are the vertices (or vertex identifiers) and the keys are the labels.

+

The map must support the following operations, where element is of type ElementType and i is of type Types::index.

+ + + + + + + + + + + +
Operation Effect
map[element] = i;
+
map maps element to i.
Types::index i = map.at(element);
+
i is set to the index of the element stored in the map.
map.erase(element);
+
The mapping for element is removed from map.
map.clear();
+
map does not contain any elements.
+

The methods have the following worst case time complexities:

+ + + + + + + + + + + + + + +
Function Time Complexity
Top $\Theta(1)$
Insert, Emplace, operator+= $\Theta(\log n)$
DeleteTop, Pop $\Theta(\log n)$
Delete $\Theta(\log n)$
Clear $\Theta(1)$ + 1 call to map.clear()
ChangeKey $\Theta(\log n)$ + 1 call to map.at()
+

The comparator must implement a strict order on the keys. The smallest element according to the comparator is the top element of the heap. For example, if the comparator is std::less<TKey>(), the smallest element is at the top, and if the comparator is std::greater<TKey>, the largest element is at the top.

+
Template Parameters
+ + + + +
ElementTypeThe type of the elements
KeyTypeThe type of the keys
MapTypeA mapping from elements to indices. The default is std::unordered_map<KeyType, Types::index>. To use the default KeyType must satisfy all requirements to be used as the key of a std::unordered_map.
+
+
+ +

Definition at line 72 of file MappingBinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ TComparator

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + +
using egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TComparator = std::function<bool(TKey const &, TKey const &)>
+
+ +

The type of the comparator.

+ +

Definition at line 93 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ TElement

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + +
using egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TElement = ElementType
+
+ +

The type of the elements in the heap.

+ +

Definition at line 77 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ TIterator

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + +
using egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TIterator = typename std::vector<std::pair<TElement, TKey> >::const_iterator
+
+ +

The type of the iterators.

+ +

Definition at line 89 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ TKey

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + +
using egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TKey = KeyType
+
+ +

The type of the keys.

+ +

Definition at line 81 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ TMap

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + +
using egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TMap = MapType
+
+ +

The type of the mapping from elements to indices.

+ +

Definition at line 85 of file MappingBinaryHeap.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ MappingBinaryHeap() [1/3]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MappingBinaryHeap (TComparator comparator = std::less<TKey>(),
TMap map = TMap() 
)
+ 		+inline
+
+ +

Constructs an empty heap, in which the elements are sorted by their keys in increasing order.

+
Parameters
+ + + +
[in]comparatorThe comparator used to compare the elements.
[in]mapThe mapping from elements to positions in the heap.
+
+
+ +

Definition at line 104 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ MappingBinaryHeap() [2/3]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MappingBinaryHeap (std::vector< std::pair< TElement, TKey > > elementsKeyPairs,
TComparator comparator = std::less<TKey>(),
TMap map = TMap() 
)
+ 		+inline
+
+ +

Constructs an heap containing the given elements.

+
Parameters
+ + + + +
[in]elementsKeyPairsThe element-key-pairs.
[in]comparatorThe comparator used to compare the elements.
[in]mapThe map.
+
+
+ +

Definition at line 118 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MakeHeapProperty().

+ +
+
+ +

◆ MappingBinaryHeap() [3/3]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+
+template<typename It >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MappingBinaryHeap (It first,
It last,
TComparator comparator = std::less<TKey>(),
TMap map = TMap() 
)
+ 		+inline
+
+ +

Constructs the heap filled with the element-key-pairs.

+
Parameters
+ + + + + +
[in]firstThe first An iterator pointing to the first element-key-pair.
[in]lastThe last An iterator pointing behind the last element-key-pair.
[in]comparatorThe comparator used to compare the elements.
[in]mapThe map.
+
+
+
Template Parameters
+ + +
ItAn iterator pointing to std::pair<TElement, TKey>.
+
+
+ +

Definition at line 139 of file MappingBinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
TIterator egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::begin () const
+ 		+inline
+
+ +

Definition at line 452 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ ChangeKey()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ChangeKey (const TElement & element,
TKey newKey 
)
+ 		+inline
+
+ +

Changes the key of the element.

+
Precondition
The heap contains the element.
+
Parameters
+ + + +
[in]elementThe element.
[in]newKeyThe new key.
+
+
+ +

Definition at line 380 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp().

+ +
+
+ +

◆ Clear()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Clear ()
+ 		+inline
+
+ +

Removes all elements from the heap.

+ +

Definition at line 363 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_.

+ +
+
+ +

◆ Comparator() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
std::function< bool(TKey const &, TKey const &)> const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator () const
+ 		+inline
+
+ +

The comparator.

+
Returns
The comparator.
+ +

Definition at line 425 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::comparator_.

+ +
+
+ +

◆ Comparator() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator (std::function< bool(TKey const &, TKey const &)> comparator)
+ 		+inline
+
+ +

Changes the comparator.

+

The heap is updated to reflect the change of the comparator.

+
...
+
heap_.Comparator( []( int a, int b ) { return a < b; } );
+
...
+
Parameters
+ + +
[in]comparatorThe comparator.
+
+
+ +

Definition at line 442 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::comparator_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MakeHeapProperty().

+ +
+
+ +

◆ ComplyHeapProperty() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty () const
+ 		+inlineprivate
+
+ +

Whether the heap property is fulfilled.

+
Returns
true if the heap property is fulfilled, false otherwise.
+ +

Definition at line 617 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Size().

+ +
+
+ +

◆ ComplyHeapProperty() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty (Types::index index) const
+ 		+inlineprivate
+
+ +

Whether the element at position index is smaller than its childred.

+
Parameters
+ + +
[in]indexThe index.
+
+
+
Returns
true if the element is smaller than all of its children, false otherwise.
+ +

Definition at line 635 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator().

+ +
+
+ +

◆ Delete()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
std::pair< TElement, TKey > egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Delete (TElement const & element)
+ 		+inline
+
+ +

Deletes an element from the heap.

+
Parameters
+ + +
elementThe element to delete.
+
+
+
Returns
A pair containing the deleted element and its key.
+ +

Definition at line 342 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap().

+ +
+
+ +

◆ DeleteTop()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
std::pair< TElement, TKey > egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::DeleteTop ()
+ 		+inline
+
+ +

Deletes the top element and returns it and its key.

+
Precondition
The heap is not empty.
+
Returns
A pair containing the former top element and its key.
+ +

Definition at line 303 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap().

+ +
+
+ +

◆ ElementAt() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
TElement & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ElementAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 491 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ ElementAt() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
TElement const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ElementAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 492 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ Emplace()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+
+template<typename... Args>
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Emplace (Args &&... args)
+ 		+inline
+
+ +

Constructs an element-key-pair inplace.

+

Depending on the implementation of the map, inserting the mapping from the element to the index may create a copy of the element.

+

To construct both the element and the key in-place, one can use the constructor of std::pair that allows piecewise construction.

#include <tuple>
+
...
+
Emplace(std::piecewise_construct,
+
std::forward_as_tuple(/* constructor arguments of element */),
+
std::forward_as_tuple(/* constructor arguments of key */));
+
Parameters
+ + +
argsThe arguments of the constructor of std::pair.
+
+
+
Template Parameters
+ + +
ArgsThe types of the constructor arguments.
+
+
+ +

Definition at line 284 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp().

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty () const
+ 		+inline
+
+ +

Whether the heap is empty.

+
Returns
true if the heap is empty, false otherwise.
+ +

Definition at line 401 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
TIterator egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::end () const
+ 		+inline
+
+ +

Definition at line 453 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ for_all_elements()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+
+template<ExecutionPolicy Policy, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Iterates over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function object that is called for all elements in the heap. It must accept one argument of type std::pair<TElement, TKey>, e.g.,
[]( std::pair<TElement, TKey> const & element ) { ... }
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 472 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_.

+ +
+
+ +

◆ HasChildren()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasChildren (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 498 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ HasKeyOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf (TElement const & element) const
+ 		+inline
+
+ +

Determines if the element exist in the heap.

+
Parameters
+ + +
elementThe element.
+
+
+
Returns
True if the element exists, False otherwise.
+ +

Definition at line 209 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_.

+ +
+
+ +

◆ HasLeftChild()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasLeftChild (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 499 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ HasParent()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasParent (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 502 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ HasRightChild()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
bool egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasRightChild (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 500 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ IndexOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::IndexOf (TElement const & element) const
+ 		+inlineprivate
+
+ +

Definition at line 504 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ Insert() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Insert (std::pair< TElement, TKey > pair)
+ 		+inline
+
+ +

Inserts the element with the given key.

+
Precondition
The heap does not contain the element.
+
Parameters
+ + +
[in]pairThe pair containing the element (first position) and the key (second position).
+
+
+ +

Definition at line 238 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp().

+ +
+
+ +

◆ Insert() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Insert (TElement element,
TKey key 
)
+ 		+inline
+
+ +

Inserts the element with the given key.

+
Precondition
The heap does not contain the element.
+
Parameters
+ + + +
elementThe element.
keyThe key.
+
+
+ +

Definition at line 225 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Insert().

+ +
+
+ +

◆ KeyAt() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
TKey & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::KeyAt (Types::index index)
+ 		+inlineprivate
+
+ +

Definition at line 493 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ KeyAt() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
TKey const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::KeyAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 494 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ KeyOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
TKey const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::KeyOf (TElement const & element) const
+ 		+inline
+
+ +

The key of the element.

+
Precondition
The heap must contain the element.
+
Parameters
+ + +
elementThe element.
+
+
+
Returns
The key of the element.
+ +

Definition at line 197 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::HasKeyOf().

+ +
+
+ +

◆ LeftChildIdOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::LeftChildIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 496 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ MakeHeapProperty()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MakeHeapProperty ()
+ 		+inlineprivate
+
+ +

Ensures that the heap property is satisfied.

+ +

Definition at line 645 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Size().

+ +
+
+ +

◆ MaximumIndex()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex () const
+ 		+inlineprivate
+
+ +

The largest index of elements in the heap.

+
Returns
The largest index of elements in the heap.
+ +

Definition at line 513 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
MappingBinaryHeap & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::operator+= (std::pair< TElement, TKey > pair)
+ 		+inline
+
+ +

Inserts the element with the given key.

+

Equivalent to Insert(pair).

+
Precondition
The heap does not contain the element.
+
Parameters
+ + +
[in]pairThe pair containing the element (first position) and the key (second position).
+
+
+
Returns
The heap.
+ +

Definition at line 258 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Insert().

+ +
+
+ +

◆ ParentIdOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ParentIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 501 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ Pop()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Pop ()
+ 		+inline
+
+ +

Deletes the top element.

+
Precondition
The heap is not empty.
+ +

Definition at line 323 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ComplyHeapProperty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap().

+ +
+
+ +

◆ RightChildIdOf()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::RightChildIdOf (Types::index index) const
+ 		+inlineprivate
+
+ +

Definition at line 497 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ SelectSwappableChildAt()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SelectSwappableChildAt (Types::index index) const
+ 		+inlineprivate
+
+ +

Selects the smallest child, where smallest is measured according to the comparator.

+
Parameters
+ + +
[in]indexThe current index.
+
+
+
Returns
The index of the child that has the smallest key.
+ +

Definition at line 596 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator().

+ +
+
+ +

◆ SiftDown() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown ()
+ 		+inlineprivate
+
+ +

Sifts the first element in the heap down.

+
Precondition
The heap is not empty.
+ +

Definition at line 548 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown().

+ +
+
+ +

◆ SiftDown() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftDown (Types::index index)
+ 		+inlineprivate
+
+ +

Sifts the element at index down.

+
Precondition
The index is valid.
+
Parameters
+ + +
[in]indexThe index.
+
+
+ +

Definition at line 560 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SelectSwappableChildAt(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Size(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap().

+ +
+
+ +

◆ SiftUp() [1/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp ()
+ 		+inlineprivate
+
+ +

Sifts the last element in the heap up.

+
Precondition
The heap is not empty.
+ +

Definition at line 522 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::MaximumIndex(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp().

+ +
+
+ +

◆ SiftUp() [2/2]

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::SiftUp (Types::index index)
+ 		+inlineprivate
+
+ +

Sifts the element at index up.

+
Precondition
The index is valid.
+
Parameters
+ + +
[in]indexThe index.
+
+
+ +

Definition at line 534 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Comparator(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Size(), and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap().

+ +
+
+ +

◆ Size()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
Types::count egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Size () const
+ 		+inline
+
+ +

The number of elements in the heap.

+
Returns
The number of elements in the heap.
+ +

Definition at line 410 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_.

+ +
+
+ +

◆ Swap()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Swap (Types::index first,
Types::index second 
)
+ 		+inlineprivate
+
+ +

Swaps the elements and keys at the indices first and second and updates the mapping.

+
Parameters
+ + + +
[in]firstThe first index.
[in]secondThe second index.
+
+
+ +

Definition at line 579 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::swap.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
std::pair< TElement, TKey > const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Top () const
+ 		+inline
+
+ +

The element and the key at the top of the heap.

+
Precondition
The heap is not empty.
+
Returns
A pair containing the element and the key at the top of the heap.
+ +

Definition at line 159 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty().

+ +
+
+ +

◆ TopElement()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
TElement const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TopElement () const
+ 		+inline
+
+ +

The element at the top of the heap.

+
Precondition
The heap is not empty.
+
Returns
The element at the top of the heap.
+ +

Definition at line 171 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty().

+ +
+
+ +

◆ TopKey()

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + +
TKey const & egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::TopKey () const
+ 		+inline
+
+ +

The key of the element at the top of the heap.

+
Precondition
The heap is not empty.
+
Returns
The key of the element at the top of the heap.
+ +

Definition at line 183 of file MappingBinaryHeap.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_, and egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty().

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ swap

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (MappingBinaryHeap< ElementType, KeyType, MapType > & first,
MappingBinaryHeap< ElementType, KeyType, MapType > & second 
)
+ 		+friend
+
+ +

Swaps the contents of two heaps.

+
Parameters
+ + + +
firstThe first heap.
secondThe second heap.
+
+
+ +

Definition at line 483 of file MappingBinaryHeap.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ comparator_

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + +
TComparator egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::comparator_
+ 		+private
+
+ +

The comparator used to compare the keys.

+ +

Definition at line 668 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ elementKeyPairs_

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + +
std::vector<std::pair<TElement, TKey> > egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::elementKeyPairs_
+ 		+private
+
+ +

Pairs of elements and their keys; ordered such that the heap property is satisfied.

+ +

Definition at line 660 of file MappingBinaryHeap.hpp.

+ +
+
+ +

◆ map_

+ +
+
+
+template<typename ElementType , typename KeyType , typename MapType = std::unordered_map<ElementType, Types::index>>
+ + + + + +
+ + + + +
TMap egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::map_
+ 		+private
+
+ +

The mapping from elements to indices in elementKeyPairs_.

+ +

Definition at line 664 of file MappingBinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_omitting_iterator-members.html b/classegoa_1_1_omitting_iterator-members.html new file mode 100644 index 00000000..bb301215 --- /dev/null +++ b/classegoa_1_1_omitting_iterator-members.html @@ -0,0 +1,107 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::OmittingIterator< ElementVectorIt, BoolVectorIt > Member List
+
+
+ +

This is the complete list of members for egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >
elementEnd_egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >private
elementIterator_egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >private
existsIterator_egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >private
GoToNextExistingElement()egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inlineprivate
GoToPreviousExistingElement()egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inlineprivate
iterator_category typedef (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >
OmittingIterator(ElementVectorIt elementIterator, ElementVectorIt elementEnd, BoolVectorIt existsIterator)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator!= (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >friend
operator*() (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator++() (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator++(int) (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator--() (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator--(int) (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator->() (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >inline
operator== (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >friend
pointer typedef (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >
reference typedef (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >
value_type typedef (defined in egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >)egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_omitting_iterator.html b/classegoa_1_1_omitting_iterator.html new file mode 100644 index 00000000..c2d6e6e5 --- /dev/null +++ b/classegoa_1_1_omitting_iterator.html @@ -0,0 +1,734 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::OmittingIterator< ElementVectorIt, BoolVectorIt > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::OmittingIterator< ElementVectorIt, BoolVectorIt > Class Template Reference
+
+
+ +

An iterator that omits elements of a range if another range of bool indicates that the element is invalid. + More...

+ +

#include <OmittingIterator.hpp>

+ + + + + + + + + + + + +

+Public Types

using iterator_category = std::input_iterator_tag
 
using value_type = typename ElementVectorIt::value_type
 
using difference_type = Types::difference
 
using pointer = ElementVectorIt
 
using reference = typename ElementVectorIt::reference
 
+ + + + + + + + + + + + + + + + +

+Public Member Functions

 OmittingIterator (ElementVectorIt elementIterator, ElementVectorIt elementEnd, BoolVectorIt existsIterator)
 Constructs an omitting iterator.
 
OmittingIterator & operator++ ()
 
OmittingIterator operator++ (int)
 
OmittingIterator & operator-- ()
 
OmittingIterator operator-- (int)
 
reference operator* ()
 
pointer operator-> ()
 
+ + + + + + + +

+Private Member Functions

void GoToNextExistingElement ()
 Goes to the next existing element.
 
void GoToPreviousExistingElement ()
 Goes to the previous existing element.
 
+ + + + + + + + + + +

+Private Attributes

ElementVectorIt elementIterator_
 The current element.
 
ElementVectorIt elementEnd_
 The iterator pointing behind the range of elements.
 
BoolVectorIt existsIterator_
 The iterator pointing to the bool corresponding to the element pointed to by elementIterator_.
 
+ + + + + +

+Friends

bool operator== (const OmittingIterator &left, const OmittingIterator &right)
 
bool operator!= (const OmittingIterator &left, const OmittingIterator &right)
 
+

Detailed Description

+
template<typename ElementVectorIt, typename BoolVectorIt>
+class egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >

An iterator that omits elements of a range if another range of bool indicates that the element is invalid.

+
Template Parameters
+ + + +
ElementVectorItThe type of the underlying element iterator.
BoolVectorItThe type of the underlying bool iterator.
+
+
+ +

Definition at line 24 of file OmittingIterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + +
using egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::difference_type = Types::difference
+
+ +

Definition at line 28 of file OmittingIterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + +
using egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::iterator_category = std::input_iterator_tag
+
+ +

Definition at line 26 of file OmittingIterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + +
using egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::pointer = ElementVectorIt
+
+ +

Definition at line 29 of file OmittingIterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + +
using egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::reference = typename ElementVectorIt::reference
+
+ +

Definition at line 30 of file OmittingIterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + +
using egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::value_type = typename ElementVectorIt::value_type
+
+ +

Definition at line 27 of file OmittingIterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ OmittingIterator()

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::OmittingIterator (ElementVectorIt elementIterator,
ElementVectorIt elementEnd,
BoolVectorIt existsIterator 
)
+ 		+inline
+
+ +

Constructs an omitting iterator.

+
Parameters
+ + + + +
[in]elementIteratorThe element the iterator points to. It does not have to be valid.
[in]elementEndThe end iterator for the range of elements.
[in]existsIteratorThe iterator referencing the bool indicating whether the element referenced by elementIterator is valid.
+
+
+ +

Definition at line 42 of file OmittingIterator.hpp.

+ +

References egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementEnd_, egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementIterator_, egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::existsIterator_, and egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::GoToNextExistingElement().

+ +
+
+

Member Function Documentation

+ +

◆ GoToNextExistingElement()

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
void egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::GoToNextExistingElement ()
+ 		+inlineprivate
+
+ +

Goes to the next existing element.

+

If no such element exists, it points to elementEnd_.

+ +

Definition at line 88 of file OmittingIterator.hpp.

+ +

References egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementEnd_, egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementIterator_, and egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::existsIterator_.

+ +
+
+ +

◆ GoToPreviousExistingElement()

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
void egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::GoToPreviousExistingElement ()
+ 		+inlineprivate
+
+ +

Goes to the previous existing element.

+

If no such element exists, the behavior is undefined.

+ +

Definition at line 99 of file OmittingIterator.hpp.

+ +

References egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementIterator_, and egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::existsIterator_.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
reference egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator* ()
+ 		+inline
+
+ +

Definition at line 71 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
OmittingIterator & egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator++ ()
+ 		+inline
+
+ +

Definition at line 53 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + + +
OmittingIterator egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator++ (int )
+ 		+inline
+
+ +

Definition at line 57 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator--() [1/2]

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
OmittingIterator & egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator-- ()
+ 		+inline
+
+ +

Definition at line 62 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator--() [2/2]

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + + +
OmittingIterator egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator-- (int )
+ 		+inline
+
+ +

Definition at line 66 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + +
pointer egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::operator-> ()
+ 		+inline
+
+ +

Definition at line 74 of file OmittingIterator.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator!=

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const OmittingIterator< ElementVectorIt, BoolVectorIt > & left,
const OmittingIterator< ElementVectorIt, BoolVectorIt > & right 
)
+ 		+friend
+
+ +

Definition at line 80 of file OmittingIterator.hpp.

+ +
+
+ +

◆ operator==

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const OmittingIterator< ElementVectorIt, BoolVectorIt > & left,
const OmittingIterator< ElementVectorIt, BoolVectorIt > & right 
)
+ 		+friend
+
+ +

Definition at line 77 of file OmittingIterator.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ elementEnd_

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + +
ElementVectorIt egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementEnd_
+ 		+private
+
+ +

The iterator pointing behind the range of elements.

+ +

Definition at line 115 of file OmittingIterator.hpp.

+ +
+
+ +

◆ elementIterator_

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + +
ElementVectorIt egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::elementIterator_
+ 		+private
+
+ +

The current element.

+

After the constructor has finished either elementIterator_ points to a valid element or to elementEnd_.

+ +

Definition at line 111 of file OmittingIterator.hpp.

+ +
+
+ +

◆ existsIterator_

+ +
+
+
+template<typename ElementVectorIt , typename BoolVectorIt >
+ + + + + +
+ + + + +
BoolVectorIt egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >::existsIterator_
+ 		+private
+
+ +

The iterator pointing to the bool corresponding to the element pointed to by elementIterator_.

+ +

Definition at line 120 of file OmittingIterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_power_grid-members.html b/classegoa_1_1_power_grid-members.html new file mode 100644 index 00000000..facb1cc5 --- /dev/null +++ b/classegoa_1_1_power_grid-members.html @@ -0,0 +1,330 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty > Member List
+
+
+ +

This is the complete list of members for egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties const &generatorProperty)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &&generatorProperty)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorAt(int vertexId, TGeneratorProperties generatorProperty)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorAt(char vertexId, TGeneratorProperties generatorProperty)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorAt(TVertex const &vertex, TGeneratorProperties const &generatorProperty)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorAt(TVertex const &vertex, TGeneratorProperties &&generatorProperty)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddGeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::generatorSnapshot maximumRealPowerGenerationPu)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadAt(Types::vertexId vertexId, TLoadProperties load)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadAt(int vertexId, TLoadProperties load)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadAt(char vertexId, TLoadProperties load)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadAt(TVertex const &vertex, TLoadProperties const &load)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadAt(TVertex const &vertex, TLoadProperties &&load)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddLoadSnapshotAt(Types::loadId loadId, Types::loadSnapshot snapshot)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddSnapshotTimestamp(Types::timestampSnapshot timestamp)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
AddSnapshotWeighting(Types::weightSnapshot weight)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
BaseMva() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
BaseMva()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
baseMva_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
FindGenerator(TGeneratorProperties const &generatorProperty, std::vector< TGeneratorProperties > const &generators) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_tuple(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generator_tuple(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_at(TVertex const &vertex, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_at(Types::vertexId vertexId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_tuple(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_generators_tuple(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_load_identifiers_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_load_identifiers_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_load_tuples(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_load_tuples(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads_at(TVertex const &vertex, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads_at(Types::vertexId const vertexId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_loads_tuple(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_of(Types::generatorId generatorId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_of(Types::vertexId generatorId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_of(Types::loadId loadId, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_of(Types::vertexId loadId, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_of(TLoadProperties load, FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_real_power_load_snapshots_of(TLoadProperties const &load, FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_vertex_identifiers_with_generator(FUNCTION function)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_vertex_identifiers_with_generator(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
for_all_vertex_identifiers_with_load(FUNCTION function) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorAt(Types::generatorId generatorId)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorAt(Types::generatorId generatorId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorBoundType() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorBoundType()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
generatorBoundType_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
generatorExists_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
GeneratorId(TGeneratorProperties const &generatorProperty) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(Types::vertexId vertexId, std::vector< int > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(Types::vertexId vertexId, std::vector< char > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(int vertexId, std::vector< Types::generatorId > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(int vertexId, std::vector< int > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(int vertexId, std::vector< char > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(char vertexId, std::vector< Types::generatorId > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(char vertexId, std::vector< int > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorIds(char vertexId, std::vector< char > &generatorIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
generatorRealPowerSnapshots_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
GeneratorRealPowerSnapshotsAt(Types::timestampSnapshot timestamp, std::vector< Types::generatorSnapshot > &snapshotsAtTimestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
generators_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
GeneratorsAt(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorsAt(Types::vertexId vertexId, std::vector< TGeneratorProperties > &generators) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorsAt(int vertexId, std::vector< TGeneratorProperties > &generators) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorsAt(char vertexId, std::vector< TGeneratorProperties > &generators) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorsAt(TVertex const &vertex, std::vector< Types::generatorId > &generatorIds) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
GeneratorsAt(TVertex const &vertex, std::vector< TGeneratorProperties > &generators) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
generatorsAtVertex_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
Graph() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
Graph()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
graph_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
HasGenerator(Types::generatorId generatorId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGenerator(int generatorId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGenerator(char generatorId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGenerator(TGeneratorProperties const &generatorProperty) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGeneratorAt(Types::vertexId vertexId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGeneratorAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGeneratorAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasGeneratorAt(TVertex const &vertex) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoad(Types::loadId loadId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoad(int loadId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoad(char loadId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoad(TLoadProperties const &load) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoadAt(Types::vertexId vertexId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoadAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoadAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
HasLoadAt(TVertex const &vertex) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
IsBounded() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
IsExact() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
IsPureUnbounded() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
IsUnbounded() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadAt(Types::loadId loadId)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadAt(Types::loadId loadId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadBoundType() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadBoundType()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
loadBoundType_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
loadExists_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
LoadId(TLoadProperties const &load) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(Types::vertexId vertexId, std::vector< Types::loadId > &loadIds) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(Types::vertexId vertexId, std::vector< int > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(Types::vertexId vertexId, std::vector< char > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(int vertexId, std::vector< Types::loadId > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(int vertexId, std::vector< int > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(int vertexId, std::vector< char > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(char vertexId, std::vector< Types::loadId > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(char vertexId, std::vector< int > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(char vertexId, std::vector< char > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(TVertex const &vertex, std::vector< Types::loadId > &loadIds) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(TVertex const &vertex, std::vector< int > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadIds(TVertex const &vertex, std::vector< char > &loadIds) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
loads_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
LoadsAt(Types::vertexId vertexId, std::vector< TLoadProperties > &loads) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadsAt(TVertex const &vertex, std::vector< TLoadProperties > &loads) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
loadsAtVertex_ (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
loadSnapshots_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
LoadSnapshotsAt(Types::vertexId vertexId, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadSnapshotsAt(TVertex const &vertex, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
LoadSnapshotsAt(Types::timestampSnapshot timestamp, std::vector< Types::loadSnapshot > &loadSnapshotsAtTimestamp)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
MakeBounded()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
MakeExact()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
MakePureUnbounded()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
MakeUnbounded()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
NetworkBoundType() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
NetworkType() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
NumberOfGenerators() const (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
numberOfGenerators_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
NumberOfLoads() const (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
numberOfLoads_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
NumberOfTimestamps() const (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
operator<<egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >friend
OutputGeneratorSnaps()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
OutputLoadSnaps()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
PositionOf(Types::timestampSnapshot timestamp) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
PowerGrid()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RealPowerLoadAt(Types::vertexId vertexId, Types::index snapshotId=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RealPowerLoadAt(TVertex const &vertex, Types::index snapshotId=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(Types::vertexId vertexId, Types::generatorId generatorId)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(Types::vertexId vertexId, int generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(Types::vertexId vertexId, char generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(int vertexId, Types::generatorId generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(int vertexId, int generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(int vertexId, char generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(char vertexId, Types::generatorId generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(char vertexId, int generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(char vertexId, char generatorId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &generatorProperty)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(int vertexId, TGeneratorProperties &generatorProperty)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveGeneratorAt(char vertexId, TGeneratorProperties &generatorProperty)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(Types::vertexId vertexId, Types::loadId loadId)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(Types::vertexId vertexId, int loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(Types::vertexId vertexId, char loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(int vertexId, Types::loadId loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(int vertexId, int loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(int vertexId, char loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(char vertexId, Types::loadId loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(char vertexId, int loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(char vertexId, char loadId)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(Types::vertexId vertexId, TLoadProperties &load)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(int vertexId, TLoadProperties &load)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
RemoveLoadAt(char vertexId, TLoadProperties &load)=delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
snapshotWeights_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
TBound typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TEdge typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TEdgeProperties typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TGeneratorProperties typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TGraph typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
ThetaBound() constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
ThetaBound()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
thetaBound_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
TimestampAt(Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
timestamps_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
TLoadProperties typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TNetwork typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TotalReactivePowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerGenerationAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerGenerationAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerGenerationBoundAt(Types::vertexId vertexId, Types::index timestampPosition=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerGenerationBoundAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerGenerationBoundAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalReactivePowerLoadBoundAt(Types::vertexId vertexId) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(Types::vertexId vertexId, Types::index timestampPosition=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(int vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(int vertexId, int timestampPosition) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(int vertexId, char timestampPosition) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(char vertexId) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(char vertexId, int timestampPosition) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerGenerationBoundAt(char vertexId, char timestampPosition) const =delete (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerLoadAt(Types::vertexId vertexId, Types::index timestampPosition) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TotalRealPowerLoadBoundAt(Types::vertexId vertexId, Types::index timestamp=0) constegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
TVertex typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
TVertexProperties typedef (defined in egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >)egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
UpdateGeneratorSnapshotSize()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
UpdateLoadSnapshotSize()egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >inline
verticesWithGeneratorCount_egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_power_grid.html b/classegoa_1_1_power_grid.html new file mode 100644 index 00000000..b09f209e --- /dev/null +++ b/classegoa_1_1_power_grid.html @@ -0,0 +1,9343 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + +

+Public Types

using TVertex = typename GraphType::TVertex
 
using TVertexProperties = typename GraphType::TVertexProperties
 
using TGeneratorProperties = GeneratorProperty
 
using TLoadProperties = LoadProperty
 
using TEdge = typename GraphType::TEdge
 
using TEdgeProperties = typename GraphType::TEdgeProperties
 
using TGraph = GraphType
 
using TNetwork = PowerGrid
 
using TBound = Bound<>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Types::count NumberOfGenerators () const
 
Types::count NumberOfLoads () const
 
Types::count NumberOfTimestamps () const
 
Constructors and destructor
 PowerGrid ()
 Constructs the object.
 
Getter and Setter
TGraph const & Graph () const
 Getter for the underlying graph.
 
TGraph & Graph ()
 Setter for the underlying graph.
 
Types::real BaseMva () const
 Getter for the base MVA.
 
Types::real & BaseMva ()
 Setter for the base MVA.
 
TBound ThetaBound () const
 Getter for the voltage angle bound.
 
TBound & ThetaBound ()
 Setter for the voltage angle bound.
 
Network Bound Accessors
Vertices::BoundType const & GeneratorBoundType () const
 Getter for the generator bound type.
 
Vertices::BoundType & GeneratorBoundType ()
 Setter for the generator bound type.
 
Vertices::BoundType const & LoadBoundType () const
 Getter for the load bound type.
 
Vertices::BoundType & LoadBoundType ()
 Setter for the load bound type.
 
void MakeBounded ()
 Makes the power grid bounded.
 
void MakeUnbounded ()
 Makes the power grid unbounded.
 
void MakePureUnbounded ()
 Makes the power grid pure unbounded.
 
void MakeExact ()
 Makes the power grid exact bounded.
 
bool IsBounded () const
 Determines if bounded.
 
bool IsUnbounded () const
 Determines if unbounded.
 
bool IsPureUnbounded () const
 Determines if pure unbounded.
 
bool IsExact () const
 Determines if exact.
 
Vertices::BoundType NetworkBoundType () const
 Get the current network bound type.
 
Types::name NetworkType () const
 Get the current network bound type.
 
Add and Remove Generators
Types::generatorId AddGeneratorAt (Types::vertexId vertexId, TGeneratorProperties const &generatorProperty)
 Adds a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.
 
Types::generatorId AddGeneratorAt (Types::vertexId vertexId, TGeneratorProperties &&generatorProperty)
 Adds a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.
 
+Types::generatorId AddGeneratorAt (int vertexId, TGeneratorProperties generatorProperty)=delete
 
+Types::generatorId AddGeneratorAt (char vertexId, TGeneratorProperties generatorProperty)=delete
 
Types::generatorId AddGeneratorAt (TVertex const &vertex, TGeneratorProperties const &generatorProperty)
 Adds a generator $\vertex\in\generators$ at a vertex vertex $\vertex\in\vertices$.
 
Types::generatorId AddGeneratorAt (TVertex const &vertex, TGeneratorProperties &&generatorProperty)
 Adds a generator $g\in\generators$ at a vertex vertex $\vertex\in\vertices$.
 
void RemoveGeneratorAt (Types::vertexId vertexId, Types::generatorId generatorId)
 Removes a generator with generatorId at a vertex with identifier vertexId.
 
+void RemoveGeneratorAt (Types::vertexId vertexId, int generatorId)=delete
 
+void RemoveGeneratorAt (Types::vertexId vertexId, char generatorId)=delete
 
+void RemoveGeneratorAt (int vertexId, Types::generatorId generatorId)=delete
 
+void RemoveGeneratorAt (int vertexId, int generatorId)=delete
 
+void RemoveGeneratorAt (int vertexId, char generatorId)=delete
 
+void RemoveGeneratorAt (char vertexId, Types::generatorId generatorId)=delete
 
+void RemoveGeneratorAt (char vertexId, int generatorId)=delete
 
+void RemoveGeneratorAt (char vertexId, char generatorId)=delete
 
void RemoveGeneratorAt (Types::vertexId vertexId, TGeneratorProperties &generatorProperty)
 Removes a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with identifier vertexId.
 
+void RemoveGeneratorAt (int vertexId, TGeneratorProperties &generatorProperty)=delete
 
+void RemoveGeneratorAt (char vertexId, TGeneratorProperties &generatorProperty)=delete
 
Generator Accessors
bool HasGenerator (Types::generatorId generatorId) const
 Determines if there is a generator $\vertex\in\generators$ with the given generatorId.
 
+bool HasGenerator (int generatorId) const =delete
 
+bool HasGenerator (char generatorId) const =delete
 
bool HasGenerator (TGeneratorProperties const &generatorProperty) const
 Determines if there is a generator $\vertex\in\generators$.
 
bool HasGeneratorAt (Types::vertexId vertexId) const
 Determines if it has a generator at vertex with identifier vertexId.
 
+bool HasGeneratorAt (int vertexId) const =delete
 
+bool HasGeneratorAt (char vertexId) const =delete
 
bool HasGeneratorAt (TVertex const &vertex) const
 Determines if it has a generator at vertex with identifier vertexId.
 
Types::generatorId GeneratorId (TGeneratorProperties const &generatorProperty) const
 The generator identifier of a generator $g\in\generators$.
 
void GeneratorIds (Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const
 Identifiers of all generators at a vertex with vertexId.
 
+void GeneratorIds (Types::vertexId vertexId, std::vector< int > &generatorIds) const =delete
 
+void GeneratorIds (Types::vertexId vertexId, std::vector< char > &generatorIds) const =delete
 
+void GeneratorIds (int vertexId, std::vector< Types::generatorId > &generatorIds) const =delete
 
+void GeneratorIds (int vertexId, std::vector< int > &generatorIds) const =delete
 
+void GeneratorIds (int vertexId, std::vector< char > &generatorIds) const =delete
 
+void GeneratorIds (char vertexId, std::vector< Types::generatorId > &generatorIds) const =delete
 
+void GeneratorIds (char vertexId, std::vector< int > &generatorIds) const =delete
 
+void GeneratorIds (char vertexId, std::vector< char > &generatorIds) const =delete
 
TGeneratorProperties & GeneratorAt (Types::generatorId generatorId)
 Generator $\vertex\in\generators$ at generator's identifier generatorId.
 
TGeneratorProperties const & GeneratorAt (Types::generatorId generatorId) const
 Generator $\vertex\in\generators$ at generator's identifier generatorId.
 
void GeneratorsAt (Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const
 All generator identifiers at a vertex with vertexId.
 
void GeneratorsAt (Types::vertexId vertexId, std::vector< TGeneratorProperties > &generators) const
 All generator objects at a vertex with vertexId.
 
+void GeneratorsAt (int vertexId, std::vector< TGeneratorProperties > &generators) const =delete
 
+void GeneratorsAt (char vertexId, std::vector< TGeneratorProperties > &generators) const =delete
 
void GeneratorsAt (TVertex const &vertex, std::vector< Types::generatorId > &generatorIds) const
 All generator identifiers at a bus vertex.
 
void GeneratorsAt (TVertex const &vertex, std::vector< TGeneratorProperties > &generators) const
 All generator objects at a bus vertex.
 
Types::generatorId FindGenerator (TGeneratorProperties const &generatorProperty, std::vector< TGeneratorProperties > const &generators) const
 Find a generator in a vector.
 
Accessors for the Total Power Generation at a Vertex <br>
template<Vertices::GenerationStrategyDifferentiationType Strategy>
TBound TotalRealPowerGenerationBoundAt (Types::vertexId vertexId, Types::index timestampPosition=0) const
 The total real power generation bound of all generators at a vertex.
 
+TBound TotalRealPowerGenerationBoundAt (int vertexId) const =delete
 
+TBound TotalRealPowerGenerationBoundAt (int vertexId, int timestampPosition) const =delete
 
+TBound TotalRealPowerGenerationBoundAt (int vertexId, char timestampPosition) const =delete
 
+TBound TotalRealPowerGenerationBoundAt (char vertexId) const =delete
 
+TBound TotalRealPowerGenerationBoundAt (char vertexId, int timestampPosition) const =delete
 
+TBound TotalRealPowerGenerationBoundAt (char vertexId, char timestampPosition) const =delete
 
template<Vertices::GenerationStrategyDifferentiationType Strategy>
Types::real TotalRealPowerGenerationAt (Types::vertexId vertexId, Types::index timestampPosition=0) const
 The total real power generation $\realpowergeneration$ at a vertex $\vertex\in\vertices$ with vertexId.
 
+Types::real TotalRealPowerGenerationAt (int vertexId) const =delete
 
+Types::real TotalRealPowerGenerationAt (char vertexId) const =delete
 
template<Vertices::GenerationStrategyDifferentiationType Strategy>
TBound TotalReactivePowerGenerationBoundAt (Types::vertexId vertexId, Types::index timestampPosition=0) const
 The total reactive power generation bound.
 
+TBound TotalReactivePowerGenerationBoundAt (int vertexId) const =delete
 
+TBound TotalReactivePowerGenerationBoundAt (char vertexId) const =delete
 
template<Vertices::GenerationStrategyDifferentiationType Strategy>
Types::real TotalReactivePowerGenerationAt (Types::vertexId vertexId, Types::index timestampPosition=0) const
 The total reactive power generation $\reactivepowergeneration$ of all generator snapshots for one timestamp at vertex $\vertex\in\vertices$ with identifier vertexId.
 
+Types::real TotalReactivePowerGenerationAt (int vertexId) const =delete
 
+Types::real TotalReactivePowerGenerationAt (char vertexId) const =delete
 
Add and Remove Loads
Types::loadId AddLoadAt (Types::vertexId vertexId, TLoadProperties load)
 Adds a load at a vertex with identifier vertexId.
 
+Types::loadId AddLoadAt (int vertexId, TLoadProperties load)=delete
 
+Types::loadId AddLoadAt (char vertexId, TLoadProperties load)=delete
 
Types::loadId AddLoadAt (TVertex const &vertex, TLoadProperties const &load)
 Adds a load at a vertex with identifier vertexId.
 
Types::loadId AddLoadAt (TVertex const &vertex, TLoadProperties &&load)
 Adds a load at a vertex with identifier vertexId.
 
void RemoveLoadAt (Types::vertexId vertexId, Types::loadId loadId)
 Removes a load at a vertex $\vertex\in\vertices$ with identifier vertexId.
 
+void RemoveLoadAt (Types::vertexId vertexId, int loadId)=delete
 
+void RemoveLoadAt (Types::vertexId vertexId, char loadId)=delete
 
+void RemoveLoadAt (int vertexId, Types::loadId loadId)=delete
 
+void RemoveLoadAt (int vertexId, int loadId)=delete
 
+void RemoveLoadAt (int vertexId, char loadId)=delete
 
+void RemoveLoadAt (char vertexId, Types::loadId loadId)=delete
 
+void RemoveLoadAt (char vertexId, int loadId)=delete
 
+void RemoveLoadAt (char vertexId, char loadId)=delete
 
void RemoveLoadAt (Types::vertexId vertexId, TLoadProperties &load)
 Removes a load at a vertex $\vertex\in\vertices$ with identifier vertexId.
 
+void RemoveLoadAt (int vertexId, TLoadProperties &load)=delete
 
+void RemoveLoadAt (char vertexId, TLoadProperties &load)=delete
 
Load Accessors
bool HasLoad (Types::loadId loadId) const
 Determines if the load identifier loadId exists.
 
+bool HasLoad (int loadId) const =delete
 
+bool HasLoad (char loadId) const =delete
 
bool HasLoad (TLoadProperties const &load) const
 Determines if the load exists.
 
bool HasLoadAt (Types::vertexId vertexId) const
 Determines if there is a load at vertex with vertexId.
 
+bool HasLoadAt (int vertexId) const =delete
 
+bool HasLoadAt (char vertexId) const =delete
 
bool HasLoadAt (TVertex const &vertex) const
 Determines if it has loads at the vertex $\vertex\in\vertices$.
 
Types::loadId LoadId (TLoadProperties const &load) const
 The load identifier of a load object.
 
void LoadIds (Types::vertexId vertexId, std::vector< Types::loadId > &loadIds) const
 Loads identifiers.
 
+void LoadIds (Types::vertexId vertexId, std::vector< int > &loadIds) const =delete
 
+void LoadIds (Types::vertexId vertexId, std::vector< char > &loadIds) const =delete
 
+void LoadIds (int vertexId, std::vector< Types::loadId > &loadIds) const =delete
 
+void LoadIds (int vertexId, std::vector< int > &loadIds) const =delete
 
+void LoadIds (int vertexId, std::vector< char > &loadIds) const =delete
 
+void LoadIds (char vertexId, std::vector< Types::loadId > &loadIds) const =delete
 
+void LoadIds (char vertexId, std::vector< int > &loadIds) const =delete
 
+void LoadIds (char vertexId, std::vector< char > &loadIds) const =delete
 
void LoadIds (TVertex const &vertex, std::vector< Types::loadId > &loadIds) const
 Loads identifiers at a vertex.
 
+void LoadIds (TVertex const &vertex, std::vector< int > &loadIds) const =delete
 
+void LoadIds (TVertex const &vertex, std::vector< char > &loadIds) const =delete
 
TLoadProperties & LoadAt (Types::loadId loadId)
 Load at load's identifier loadId.
 
TLoadProperties const & LoadAt (Types::loadId loadId) const
 Load at load's identifier loadId.
 
void LoadsAt (Types::vertexId vertexId, std::vector< TLoadProperties > &loads) const
 The loads at a vertex with identifier vertexId.
 
void LoadsAt (TVertex const &vertex, std::vector< TLoadProperties > &loads) const
 The loads at a vertex object.
 
Accessors for the Total Power Load at a Vertex
Types::real RealPowerLoadAt (Types::vertexId vertexId, Types::index snapshotId=0) const
 Total real power load for a certain snapshot (timestamp) at a vertex.
 
Types::real RealPowerLoadAt (TVertex const &vertex, Types::index snapshotId=0) const
 Total real power load for a certain snapshot (timestamp) at a vertex.
 
TBound TotalRealPowerLoadBoundAt (Types::vertexId vertexId, Types::index timestamp=0) const
 Total real power load bound at vertex vertexId.
 
Types::real TotalRealPowerLoadAt (Types::vertexId vertexId, Types::index timestampPosition) const
 The total real power load at a vertex with id vertexId.
 
TBound TotalReactivePowerLoadBoundAt (Types::vertexId vertexId) const
 Total reactive power load bound at a vertex.
 
Snapshot Accessors and Modifiers
void AddGeneratorRealPowerSnapshotAt (Types::generatorId generatorId, Types::generatorSnapshot maximumRealPowerGenerationPu)
 Adds a generator snapshot at generator with identifier generatorId.
 
void UpdateGeneratorSnapshotSize ()
 Update generator snapshot size.
 
void UpdateLoadSnapshotSize ()
 Update load snapshot.
 
void OutputGeneratorSnaps ()
 Output generation snapshots.
 
void OutputLoadSnaps ()
 Output load snapshots.
 
void AddLoadSnapshotAt (Types::loadId loadId, Types::loadSnapshot snapshot)
 Adds a real power load snapshot.
 
void AddSnapshotWeighting (Types::weightSnapshot weight)
 Adds a snapshot weighting.
 
void AddSnapshotTimestamp (Types::timestampSnapshot timestamp)
 Adds a timestamp.
 
Types::index PositionOf (Types::timestampSnapshot timestamp) const
 Position of a timestamp.
 
Types::timestampSnapshot TimestampAt (Types::index timestampPosition) const
 Timestamp at position.
 
Generator Real Power Snapshot
Types::generatorSnapshot GeneratorRealPowerSnapshotAt (Types::generatorId generatorId, Types::timestampSnapshot timestamp) const
 Generator real power snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorRealPowerSnapshotAt (TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const
 Generator real power snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorRealPowerSnapshotAt (Types::generatorId generatorId, Types::index timestampPosition) const
 Generator real power snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorRealPowerSnapshotAt (TGeneratorProperties const &generator, Types::index timestampPosition) const
 Real power generator snapshot at a given timestamp.
 
void GeneratorRealPowerSnapshotsAt (Types::timestampSnapshot timestamp, std::vector< Types::generatorSnapshot > &snapshotsAtTimestamp) const
 Generator snapshots at a timestamp.
 
Generator Reactive Power Snapshot
Todo:
Not fully supported
+
Types::generatorSnapshot GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId, Types::timestampSnapshot timestamp) const
 Generator snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorReactivePowerSnapshotAt (TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const
 Generator snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId, Types::index timestampPosition) const
 Generator real power snapshot at a given timestamp.
 
Types::generatorSnapshot GeneratorReactivePowerSnapshotAt (TGeneratorProperties const &generator, Types::index timestampPosition) const
 Generator reactive snapshot at a given timestamp.
 
Load Snapshot
Types::loadSnapshot LoadSnapshotOf (Types::loadId loadId, Types::timestampSnapshot timestamp)
 Load snapshot at a timestamp.
 
Types::loadSnapshot LoadSnapshotOf (Types::loadId loadId, Types::timestampSnapshot timestamp) const
 Load snapshot at a timestamp.
 
Types::loadSnapshot LoadSnapshotOf (Types::loadId loadId, Types::index timestampPosition)
 The load value of the load at loadId for the timestamp at timestampPosition.
 
Types::loadSnapshot LoadSnapshotOf (Types::loadId loadId, Types::index timestampPosition) const
 The load value of the load at loadId for the timestamp at timestampPosition.
 
void LoadSnapshotsAt (Types::vertexId vertexId, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)
 Loads a snapshot at a vertex with vertexId and a timestampPosition.
 
void LoadSnapshotsAt (TVertex const &vertex, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)
 Loads a snapshot at a vertex and a timestampPosition.
 
void LoadSnapshotsAt (Types::timestampSnapshot timestamp, std::vector< Types::loadSnapshot > &loadSnapshotsAtTimestamp)
 Loads a snapshot at a certain timestamp.
 
Generator Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators (FUNCTION function)
 Iterate over all generators (vertex independent).
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators (FUNCTION function) const
 Iterate over all generators (vertex independent)
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_at (TVertex const &vertex, FUNCTION function)
 The for loop over all generators at a vertex $\vertex\in\vertices$ with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all generators at a vertex $\vertex\in\vertices$ with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all generators at a vertex with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all generators at a vertex with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_identifiers_with_generator (FUNCTION function)
 Iterate over all vertices that have a generator.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_identifiers_with_generator (FUNCTION function) const
 Iterate over all vertices that have a generator.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_identifiers_at (TVertex const &vertex, FUNCTION function)
 Iterate over all generator identifiers at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_identifiers_at (TVertex const &vertex, FUNCTION function) const
 Iterate over all generator identifiers at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_identifiers_at (Types::vertexId vertexId, FUNCTION function)
 Iterate over all generator identifiers at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_identifiers_at (Types::vertexId vertexId, FUNCTION function) const
 Iterate over all generator identifiers at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_tuple (FUNCTION function)
 Iterate over all vertices that have a generator and its generators.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generator_tuple (FUNCTION function) const
 Iterate over all vertices that have a generator and its generators.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_tuple (FUNCTION function)
 Iterate over all vertices that have a generator and its generators.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_generators_tuple (FUNCTION function) const
 Iterate over all vertices that have a generator and its generators.
 
Generator Snapshot Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots (FUNCTION function)
 The for loop over all generator maximum real power p.u. snapshots.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots (FUNCTION function) const
 The for loop over all generator maximum real power p.u. snapshots.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_of (Types::generatorId generatorId, FUNCTION function)
 The for loop over all maximum real power p.u. snapshots of a generator with generatorId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_of (Types::vertexId generatorId, FUNCTION function) const
 The for loop over all maximum real power p.u. snapshots of a generator with generatorId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_of (TGeneratorProperties const &generatorProperties, FUNCTION function)
 The for loop over all maximum real power p.u. snapshots of a generator.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_of (TGeneratorProperties const &generatorProperties, FUNCTION function) const
 The for loop over all maximum real power p.u. snapshots of a generator.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (TVertex const &vertex, FUNCTION function)
 The for loop over all generator maximum real power p.u. snapshots at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all generator maximum real power p.u. snapshots at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The sequential for loop over snapshots with a certain @ timestampPosition for all generators.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const
 The sequential for loop over snapshots with a certain @ timestampPosition for all generators.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_generator_snapshots_at (TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const
 The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.
 
Seriell Load Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads (FUNCTION function)
 The for loop over all loads (vertex independent).
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads (FUNCTION function) const
 The for loop over all loads (vertex independent).
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_identifiers_with_load (FUNCTION function) const
 The for loop over all vertices that have a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_load_identifiers_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all load identifiers at a vertex identifier vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_load_identifiers_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all load identifiers at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads_at (TVertex const &vertex, FUNCTION function)
 The for loop over all load objects at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all load objects at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads_at (Types::vertexId const vertexId, FUNCTION function)
 The for loop over all load objects at a vertex identifier vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all load objects at a vertex identifier vertexId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_load_tuples (FUNCTION function)
 The for loop over all verticesthat have a load and its load objects.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_load_tuples (FUNCTION function) const
 The for loop over all verticesthat have a load and its load objects.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_loads_tuple (FUNCTION function)
 The for loop over all verticesthat have a load.
 
Load Snapshot Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots (FUNCTION function)
 The for loop over all load real power snapshots.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots (FUNCTION function) const
 The for loop over all load real power snapshots.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_of (Types::loadId loadId, FUNCTION function)
 The for loop over all real power snapshots of a load with loadId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_of (Types::vertexId loadId, FUNCTION function) const
 The for loop over all real power snapshots of a load with loadId.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_of (TLoadProperties load, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_of (TLoadProperties const &load, FUNCTION function) const
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (TVertex const &vertex, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_real_power_load_snapshots_at (TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const
 The for loop over all real power snapshots of a load.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Types::real baseMva_
 
TBound thetaBound_
 
Types::count verticesWithGeneratorCount_
 
Types::count numberOfGenerators_
 
Types::count numberOfLoads_
 
std::vector< std::vector< Types::vertexId > > generatorsAtVertex_
 
std::vector< TGeneratorProperties > generators_
 
std::vector< bool > generatorExists_
 
std::vector< std::vector< Types::vertexId > > loadsAtVertex_
 
std::vector< TLoadProperties > loads_
 
std::vector< bool > loadExists_
 
std::vector< std::vector< Types::generatorSnapshot > > generatorRealPowerSnapshots_
 
std::vector< std::vector< Types::loadSnapshot > > loadSnapshots_
 
std::vector< Types::timestampSnapshot > timestamps_
 
std::vector< Types::weightSnapshot > snapshotWeights_
 
Vertices::BoundType generatorBoundType_
 
Vertices::BoundType loadBoundType_
 
TGraph graph_
 
+ + + + + +

+Friends

Output Methods
std::ostream & operator<< (std::ostream &os, PowerGrid< TGraph > const &rhs)
 Output.
 
+

Detailed Description

+
template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+class egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
+

Definition at line 42 of file PowerGrid.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TBound = Bound<>
+
+ +

Definition at line 57 of file PowerGrid.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TEdge = typename GraphType::TEdge
+
+ +

Definition at line 51 of file PowerGrid.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TEdgeProperties = typename GraphType::TEdgeProperties
+
+ +

Definition at line 52 of file PowerGrid.hpp.

+ +
+
+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TGeneratorProperties = GeneratorProperty
+
+ +

Definition at line 48 of file PowerGrid.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TGraph = GraphType
+
+ +

Definition at line 54 of file PowerGrid.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TLoadProperties = LoadProperty
+
+ +

Definition at line 49 of file PowerGrid.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TNetwork = PowerGrid
+
+ +

Definition at line 55 of file PowerGrid.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TVertex = typename GraphType::TVertex
+
+ +

Definition at line 46 of file PowerGrid.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + +
using egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TVertexProperties = typename GraphType::TVertexProperties
+
+ +

Definition at line 47 of file PowerGrid.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ PowerGrid()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::PowerGrid ()
+ 		+inline
+
+ +

Constructs the object.

+ +

Definition at line 67 of file PowerGrid.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddGeneratorAt() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddGeneratorAt (TVertex const & vertex,
TGeneratorProperties && generatorProperty 
)
+ 		+inline
+
+ +

Adds a generator $g\in\generators$ at a vertex vertex $\vertex\in\vertices$.

+
Parameters
+ + + +
vertexThe vertex object $\vertex\in\vertices$.
[in]generatorPropertyThe generator property $\vertex\in\generators$.
+
+
+
Returns
The generator identifier.
+ +

Definition at line 557 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddGeneratorAt() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddGeneratorAt (TVertex const & vertex,
TGeneratorProperties const & generatorProperty 
)
+ 		+inline
+
+ +

Adds a generator $\vertex\in\generators$ at a vertex vertex $\vertex\in\vertices$.

+
Parameters
+ + + +
vertexThe vertex object $\vertex\in\vertices$.
[in]generatorPropertyThe generator property.
+
+
+
Returns
The generator identifier.
+ +

Definition at line 535 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddGeneratorAt() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddGeneratorAt (Types::vertexId vertexId,
TGeneratorProperties && generatorProperty 
)
+ 		+inline
+
+ +

Adds a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier vertexId.
generatorThe generator object $\vertex\in\generators$.
+
+
+
Returns
The generator identifier.
+ +

Definition at line 495 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddGeneratorAt() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddGeneratorAt (Types::vertexId vertexId,
TGeneratorProperties const & generatorProperty 
)
+ 		+inline
+
+ +

Adds a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier vertexId.
[in]generatorPropertyThe generator object $\vertex\in\generators$.
+
+
+
Returns
The generator identifier.
+ +

Definition at line 457 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorExists_, egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generators_, egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorsAtVertex_, egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::Graph(), and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::numberOfGenerators_.

+ +
+
+ +

◆ AddGeneratorRealPowerSnapshotAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddGeneratorRealPowerSnapshotAt (Types::generatorId generatorId,
Types::generatorSnapshot maximumRealPowerGenerationPu 
)
+ 		+inline
+
+ +

Adds a generator snapshot at generator with identifier generatorId.

+

These values represent the maximum possible production of a generator at a certain timestamp.

+
Parameters
+ + + +
[in]generatorIdThe identifier of the generator.
[in]maximumRealPowerGenerationPuThe generator snapshot representing the maximum real power generation in p.u.
+
+
+
Precondition
The generator $\vertex\in\generators$ with the generatorId has to exist and the maximum real power generation p.u. has not to be Const::NONE.
+ +

Definition at line 1736 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddLoadAt() [1/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddLoadAt (TVertex const & vertex,
TLoadProperties && load 
)
+ 		+inline
+
+ +

Adds a load at a vertex with identifier vertexId.

+

There are more than one load allowed at each vertex.

+
Parameters
+ + + +
vertexThe vertex object $\vertex\in\vertices$.
loadThe load object.
+
+
+
Returns
The load identifier.
+ +

Definition at line 1237 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddLoadAt() [2/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddLoadAt (TVertex const & vertex,
TLoadProperties const & load 
)
+ 		+inline
+
+ +

Adds a load at a vertex with identifier vertexId.

+

There are more than one load allowed at each vertex.

+
Parameters
+ + + +
vertexThe vertex object $\vertex\in\vertices$.
[in]loadThe load object.
+
+
+
Returns
The load identifier.
+ +

Definition at line 1218 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddLoadAt() [3/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddLoadAt (Types::vertexId vertexId,
TLoadProperties load 
)
+ 		+inline
+
+ +

Adds a load at a vertex with identifier vertexId.

+

There are more than one load allowed at each vertex.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
loadThe load object.
+
+
+
Returns
The identifier of the load.
+ +

Definition at line 1184 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddLoadSnapshotAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddLoadSnapshotAt (Types::loadId loadId,
Types::loadSnapshot snapshot 
)
+ 		+inline
+
+ +

Adds a real power load snapshot.

+

There are more than one load per bus permitted.

+
Parameters
+ + + +
[in]loadIdThe load identifier
[in]snapshotThe load of a snapshot representing the real power load at a timestamp in p.u.
+
+
+ +

Definition at line 1822 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddSnapshotTimestamp()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddSnapshotTimestamp (Types::timestampSnapshot timestamp)
+ 		+inline
+
+ +

Adds a timestamp.

+

The timestamp should have the format "0000-00-00 00:00:00" representing "<year>-<month>-<day> <hour>:<minute>:<second>".

+
Parameters
+ + +
[in]timestampThe timestamp, e.g., "2019-09-19 19:19:19"
+
+
+ +

Definition at line 1856 of file PowerGrid.hpp.

+ +
+
+ +

◆ AddSnapshotWeighting()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::AddSnapshotWeighting (Types::weightSnapshot weight)
+ 		+inline
+
+ +

Adds a snapshot weighting.

+
Parameters
+ + +
[in]weightThe weight of a snapshot
+
+
+ +

Definition at line 1842 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::snapshotWeights_.

+ +
+
+ +

◆ BaseMva() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::real & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::BaseMva ()
+ 		+inline
+
+ +

Setter for the base MVA.

+
Returns
The power grid's base MVA.
+ +

Definition at line 119 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::baseMva_.

+ +
+
+ +

◆ BaseMva() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::BaseMva () const
+ 		+inline
+
+ +

Getter for the base MVA.

+
Returns
The power grid's base MVA.
+ +

Definition at line 109 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::baseMva_.

+ +
+
+ +

◆ FindGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::FindGenerator (TGeneratorProperties const & generatorProperty,
std::vector< TGeneratorProperties > const & generators 
) const
+ 		+inline
+
+ +

Find a generator in a vector.

+
Parameters
+ + + +
[in]generatorPropertyThe generator vertex.
[in]generatorsThe generators.
+
+
+
Note
If the generator $\vertex\in\generators$ does not exist the method returns Const::NONE equivalent to $\emptyset$. However, for duplicate generators $\vertex\in\generators$ it will output the position it finds the first duplicate generator.
+
Returns
The generator's identifier.
+ +

Definition at line 942 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_identifiers_at() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_identifiers_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

Iterate over all generator identifiers at a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object $\vertex\in\vertices$.
[in]functionThe function pointer, e.g., lambda function that has a generatorId as input.
+
+
+
for_all_generator_identifiers_at ( vertex,
+
[]( Types::generatorId generatorId )
+
{
+
// Do something with the identifier of the generator.
+
}
+
);
+
egoa::PowerGrid::for_all_generator_identifiers_at
void for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function)
Iterate over all generator identifiers at a vertex.
Definition PowerGrid.hpp:2607
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator identifiers at vertex.
+
+
+ +

Definition at line 2607 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_identifiers_at() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_identifiers_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

Iterate over all generator identifiers at a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object $\vertex\in\vertices$.
[in]functionThe function pointer, e.g., lambda function that has a generatorId as input.
+
+
+
for_all_generator_identifiers_at ( vertex,
+
[]( Types::generatorId generatorId )
+
{
+
// Do something with the identifier of the generator.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator identifiers at vertex.
+
+
+ +

Definition at line 2638 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_identifiers_at() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_identifiers_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

Iterate over all generator identifiers at a vertex.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function pointer, e.g., lambda function that has a generatorId as input.
+
+
+
for_all_generator_identifiers_at ( vertexId,
+
[]( Types::generatorId generatorId )
+
{
+
// Do something with the identifier of the generator.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator identifiers at vertexId.
+
+
+ +

Definition at line 2669 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_identifiers_at() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_identifiers_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

Iterate over all generator identifiers at a vertex.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function pointer, e.g., lambda function that has a generatorId as input.
+
+
+
for_all_generator_identifiers_at ( vertexId,
+
[]( Types::generatorId generatorId )
+
{
+
// Do something with the identifier of the generator.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator identifiers at vertexId.
+
+
+ +

Definition at line 2700 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_tuple() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_tuple (FUNCTION function)
+ 		+inline
+
+ +

Iterate over all vertices that have a generator and its generators.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId and a generator object as input.
+
+
+
for_all_generator_tuple (
+
[]( Types::vertexId vertexId
+
, TGeneratorProperties & generator )
+
{
+
// Do something with ?.
+
}
+
);
+
egoa::PowerGrid::for_all_generator_tuple
void for_all_generator_tuple(FUNCTION function)
Iterate over all vertices that have a generator and its generators.
Definition PowerGrid.hpp:2732
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator tuple of the from (vertexId, generator).
+
+
+ +

Definition at line 2732 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generator_tuple() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generator_tuple (FUNCTION function) const
+ 		+inline
+
+ +

Iterate over all vertices that have a generator and its generators.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId and a generator object as input.
+
+
+
for_all_generator_tuple (
+
[]( Types::vertexId vertexId
+
, TGeneratorProperties generator )
+
{
+
// Do something with ?.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator tuple of the from (vertexId, generator).
+
+
+ +

Definition at line 2762 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators (FUNCTION function)
+ 		+inline
+
+ +

Iterate over all generators (vertex independent).

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
for_all_generators (
+
[]( TGeneratorProperties & generatorProperty )
+
{
+
// Do something with the generator object.
+
}
+
);
+
egoa::PowerGrid::for_all_generators
void for_all_generators(FUNCTION function)
Iterate over all generators (vertex independent).
Definition PowerGrid.hpp:2370
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators.
+
+
+ +

Definition at line 2370 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators (FUNCTION function) const
+ 		+inline
+
+ +

Iterate over all generators (vertex independent)

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a generator object as input
+
+
+
for_all_generators (
+
[]( TGeneratorProperties const & generatorProperty )
+
{
+
// Do something with the generator object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators of a power grid.
+
+
+ +

Definition at line 2398 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_at() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all generators at a vertex $\vertex\in\vertices$ with vertexId.

+
Parameters
+ + + +
vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function.
+
+
+
for_all_generators_at ( vertex,
+
[]( TGeneratorProperties & generatorProperty )
+
{
+
// Do something with the generator vertex.
+
}
+
);
+
egoa::PowerGrid::for_all_generators_at
void for_all_generators_at(TVertex const &vertex, FUNCTION function)
The for loop over all generators at a vertex with vertexId.
Definition PowerGrid.hpp:2427
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators of vertex.
+
+
+ +

Definition at line 2427 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_at() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all generators at a vertex $\vertex\in\vertices$ with vertexId.

+
Parameters
+ + + +
vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function.
+
+
+
for_all_generators_at ( vertex,
+
[]( TGeneratorProperties const & generatorProperty )
+
{
+
// Do something with the generator vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators of vertex.
+
+
+ +

Definition at line 2458 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_at() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all generators at a vertex with vertexId.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
[in]functionThe function.
+
+
+
for_all_generators_at (
+
[]( TGeneratorProperties & generatorProperty )
+
{
+
// Do something with the generator vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators of vertexId.
+
+
+ +

Definition at line 2489 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_at() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all generators at a vertex with vertexId.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
[in]functionThe function.
+
+
+
for_all_generators_at ( vertexId,
+
[]( TGeneratorProperties const & generatorProperty )
+
{
+
// Do something with the generator vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generators of vertexId.
+
+
+ +

Definition at line 2520 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_tuple() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_tuple (FUNCTION function)
+ 		+inline
+
+ +

Iterate over all vertices that have a generator and its generators.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId and a vector of generator objects as input.
+
+
+
for_all_generators_tuple (
+
[]( Types::vertexId vertexId
+
, std::vector<TGeneratorProperties> generators )
+
{
+
// Do something with ?.
+
}
+
);
+
egoa::PowerGrid::for_all_generators_tuple
void for_all_generators_tuple(FUNCTION function)
Iterate over all vertices that have a generator and its generators.
Definition PowerGrid.hpp:2792
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator tuple of the from (vertexId, generators).
+
+
+ +

Definition at line 2792 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_generators_tuple() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_generators_tuple (FUNCTION function) const
+ 		+inline
+
+ +

Iterate over all vertices that have a generator and its generators.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId and a vector of generator objects as input.
+
+
+
for_all_generators_tuple<ExecutionPolicy::sequential>(
+
[]( Types::vertexId vertexId
+
, std::vector<TGeneratorProperties> generators )
+
{
+
// Do something with ?.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all generator tuple of the from (vertexId, generators).
+
+
+ +

Definition at line 2822 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_load_identifiers_at() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_load_identifiers_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all load identifiers at a vertex.

+
Parameters
+ + + +
vertexThe vertex object.
[in]functionThe function pointer, e.g., lambda function that has a load identifier as input.
+
+
+
for_all_load_identifiers_at<ExecutionPolicy::sequential> ( vertex
+
, []( Types::loadId loadId )
+
{
+
// Do something with the load identifier at the @p vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all load identifier at vertex.
+
+
+ +

Definition at line 3526 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_load_identifiers_at() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_load_identifiers_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all load identifiers at a vertex identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function pointer, e.g., lambda function that has a load identifier Types::loadId as input.
+
+
+
for_all_load_identifiers_at<ExecutionPolicy::sequential>( vertexId
+
, []( Types::loadId loadId )
+
{
+
// Do something with the load identifier at the @p vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all load identifier at vertexId.
+
+
+ +

Definition at line 3494 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_load_tuples() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_load_tuples (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all verticesthat have a load and its load objects.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a load objectas input.
+
+
+
for_all_load_tuples<ExecutionPolicy::sequential> (
+
[]( Types::vertexId vertexId
+
, TLoadProperties & load )
+
{
+
// Do something with the vertexId and load object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all load tuples (vertexId, load).
+
+
+ +

Definition at line 3686 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_load_tuples() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_load_tuples (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all verticesthat have a load and its load objects.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a load objectas input.
+
+
+
for_all_load_tuples<ExecutionPolicy::sequential> (
+
[]( Types::vertexId vertexId
+
, TLoadProperties const & load )
+
{
+
// Do something with the vertexId and load object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all load tuples (vertexId, load).
+
+
+ +

Definition at line 3717 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all loads (vertex independent).

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads<ExecutionPolicy::sequential> (
+
[]( TLoadProperties & load )
+
{
+
// Do something with the load object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads.
+
+
+ +

Definition at line 3404 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all loads (vertex independent).

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads<ExecutionPolicy::sequential> (
+
[]( TLoadProperties const & load )
+
{
+
// Do something with the load object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads.
+
+
+ +

Definition at line 3433 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads_at() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all load objects at a vertex.

+
Parameters
+ + + +
vertexThe vertex object.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads_at<ExecutionPolicy::sequential> ( vertex
+
, []( TLoadProperties & load )
+
{
+
// Do something with the load object at the @p vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads at vertex.
+
+
+ +

Definition at line 3558 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads_at() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all load objects at a vertex.

+
Parameters
+ + + +
vertexThe vertex object.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads_at<ExecutionPolicy::sequential> ( vertex
+
, []( TLoadProperties const & load )
+
{
+
// Do something with the load object at the @p vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads at vertex.
+
+
+ +

Definition at line 3590 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads_at() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads_at (Types::vertexId const vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all load objects at a vertex identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads_at<ExecutionPolicy::sequential> ( vertexId
+
, []( TLoadProperties & load )
+
{
+
// Do something with the load object at the @p vertexId.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads at vertexId.
+
+
+ +

Definition at line 3622 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads_at() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all load objects at a vertex identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
for_all_loads_at<ExecutionPolicy::sequential> ( vertexId
+
, []( TLoadProperties const & load )
+
{
+
// Do something with the load object at the @p vertexId.
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads at vertexId.
+
+
+ +

Definition at line 3653 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_loads_tuple()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_loads_tuple (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all verticesthat have a load.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and its load objectsas input.
+
+
+
for_all_loads_tuple<ExecutionPolicy::sequential> (
+
[]( Types::vertexId vertexId
+
, std::vector<TLoadProperties> & loads )
+
{
+
// Do something with the vertexId and load object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all loads tuple (vertexId, load).
+
+
+ +

Definition at line 3748 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_generator_snapshots<ExecutionPolicy::sequential>(
+
[]( Types::index snapshotId
+
, Types::generatorSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots.
+
+
+ +

Definition at line 2854 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots.

+
Parameters
+ + + +
generatorIdThe identifier of the generator.
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_generator_snapshots<ExecutionPolicy::sequential>(
+
[]( Types::index snapshotId
+
, Types::generatorSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots.
+
+
+ +

Definition at line 2884 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [1/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots at a vertex.

+
Parameters
+ + + +
vertexThe vertex.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots at vertex.
+
+
+ +

Definition at line 3152 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [2/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots at a vertex.

+
Parameters
+ + + +
vertexThe vertex.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots at vertex.
+
+
+ +

Definition at line 3191 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [3/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.

+
Parameters
+ + + + +
vertexThe vertex
[in]timestampPositionThe timestamp position
[in]functionThe function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 3322 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [4/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.

+
Parameters
+ + + + +
vertexThe vertex.
[in]timestampPositionThe timestamp position.
[in]functionThe function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertex,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 3366 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [5/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.

+
Parameters
+ + + +
vertexIdThe identifier of a vertex.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots at vertexId.
+
+
+ +

Definition at line 3074 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [6/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.

+
Parameters
+ + + +
vertexIdThe identifier of a vertex.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots at vertexId.
+
+
+ +

Definition at line 3113 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [7/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inline
+
+ +

The sequential for loop over snapshots with a certain @ timestampPosition for all generators.

+

This loop basically extracts a row.

+
Parameters
+ + + + +
vertexIdThe identifier of a vertex.
timestampPositionThe position of the snapshot. (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator at timestamp at vertex.
+
+
+ +

Definition at line 3234 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [8/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_at (Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
) const
+ 		+inline
+
+ +

The sequential for loop over snapshots with a certain @ timestampPosition for all generators.

+

This loop basically extracts a row.

+
Parameters
+ + + + +
vertexIdThe identifier of a vertex.
timestampPositionThe position of the snapshot (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator at timestamp at vertex.
+
+
+ +

Definition at line 3279 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_of (TGeneratorProperties const & generatorProperties,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all maximum real power p.u. snapshots of a generator.

+
Parameters
+ + + +
generatorPropertiesThe generator properties.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the generator's properties generatorProperties exists before using this method.
+
if ( network.HasGenerator ( network.GeneratorId ( generatorProperties ) ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots of generator.
+
+
+ +

Definition at line 2997 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_of (TGeneratorProperties const & generatorProperties,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all maximum real power p.u. snapshots of a generator.

+
Parameters
+ + + +
generatorPropertiesThe generator properties.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the generator's properties generatorProperties exists before using this method.
+
if ( network.HasGenerator ( network.GeneratorId ( generatorProperties ) ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots of generator.
+
+
+ +

Definition at line 3035 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_of (Types::generatorId generatorId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all maximum real power p.u. snapshots of a generator with generatorId.

+
Parameters
+ + + +
generatorIdThe identifier of the generator.
[in]functionThe function, e.g., lambda function
+
+
+
Precondition
Check if the generator identifier generatorId of the generatorProperties exists before using this method.
+
if ( network.HasGenerator ( generatorId ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
generatorId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots of generatorId.
+
+
+ +

Definition at line 2921 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_generator_snapshots_of (Types::vertexId generatorId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all maximum real power p.u. snapshots of a generator with generatorId.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the generator identifier generatorId of the generatorProperties exists before using this method.
+
if ( network.HasGenerator ( generatorId ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
generatorId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power generator snapshots of generatorId.
+
+
+ +

Definition at line 2959 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all load real power snapshots.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_load_snapshots<ExecutionPolicy::sequential>(
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots.
+
+
+ +

Definition at line 3781 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all load real power snapshots.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_load_snapshots<ExecutionPolicy::sequential>(
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots.
+
+
+ +

Definition at line 3809 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [1/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + +
vertexThe vertex object.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertex.
+
+
+ +

Definition at line 4077 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [2/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
vertexThe vertex object.
[in]timestampPositionThe timestamp position
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertex.
+
+
+ +

Definition at line 4116 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [3/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
vertexThe vertex object.
[in]timestampPositionThe timestamp position.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertex
+
, timestampPosition
+
, []( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 4244 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [4/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
vertexThe vertex object.
[in]timestampPositionThe timestamp position
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertex,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 4286 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [5/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertexId.
+
+
+ +

Definition at line 4000 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [6/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertexId.
+
+
+ +

Definition at line 4039 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [7/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
vertexIdThe identifier of a vertex
timestampPositionThe position of the snapshot (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertexId.
+
+
+ +

Definition at line 4158 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [8/8]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_at (Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
vertexIdThe identifier of a vertex
timestampPositionThe position of the snapshot (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
vertexId
+
, timestampPosition
+
, []( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots at vertexId.
+
+
+ +

Definition at line 4202 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_of (TLoadProperties const & load,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + +
[in]loadThe load object.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the load's properties loadProperties exists before using this method.
+
if ( network.HasLoad ( network.LoadId ( loadProperties ) ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots of load.
+
+
+ +

Definition at line 3961 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_of (TLoadProperties load,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + +
[in]loadThe load object.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the load's properties loadProperties exists before using this method.
+
if ( network.HasLoad ( network.LoadId ( loadProperties ) ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots of load.
+
+
+ +

Definition at line 3923 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_of (Types::loadId loadId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load with loadId.

+
Parameters
+ + + +
[in]loadIdThe load identifier.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the load identifier loadId of the loadProperties exists before using this method.
+
if ( network.HasLoad ( loadId ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
loadId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots of loadId.
+
+
+ +

Definition at line 3846 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_real_power_load_snapshots_of (Types::vertexId loadId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all real power snapshots of a load with loadId.

+
Parameters
+ + + +
[in]loadIdThe load identifier.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the load identifier loadId of the loadProperties exists before using this method.
+
if ( network.HasLoad ( loadId ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
loadId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all real power load snapshots of loadId.
+
+
+ +

Definition at line 3885 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers_with_generator() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_vertex_identifiers_with_generator (FUNCTION function)
+ 		+inline
+
+ +

Iterate over all vertices that have a generator.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId as input.
+
+
+
for_all_vertex_identifiers_with_generator (
+
[]( Types::vertexId vertexId )
+
{
+
// Do something with the identifier of a vertex.
+
}
+
);
+
egoa::PowerGrid::for_all_vertex_identifiers_with_generator
void for_all_vertex_identifiers_with_generator(FUNCTION function)
Iterate over all vertices that have a generator.
Definition PowerGrid.hpp:2550
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all vertex identifiers having a generator.
+
+
+ +

Definition at line 2550 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers_with_generator() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_vertex_identifiers_with_generator (FUNCTION function) const
+ 		+inline
+
+ +

Iterate over all vertices that have a generator.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertexId as input.
+
+
+
for_all_vertex_identifiers_with_generator (
+
[]( Types::vertexId vertexId )
+
{
+
// Do something with the identifier of a vertex.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all vertex identifiers having a generator.
+
+
+ +

Definition at line 2578 of file PowerGrid.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers_with_load()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::for_all_vertex_identifiers_with_load (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all vertices that have a load.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier Types::vertexId as input.
+
+
+
for_all_vertex_identifiers_with_load<ExecutionPolicy::sequential> (
+
[]( Types::vertexId vertexId )
+
{
+
// Do something with the vertex identifier that has loads.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all vertex identifier that have a load.
+
+
+ +

Definition at line 3463 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
TGeneratorProperties & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorAt (Types::generatorId generatorId)
+ 		+inline
+
+ +

Generator $\vertex\in\generators$ at generator's identifier generatorId.

+
Parameters
+ + +
[in]generatorIdThe generator identifier.
+
+
+
Returns
The generator properties $\vertex\in\generators$.
+ +

Definition at line 768 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
TGeneratorProperties const & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorAt (Types::generatorId generatorId) const
+ 		+inline
+
+ +

Generator $\vertex\in\generators$ at generator's identifier generatorId.

+
Parameters
+ + +
[in]generatorIdThe generator identifier.
+
+
+
Returns
The generator property $\vertex\in\generators$.
+ +

Definition at line 782 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorBoundType() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Vertices::BoundType & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorBoundType ()
+ 		+inline
+
+ +

Setter for the generator bound type.

+
Precondition
The default value is unknown.
+
Returns
The generator vertex bound type.
+ +

Definition at line 166 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_.

+ +
+
+ +

◆ GeneratorBoundType() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Vertices::BoundType const & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorBoundType () const
+ 		+inline
+
+ +

Getter for the generator bound type.

+
Precondition
The default value is unknown.
+
Returns
The generator vertex bound type.
+ +

Definition at line 155 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_.

+ +
+
+ +

◆ GeneratorId()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
Types::generatorId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorId (TGeneratorProperties const & generatorProperty) const
+ 		+inline
+
+ +

The generator identifier of a generator $g\in\generators$.

+
Parameters
+ + +
[in]generatorPropertyThe generator property.
+
+
+
Note
If the generator $\vertex\in\generators$ does not exist the method returns Const::NONE equivalent to $\emptyset$. However, for duplicate generators $\vertex\in\generators$ it will output the position it finds the first duplicate generator.
+
Returns
If the generator exists the generator's identifier generatorId is returned, Const::NONE otherwise.
+ +

Definition at line 726 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorIds()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorIds (Types::vertexId vertexId,
std::vector< Types::generatorId > & generatorIds 
) const
+ 		+inline
+
+ +

Identifiers of all generators at a vertex with vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
generatorIdsThe generator identifiers.
+
+
+ +

Definition at line 739 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorReactivePowerSnapshotAt() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (TGeneratorProperties const & generator,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

Generator reactive snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Parameters
+ + + +
generatorThe generator object.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 2151 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorReactivePowerSnapshotAt() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (TGeneratorProperties const & generator,
Types::timestampSnapshot timestamp 
) const
+ 		+inline
+
+ +

Generator snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Parameters
+ + + +
generatorThe generator object.
[in]timestampThe timestamp.
+
+
+
Returns
The generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 2096 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorReactivePowerSnapshotAt() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

Generator real power snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Note
Timestamp is not supported for reactive power currently!
+
Parameters
+ + + +
generatorIdThe generator identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The generation at a timestamp (maximum real power generation in p.u.).
+
Todo:
Logic for reactive power if data allows it. This is not clean.
+ +

Definition at line 2122 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorReactivePowerSnapshotAt() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId,
Types::timestampSnapshot timestamp 
) const
+ 		+inline
+
+ +

Generator snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Parameters
+ + + +
generatorIdThe generator identifier.
[in]timestampThe timestamp.
+
+
+
Returns
The generation at a timestamp (maximum real power generation in p.u.).
+
Todo:
Reactive power is not supported in that way.
+ +

Definition at line 2067 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorRealPowerSnapshotAt() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotAt (TGeneratorProperties const & generator,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

Real power generator snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Parameters
+ + + +
generatorThe generator object.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The real power generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 2000 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorRealPowerSnapshotAt() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotAt (TGeneratorProperties const & generator,
Types::timestampSnapshot timestamp 
) const
+ 		+inline
+
+ +

Generator real power snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Parameters
+ + + +
generatorThe generator object.
[in]timestampThe timestamp.
+
+
+
Returns
The real power generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 1946 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorRealPowerSnapshotAt() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotAt (Types::generatorId generatorId,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

Generator real power snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Precondition
Check for a valid generatorId and timestamp position.
+
Parameters
+ + + +
generatorIdThe generator identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The real power generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 1970 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorRealPowerSnapshotAt() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::generatorSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotAt (Types::generatorId generatorId,
Types::timestampSnapshot timestamp 
) const
+ 		+inline
+
+ +

Generator real power snapshot at a given timestamp.

+

If the generator has no generation value assigned for the given timestamp, the method returns Const::NONE.

+
Postcondition
If the timestamp is invalid the method returns Const::NONE.
+
Parameters
+ + + +
generatorIdThe generator identifier.
[in]timestampThe timestamp.
+
+
+
Returns
The real power generation at a timestamp (maximum real power generation in p.u.).
+ +

Definition at line 1917 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorRealPowerSnapshotsAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotsAt (Types::timestampSnapshot timestamp,
std::vector< Types::generatorSnapshot > & snapshotsAtTimestamp 
) const
+ 		+inline
+
+ +

Generator snapshots at a timestamp.

+

Some generators might not have snapshots over time. In this case this method returns a vector with Const::NONE at these generators.

+
Precondition
The vector snapshotsAtTimestamp has to be empty and snapshotsAtTimestamp have to be empty.
+
Parameters
+ + + +
[in]timestampThe timestamp.
snapshotsAtTimestampThe snapshots at the timestamp.
+
+
+
Todo:
Add the same for reactive power?
+ +

Definition at line 2023 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorsAt() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorsAt (TVertex const & vertex,
std::vector< TGeneratorProperties > & generators 
) const
+ 		+inline
+
+ +

All generator objects at a bus vertex.

+
Parameters
+ + + +
vertexThe vertex object.
generatorsThe generators at a vertex.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
See also
StaticGraph::VertexExists
+
+DynamicGraph::VertexExists
+
std::vector<TGeneratorProperties> generators;
+
if ( this->Graph().VertexExists ( this->Graph().VertexId ( vertexId ) ) )
+
GeneratorsAt ( vertex, generators );
+
egoa::PowerGrid::GeneratorsAt
void GeneratorsAt(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const
All generator identifiers at a vertex with vertexId.
Definition PowerGrid.hpp:814
+
egoa::PowerGrid::Graph
TGraph const & Graph() const
Getter for the underlying graph.
Definition PowerGrid.hpp:89
+
Note
If the vertex $\vertex\in\vertices$ has no generator $\{\vertex\}\cap\generators = \emptyset$ then the generators vectors returns empty.
+ +

Definition at line 919 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorsAt() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorsAt (TVertex const & vertex,
std::vector< Types::generatorId > & generatorIds 
) const
+ 		+inline
+
+ +

All generator identifiers at a bus vertex.

+
Parameters
+ + + +
vertexThe vertex object.
generatorsThe generators at a vertex.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
See also
StaticGraph::VertexExists
+
+DynamicGraph::VertexExists
+
std::vector<Types::generatorId> generatorIds;
+
if ( this->Graph().VertexExists ( this->Graph().VertexId ( vertexId ) ) )
+
GeneratorsAt ( vertex, generatorIds );
+
Note
If the vertex $\vertex\in\vertices$ has no generator $\{\vertex\}\cap\generators = \emptyset$ then the generatorIds vectors returns empty.
+ +

Definition at line 888 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorsAt() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorsAt (Types::vertexId vertexId,
std::vector< TGeneratorProperties > & generators 
) const
+ 		+inline
+
+ +

All generator objects at a vertex with vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
generatorsThe generators at vertex with vertexId.
+
+
+
Precondition
Check if the vertex identifier vertexId exists before using this method.
+
See also
StaticGraph::VertexExists
+
+DynamicGraph::VertexExists
+
std::vector<TGeneratorProperties> generators;
+
if ( this->Graph().VertexExists ( vertexId ) )
+
GeneratorsAt ( vertex, generators );
+
Note
If the vertex $\vertex\in\vertices$ has no generator $\{\vertex\}\cap\generators = \emptyset$ then the generators vectors returns empty.
+ +

Definition at line 849 of file PowerGrid.hpp.

+ +
+
+ +

◆ GeneratorsAt() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorsAt (Types::vertexId vertexId,
std::vector< Types::generatorId > & generatorIds 
) const
+ 		+inline
+
+ +

All generator identifiers at a vertex with vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
generatoridentifiers The generator identifiers at vertex with vertexId.
+
+
+
Precondition
Check if the vertex identifier vertexId exists before using this method.
+
See also
StaticGraph::VertexExists
+
+DynamicGraph::VertexExists
+
std::vector<Types::generatorId> generatorIds;
+
if ( this->Graph().VertexExists ( vertexId ) )
+
{
+
GeneratorsAt ( vertex, generatorIds );
+
}
+
Note
If the vertex $\vertex\in\vertices$ has no generator $\{\vertex\}\cap\generators = \emptyset$ then the generatorIds vectors returns empty.
+ +

Definition at line 814 of file PowerGrid.hpp.

+ +
+
+ +

◆ Graph() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
TGraph & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::Graph ()
+ 		+inline
+
+ +

Setter for the underlying graph.

+
Returns
The underlying graph.
+ +

Definition at line 99 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::graph_.

+ +
+
+ +

◆ Graph() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
TGraph const & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::Graph () const
+ 		+inline
+
+ +

Getter for the underlying graph.

+
Returns
The underlying graph.
+ +

Definition at line 89 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::graph_.

+ +
+
+ +

◆ HasGenerator() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasGenerator (TGeneratorProperties const & generatorProperty) const
+ 		+inline
+
+ +

Determines if there is a generator $\vertex\in\generators$.

+
Parameters
+ + +
[in]generatorPropertyThe generator property.
+
+
+
Returns
true if the generator exists, false otherwise.
+ +

Definition at line 670 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasGenerator() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasGenerator (Types::generatorId generatorId) const
+ 		+inline
+
+ +

Determines if there is a generator $\vertex\in\generators$ with the given generatorId.

+
Parameters
+ + +
[in]generatorIdThe generator identifier.
+
+
+
Returns
true if the generator identifier exists, false otherwise.
+ +

Definition at line 651 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasGeneratorAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasGeneratorAt (TVertex const & vertex) const
+ 		+inline
+
+ +

Determines if it has a generator at vertex with identifier vertexId.

+
Parameters
+ + +
[in]vertexThe vertex object $\vertex\in\vertices$.
+
+
+
Returns
true if there is a generator at vertex vertexId, false otherwise.
+ +

Definition at line 704 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasGeneratorAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasGeneratorAt (Types::vertexId vertexId) const
+ 		+inline
+
+ +

Determines if it has a generator at vertex with identifier vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex with identifier vertexId.
+
+
+
Returns
true if there is a generator at vertex vertexId, false otherwise.
+ +

Definition at line 684 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasLoad() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasLoad (TLoadProperties const & load) const
+ 		+inline
+
+ +

Determines if the load exists.

+
Parameters
+ + +
loadThe load object.
+
+
+
Returns
true if the load exists, false otherwise.
+ +

Definition at line 1345 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasLoad() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasLoad (Types::loadId loadId) const
+ 		+inline
+
+ +

Determines if the load identifier loadId exists.

+
Parameters
+ + +
[in]loadIdThe load identifier.
+
+
+
Returns
true if the load identifier exists, false otherwise.
+ +

Definition at line 1328 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasLoadAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasLoadAt (TVertex const & vertex) const
+ 		+inline
+
+ +

Determines if it has loads at the vertex $\vertex\in\vertices$.

+
Parameters
+ + +
vertexThe vertex $\vertex\in\vertices$.
+
+
+
Returns
true if there are loads at the vertex, false otherwise.
+ +

Definition at line 1379 of file PowerGrid.hpp.

+ +
+
+ +

◆ HasLoadAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::HasLoadAt (Types::vertexId vertexId) const
+ 		+inline
+
+ +

Determines if there is a load at vertex with vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
true if the load identifier exists, false otherwise.
+ +

Definition at line 1359 of file PowerGrid.hpp.

+ +
+
+ +

◆ IsBounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsBounded () const
+ 		+inline
+
+ +

Determines if bounded.

+
Returns
true if bounded, false otherwise.
+ +

Definition at line 326 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ IsExact()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsExact () const
+ 		+inline
+
+ +

Determines if exact.

+
Returns
true if exact, false otherwise.
+ +

Definition at line 362 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ IsPureUnbounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsPureUnbounded () const
+ 		+inline
+
+ +

Determines if pure unbounded.

+
Returns
true if pure unbounded, false otherwise.
+ +

Definition at line 348 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ IsUnbounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
bool egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsUnbounded () const
+ 		+inline
+
+ +

Determines if unbounded.

+
Returns
true if unbounded, false otherwise.
+ +

Definition at line 337 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ LoadAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
TLoadProperties & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadAt (Types::loadId loadId)
+ 		+inline
+
+ +

Load at load's identifier loadId.

+
Parameters
+ + +
[in]loadIdThe load identifier.
+
+
+
Returns
The load properties.
+ +

Definition at line 1466 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
TLoadProperties const & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadAt (Types::loadId loadId) const
+ 		+inline
+
+ +

Load at load's identifier loadId.

+
Parameters
+ + +
[in]loadIdThe load identifier.
+
+
+
Returns
The load properties.
+ +

Definition at line 1479 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadBoundType() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Vertices::BoundType & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadBoundType ()
+ 		+inline
+
+ +

Setter for the load bound type.

+
Precondition
The default value is unknown.
+
Returns
The load vertex bound type.
+ +

Definition at line 188 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ LoadBoundType() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Vertices::BoundType const & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadBoundType () const
+ 		+inline
+
+ +

Getter for the load bound type.

+
Precondition
The default value is unknown.
+
Returns
The load vertex bound type.
+ +

Definition at line 177 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ LoadId()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
Types::loadId egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadId (TLoadProperties const & load) const
+ 		+inline
+
+ +

The load identifier of a load object.

+
Parameters
+ + +
[in]loadThe load object.
+
+
+
Returns
If the load object exists it returns the unique identifier of a load object, otherwise it returns Const::NONE.
+ +

Definition at line 1394 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadIds() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadIds (TVertex const & vertex,
std::vector< Types::loadId > & loadIds 
) const
+ 		+inline
+
+ +

Loads identifiers at a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in/out]loadIds The load identifiers.
+
+
+ +

Definition at line 1441 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadIds() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadIds (Types::vertexId vertexId,
std::vector< Types::loadId > & loadIds 
) const
+ 		+inline
+
+ +

Loads identifiers.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
A set of load identifiers.
+ +

Definition at line 1413 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadsAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadsAt (TVertex const & vertex,
std::vector< TLoadProperties > & loads 
) const
+ 		+inline
+
+ +

The loads at a vertex object.

+
Parameters
+ + + +
vertexThe vertex object.
loadsThe loads.
+
+
+ +

Definition at line 1513 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadsAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadsAt (Types::vertexId vertexId,
std::vector< TLoadProperties > & loads 
) const
+ 		+inline
+
+ +

The loads at a vertex with identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
loadsThe loads.
+
+
+ +

Definition at line 1491 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotOf() [1/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotOf (Types::loadId loadId,
Types::index timestampPosition 
)
+ 		+inline
+
+ +

The load value of the load at loadId for the timestamp at timestampPosition.

+
Parameters
+ + + +
[in]loadIdThe load identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The load value at loadId for the timestamp at timestampPosition.
+ +

Definition at line 2215 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotOf() [2/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotOf (Types::loadId loadId,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

The load value of the load at loadId for the timestamp at timestampPosition.

+
Parameters
+ + + +
[in]loadIdThe load identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The load value at loadId for the timestamp at timestampPosition.
+ +

Definition at line 2244 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotOf() [3/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotOf (Types::loadId loadId,
Types::timestampSnapshot timestamp 
)
+ 		+inline
+
+ +

Load snapshot at a timestamp.

+

Some loads might not have snapshots over time. In this case this method returns Const::NONE as load value.

+
Parameters
+ + +
[in]timestampThe timestamp.
+
+
+
Returns
The load at the timestamp.
+ +

Definition at line 2174 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotOf() [4/4]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::loadSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotOf (Types::loadId loadId,
Types::timestampSnapshot timestamp 
) const
+ 		+inline
+
+ +

Load snapshot at a timestamp.

+

Some loads might not have snapshots over time. In this case this method returns Const::NONE as load value.

+
Parameters
+ + +
[in]timestampThe timestamp.
+
+
+
Returns
The load at the timestamp.
+ +

Definition at line 2194 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotsAt() [1/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotsAt (TVertex const & vertex,
Types::index timestampPosition,
std::vector< Types::loadSnapshot > & loadSnapshots 
)
+ 		+inline
+
+ +

Loads a snapshot at a vertex and a timestampPosition.

+
Parameters
+ + + + +
[in]vertexThe vertex.
[in]timestampPositionThe timestamp position.
loadSnapshotsThe load snapshots (load snapshots are added to the back, if no loads are at a vertex input and output are the same).
+
+
+ +

Definition at line 2301 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotsAt() [2/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotsAt (Types::timestampSnapshot timestamp,
std::vector< Types::loadSnapshot > & loadSnapshotsAtTimestamp 
)
+ 		+inline
+
+ +

Loads a snapshot at a certain timestamp.

+

Some loads might not have snapshots over time. In this case this method returns a vector with Const::NONE at these generators.

+
Parameters
+ + + +
[in]timestampThe timestamp.
loadSnapshotsAtTimestampThe load snapshots at the timestamp.
+
+
+ +

Definition at line 2322 of file PowerGrid.hpp.

+ +
+
+ +

◆ LoadSnapshotsAt() [3/3]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::LoadSnapshotsAt (Types::vertexId vertexId,
Types::index timestampPosition,
std::vector< Types::loadSnapshot > & loadSnapshots 
)
+ 		+inline
+
+ +

Loads a snapshot at a vertex with vertexId and a timestampPosition.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier
[in]timestampPositionThe timestamp position
loadSnapshotsThe load snapshots (load snapshots are added to the back, if no loads are at a vertex input and output are the same).
+
+
+ +

Definition at line 2273 of file PowerGrid.hpp.

+ +
+
+ +

◆ MakeBounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::MakeBounded ()
+ 		+inline
+
+ +

Makes the power grid bounded.

+

A network is bounded if the demands/loads and the generators are bounded by their minimum and maximum possible generation. (see https://doi.org/10.1145/3208903.3208910 Page 343 Equations 11 and 12 for the definition)

+

+\[ + -\maxdemand\leq\netflow(\vertexa)\leq-\mindemand\qquad\forall\vertexa\in\consumers + \] +

+

+\[ + \maxexcess\leq\netflow(\vertexa)\leq \minexcess\qquad\forall\vertexa\in\generators + \] +

+
Precondition
All loads are set to bounded and all generators to bounded.
+
Note
Note that since the data does not provide a proper load lower bound we use maxbound and thus, set the lower bound to zero.
+ +

Definition at line 219 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ MakeExact()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::MakeExact ()
+ 		+inline
+
+ +

Makes the power grid exact bounded.

+

This is especially useful when running the ordinary power flow (PF) program as PF just checks if the generator and load values produce feasible power flow.

+

A network has exact bounds if the following holds

+\[ + -\demand(\vertexa)\leq\netflow(\vertexa)\leq -\demand(\vertexa)\qquad\forall\vertexa\in\consumers, + \] +

+

+\[ + \excess(\vertexa)\leq\netflow(\vertexa)\leq\excess(\vertexa)\qquad\forall\vertexa\in\generators, + \] +

+

where the netflow is defined by $\netflow:=\sum_{ \{ \vertexa,\vertexb \} \in \undirectededges } \flow ( \vertexa,\vertexb ) $, and the set of generators and and consumers is denoted by $\generators$ and $\consumers$, respectively.

+
Precondition
All loads are set to exact and all generators to exact.
+ +

Definition at line 315 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ MakePureUnbounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::MakePureUnbounded ()
+ 		+inline
+
+ +

Makes the power grid pure unbounded.

+

A network is pure unbounded if the demands/loads and the generators are unbounded. This means that the minimum and maximum are 0 and infinity, respectively (see https://doi.org/10.1145/3208903.3208910 Page 342 Equations 2 and 3 for the definition).

+

+\[ + -\infty\leq\netflow(\vertexa)\leq 0\qquad\forall\vertexa\in\consumers + \] +

+

+\[ + 0\leq\netflow(\vertexa)\leq\infty\qquad\forall\vertexa\in\generators + \] +

+
Note
Note that unbounded generators get bounded demands as defined in https://doi.org/10.1145/3208903.3208910 Page 348 Section 7. Note that pure unbounded focuses on the demands only.
+
Precondition
All loads are set to pureunbounded and all generators to unbounded.
+
See also
Vertices::BoundType
+ +

Definition at line 285 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ MakeUnbounded()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::MakeUnbounded ()
+ 		+inline
+
+ +

Makes the power grid unbounded.

+

A network is unbounded if the demands/loads and the generators are unbounded. This means that the minimum and maximum are 0 and infinity, respectively. (see https://doi.org/10.1145/3208903.3208910 Page 342 Equations 2 and 3 for the definition)

+

+\[ + -\infty\leq\netflow(\vertexa)\leq 0\qquad\forall\vertexa\in\consumers + \] +

+

+\[ + 0\leq\netflow(\vertexa)\leq\infty\qquad\forall\vertexa\in\generators + \] +

+
Precondition
All loads are set to unbounded and all generators to unbounded.
+ +

Definition at line 247 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_, and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_.

+ +
+
+ +

◆ NetworkBoundType()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Vertices::BoundType egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NetworkBoundType () const
+ 		+inline
+
+ +

Get the current network bound type.

+
Returns
The network bound type.
+ +

Definition at line 373 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsBounded(), egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsExact(), egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsPureUnbounded(), and egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::IsUnbounded().

+ +
+
+ +

◆ NetworkType()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::name egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NetworkType () const
+ 		+inline
+
+ +

Get the current network bound type.

+
Returns
The network bound type string.
+ +

Definition at line 387 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NetworkBoundType().

+ +
+
+ +

◆ NumberOfGenerators()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NumberOfGenerators () const
+ 		+inline
+
+ +

Definition at line 4298 of file PowerGrid.hpp.

+ +
+
+ +

◆ NumberOfLoads()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NumberOfLoads () const
+ 		+inline
+
+ +

Definition at line 4303 of file PowerGrid.hpp.

+ +
+
+ +

◆ NumberOfTimestamps()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::NumberOfTimestamps () const
+ 		+inline
+
+ +

Definition at line 4308 of file PowerGrid.hpp.

+ +
+
+ +

◆ OutputGeneratorSnaps()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::OutputGeneratorSnaps ()
+ 		+inline
+
+ +

Output generation snapshots.

+ +

Definition at line 1771 of file PowerGrid.hpp.

+ +
+
+ +

◆ OutputLoadSnaps()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::OutputLoadSnaps ()
+ 		+inline
+
+ +

Output load snapshots.

+ +

Definition at line 1796 of file PowerGrid.hpp.

+ +
+
+ +

◆ PositionOf()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
Types::index egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::PositionOf (Types::timestampSnapshot timestamp) const
+ 		+inline
+
+ +

Position of a timestamp.

+
Parameters
+ + +
[in]timestampThe timestamp.
+
+
+
Returns
The position of a timestamp.
+
Note
Implementation is very inefficient.
+ +

Definition at line 1871 of file PowerGrid.hpp.

+ +
+
+ +

◆ RealPowerLoadAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RealPowerLoadAt (TVertex const & vertex,
Types::index snapshotId = 0 
) const
+ 		+inline
+
+ +

Total real power load for a certain snapshot (timestamp) at a vertex.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]snapshotIdThe snapshot position.
+
+
+
Returns
The total real power load at a vertex for a timestamp.
+ +

Definition at line 1571 of file PowerGrid.hpp.

+ +
+
+ +

◆ RealPowerLoadAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RealPowerLoadAt (Types::vertexId vertexId,
Types::index snapshotId = 0 
) const
+ 		+inline
+
+ +

Total real power load for a certain snapshot (timestamp) at a vertex.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]snapshotIdThe snapshot position.
+
+
+
Returns
The total real power load at a vertex for a timestamp.
+ +

Definition at line 1544 of file PowerGrid.hpp.

+ +
+
+ +

◆ RemoveGeneratorAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RemoveGeneratorAt (Types::vertexId vertexId,
TGeneratorProperties & generatorProperty 
)
+ 		+inline
+
+ +

Removes a generator $g\in\generators$ at a vertex $\vertex\in\vertices$ with identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 620 of file PowerGrid.hpp.

+ +
+
+ +

◆ RemoveGeneratorAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RemoveGeneratorAt (Types::vertexId vertexId,
Types::generatorId generatorId 
)
+ 		+inline
+
+ +

Removes a generator with generatorId at a vertex with identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]generatorIdThe generator identifier.
+
+
+ +

Definition at line 574 of file PowerGrid.hpp.

+ +
+
+ +

◆ RemoveLoadAt() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RemoveLoadAt (Types::vertexId vertexId,
TLoadProperties & load 
)
+ 		+inline
+
+ +

Removes a load at a vertex $\vertex\in\vertices$ with identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
loadThe load object.
+
+
+ +

Definition at line 1299 of file PowerGrid.hpp.

+ +
+
+ +

◆ RemoveLoadAt() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::RemoveLoadAt (Types::vertexId vertexId,
Types::loadId loadId 
)
+ 		+inline
+
+ +

Removes a load at a vertex $\vertex\in\vertices$ with identifier vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
loadIdThe load identifier.
+
+
+ +

Definition at line 1254 of file PowerGrid.hpp.

+ +
+
+ +

◆ ThetaBound() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
TBound & egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::ThetaBound ()
+ 		+inline
+
+ +

Setter for the voltage angle bound.

+
Returns
The voltage angle bound.
+ +

Definition at line 139 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::thetaBound_.

+ +
+
+ +

◆ ThetaBound() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::ThetaBound () const
+ 		+inline
+
+ +

Getter for the voltage angle bound.

+
Returns
The voltage angle bound.
+ +

Definition at line 129 of file PowerGrid.hpp.

+ +

References egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::thetaBound_.

+ +
+
+ +

◆ TimestampAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
Types::timestampSnapshot egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TimestampAt (Types::index timestampPosition) const
+ 		+inline
+
+ +

Timestamp at position.

+
Parameters
+ + +
[in]timestampThe timestamp.
+
+
+
Returns
The timestamp at the position.
+ +

Definition at line 1891 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalReactivePowerGenerationAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<Vertices::GenerationStrategyDifferentiationType Strategy>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalReactivePowerGenerationAt (Types::vertexId vertexId,
Types::index timestampPosition = 0 
) const
+ 		+inline
+
+ +

The total reactive power generation $\reactivepowergeneration$ of all generator snapshots for one timestamp at vertex $\vertex\in\vertices$ with identifier vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex $\vertex\in\vertices$ with identifier vertexId.
+
+
+
Note
The total reactive power generation $\reactivepowergeneration$ only includes the snapshots of active generators. In addition, if the vertex $\vertex\in\vertices$ has no generators the return value is 0.
+
Returns
The total reactive power generation $\reactivepowergeneration$ of all generatorsnapshots at a vertex $\vertex\in\vertices$ with identifier vertexId.
+
Todo:
Use the same logic as in Real Power using snapshot -> GeneratorRealPowerSnapshotAt( generator, timestampPosition );
+ +

Definition at line 1155 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalReactivePowerGenerationBoundAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<Vertices::GenerationStrategyDifferentiationType Strategy>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalReactivePowerGenerationBoundAt (Types::vertexId vertexId,
Types::index timestampPosition = 0 
) const
+ 		+inline
+
+ +

The total reactive power generation bound.

+

Returns the minimum and maximum of all generators $[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ at the vertex vertexId. This depends also on if the power grid is set to (1) exact, (2) bounded, or (3) unbounded/pureunbounded.

+

(1) Uses the sum of the generators reactive power generation ( $\reactivepowergeneration$) snapshot,

+

(2) Uses the sum of the minimum ( $\reactivepowergenerationmin$) and the sum of the maximum ( $\reactivepowergenerationmax$) reactive power generation of the data,

+

(3) Uses 0 and infinity for the minimum and maximum, respectively.

+
Parameters
+ + +
[in]vertexIdThe vertex $\vertex\in\vertices$ with identifier vertexId.
+
+
+
Returns
The total reactive power generation bound—meaning minimum and maximum—at vertex identifier vertexId.
+ +

Definition at line 1095 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalReactivePowerLoadBoundAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalReactivePowerLoadBoundAt (Types::vertexId vertexId) const
+ 		+inline
+
+ +

Total reactive power load bound at a vertex.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The reactive power load bound at a vertex vertexId.
+ +

Definition at line 1690 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalRealPowerGenerationAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<Vertices::GenerationStrategyDifferentiationType Strategy>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalRealPowerGenerationAt (Types::vertexId vertexId,
Types::index timestampPosition = 0 
) const
+ 		+inline
+
+ +

The total real power generation $\realpowergeneration$ at a vertex $\vertex\in\vertices$ with vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex $\vertex$ with vertexId.
+
+
+
Note
The total real power generation $\realpowergeneration$ only includes the snapshots of active generators. In addition, if the vertex $\vertex\in\vertices$ has no generators the return value is 0.
+
Returns
The total real power generation $\realpowergeneration$ of all generator snapshots at a vertex $\vertex$ with vertexId.
+ +

Definition at line 1054 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalRealPowerGenerationBoundAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+
+template<Vertices::GenerationStrategyDifferentiationType Strategy>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalRealPowerGenerationBoundAt (Types::vertexId vertexId,
Types::index timestampPosition = 0 
) const
+ 		+inline
+
+ +

The total real power generation bound of all generators at a vertex.

+

Returns the minimum and maximum of all generators at the vertex index. This depends also on if the power grid is set to (1) exact, (2) bounded, or (3) unbounded/pureunbounded.

+

(1) Uses the sum of the generators real power generation (pg) snapshot,

+

(2) Uses the sum of the minimum ( $\realpowergenerationmin$) and the sum of the maximum ( $\realpowergenerationmax$) real power generation of the data,

+

(3) Uses 0 and infinity for the minimum and maximum, respectively.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Precondition
The timestamp position is used for Vertices::BoundType::exact only.
+
Returns
The total real power generation bound—meaning minimum and maximum—at the vertex. If the vertex has no generator the minimum and maximum generation are set to 0. If all maximum values are Const::REAL_INFTY for Vertices::BoundType::bounded the return value might become std::numeric_limits<double>::infinity(), which is in fact a very large number.
+ +

Definition at line 995 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalRealPowerLoadAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalRealPowerLoadAt (Types::vertexId vertexId,
Types::index timestampPosition 
) const
+ 		+inline
+
+ +

The total real power load at a vertex with id vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
The total real power load at the vertex with id vertexId.
+ +

Definition at line 1659 of file PowerGrid.hpp.

+ +
+
+ +

◆ TotalRealPowerLoadBoundAt()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalRealPowerLoadBoundAt (Types::vertexId vertexId,
Types::index timestamp = 0 
) const
+ 		+inline
+
+ +

Total real power load bound at vertex vertexId.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]timestampThe time stamp.
+
+
+
Note
The time stamp is only used when the type is set to exact.
+
Returns
The real power load bound at a vertex vertexId.
+ +

Definition at line 1589 of file PowerGrid.hpp.

+ +
+
+ +

◆ UpdateGeneratorSnapshotSize()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::UpdateGeneratorSnapshotSize ()
+ 		+inline
+
+ +

Update generator snapshot size.

+

There can be more generators than buses.

+ +

Definition at line 1754 of file PowerGrid.hpp.

+ +
+
+ +

◆ UpdateLoadSnapshotSize()

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + +
void egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::UpdateLoadSnapshotSize ()
+ 		+inline
+
+ +

Update load snapshot.

+

Currently we assume that there is one load per bus

+ +

Definition at line 1763 of file PowerGrid.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
PowerGrid< TGraph > const & rhs 
)
+ 		+friend
+
+ +

Output.

+
Parameters
+ + + +
osThe operating system
[in]rhsThe right hand side
+
+
+
Returns
Output stream
+ +

Definition at line 407 of file PowerGrid.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ baseMva_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Types::real egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::baseMva_
+ 		+private
+
+

Base MVA for the power grid used for the p.u. system, e.g., 100 MW

+ +

Definition at line 4320 of file PowerGrid.hpp.

+ +
+
+ +

◆ generatorBoundType_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Vertices::BoundType egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorBoundType_
+ 		+private
+
+

The generator bound type.

+ +

Definition at line 4340 of file PowerGrid.hpp.

+ +
+
+ +

◆ generatorExists_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< bool > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorExists_
+ 		+private
+
+

Vector that describes which generator vertices exist

+ +

Definition at line 4329 of file PowerGrid.hpp.

+ +
+
+ +

◆ generatorRealPowerSnapshots_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< std::vector<Types::generatorSnapshot> > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorRealPowerSnapshots_
+ 		+private
+
+

Generator snapshots

+ +

Definition at line 4335 of file PowerGrid.hpp.

+ +
+
+ +

◆ generators_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< TGeneratorProperties > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generators_
+ 		+private
+
+

Vector of generator vertices

+ +

Definition at line 4328 of file PowerGrid.hpp.

+ +
+
+ +

◆ generatorsAtVertex_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< std::vector<Types::vertexId> > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::generatorsAtVertex_
+ 		+private
+
+

Mapping generator to a vertex

+ +

Definition at line 4327 of file PowerGrid.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
TGraph egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::graph_
+ 		+private
+
+

The graph.

+ +

Definition at line 4343 of file PowerGrid.hpp.

+ +
+
+ +

◆ loadBoundType_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Vertices::BoundType egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadBoundType_
+ 		+private
+
+

The load bound type.

+ +

Definition at line 4341 of file PowerGrid.hpp.

+ +
+
+ +

◆ loadExists_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< bool > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadExists_
+ 		+private
+
+

Vector that describes which load vertices exist

+ +

Definition at line 4333 of file PowerGrid.hpp.

+ +
+
+ +

◆ loads_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< TLoadProperties > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loads_
+ 		+private
+
+

Vector of load vertices

+ +

Definition at line 4332 of file PowerGrid.hpp.

+ +
+
+ +

◆ loadsAtVertex_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< std::vector<Types::vertexId> > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadsAtVertex_
+ 		+private
+
+ +

Definition at line 4331 of file PowerGrid.hpp.

+ +
+
+ +

◆ loadSnapshots_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< std::vector<Types::loadSnapshot> > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::loadSnapshots_
+ 		+private
+
+

Load snapshots

+ +

Definition at line 4336 of file PowerGrid.hpp.

+ +
+
+ +

◆ numberOfGenerators_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::numberOfGenerators_
+ 		+private
+
+

Number of generators in the power grid

+ +

Definition at line 4324 of file PowerGrid.hpp.

+ +
+
+ +

◆ numberOfLoads_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::numberOfLoads_
+ 		+private
+
+

Number of loads in the power grid

+ +

Definition at line 4325 of file PowerGrid.hpp.

+ +
+
+ +

◆ snapshotWeights_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< Types::weightSnapshot > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::snapshotWeights_
+ 		+private
+
+

Weights for each snapshot

+ +

Definition at line 4338 of file PowerGrid.hpp.

+ +
+
+ +

◆ thetaBound_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
TBound egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::thetaBound_
+ 		+private
+
+

Theta bound used to calculate the big M value

+ +

Definition at line 4321 of file PowerGrid.hpp.

+ +
+
+ +

◆ timestamps_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
std::vector< Types::timestampSnapshot > egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::timestamps_
+ 		+private
+
+

Timestamps of the snapshots

+ +

Definition at line 4337 of file PowerGrid.hpp.

+ +
+
+ +

◆ verticesWithGeneratorCount_

+ +
+
+
+template<typename GraphType = StaticGraph < Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties>, typename GeneratorProperty = Vertices::GeneratorProperties<Vertices::IeeeBusType>, typename LoadProperty = Vertices::LoadProperties<Vertices::IeeeBusType>>
+ + + + + +
+ + + + +
Types::count egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::verticesWithGeneratorCount_
+ 		+private
+
+

Number of vertices having generators

+ +

Definition at line 4323 of file PowerGrid.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_power_grid_i_o-members.html b/classegoa_1_1_power_grid_i_o-members.html new file mode 100644 index 00000000..3a2ff6e1 --- /dev/null +++ b/classegoa_1_1_power_grid_i_o-members.html @@ -0,0 +1,122 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::PowerGridIO< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::PowerGridIO< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
fileReaders (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >static
fileWriters (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >static
indentChar_egoa::PowerGridIO< GraphType >privatestatic
indentWidth_egoa::PowerGridIO< GraphType >privatestatic
read(PowerGrid< GraphType > &network, std::istream &input_stream)egoa::PowerGridIO< GraphType >inlinestatic
read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)egoa::PowerGridIO< GraphType >inlinestatic
read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStreamBased reader=PowerGridIO< GraphType >::read)egoa::PowerGridIO< GraphType >inlinestatic
read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStringBased reader=PowerGridIO< GraphType >::read)egoa::PowerGridIO< GraphType >inlinestatic
read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename, ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader=PowerGridIO< GraphType >::read)egoa::PowerGridIO< GraphType >inlinestatic
ReaderFunctionStreamBased typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >
ReaderFunctionStreamBasedPowerGridAndCandidateNetwork typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >
ReaderFunctionStringBased typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >
ReadGraphGml(PowerGrid< GraphType > &network, std::istream &input_stream)egoa::PowerGridIO< GraphType >inlinestatic
readIeeeCdfMatlab(PowerGrid< GraphType > &network, std::istream &input_stream)egoa::PowerGridIO< GraphType >inlinestatic
ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)egoa::PowerGridIO< GraphType >inlinestatic
ReadPyPsa(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)egoa::PowerGridIO< GraphType >inlinestatic
streamReaders (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >static
streamReadersPowerGridAndCandidateNetwork (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >static
streamWriters (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >static
Stroke2DotStyle(Stroke::Name const &stroke)egoa::PowerGridIO< GraphType >inlinestatic
TElectricalEdge typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >private
TElectricalVertex typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >private
TGraph typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >private
write(PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)egoa::PowerGridIO< GraphType >inlinestatic
write(PowerGrid< GraphType > const &network, std::string const &filename, WriterFunctionStreamBasedtionStringBased writer=PowerGridIO< GraphType >::write)egoa::PowerGridIO< GraphType >inlinestatic
WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)egoa::PowerGridIO< GraphType >inlinestatic
WriteGeoJson(PowerGrid< GraphType > const &network, std::ostream &outputStream)egoa::PowerGridIO< GraphType >inlinestatic
WriteGraphDot(PowerGrid< GraphType > const &network, std::ostream &outputStream)egoa::PowerGridIO< GraphType >inlinestatic
WriteGraphDot(PowerGrid< GraphType > const &network, std::string const &filename) (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >inlinestatic
WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)egoa::PowerGridIO< GraphType >inlinestatic
WriteGraphGml(PowerGrid< GraphType > const &network, std::string const &filename)egoa::PowerGridIO< GraphType >inlinestatic
writeIeeeCdfMatlab(PowerGrid< GraphType > const &network, std::ostream &output_stream)egoa::PowerGridIO< GraphType >inlinestatic
WriterFunctionStreamBased typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >
WriterFunctionStreamBasedtionStringBased typedef (defined in egoa::PowerGridIO< GraphType >)egoa::PowerGridIO< GraphType >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_power_grid_i_o.html b/classegoa_1_1_power_grid_i_o.html new file mode 100644 index 00000000..00406ed4 --- /dev/null +++ b/classegoa_1_1_power_grid_i_o.html @@ -0,0 +1,1637 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::PowerGridIO< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +Static Private Attributes | +List of all members
+
egoa::PowerGridIO< GraphType > Class Template Reference
+
+
+ +

Class for power grid io. + More...

+ +

#include <PowerGridIO.hpp>

+ + + + + + + + + + + + + + +

+Public Types

Reader function pointer
using ReaderFunctionStreamBased = bool(*)(PowerGrid< GraphType > &, std::istream &)
 
using ReaderFunctionStringBased = bool(*)(PowerGrid< GraphType > &, std::string const &)
 
using ReaderFunctionStreamBasedPowerGridAndCandidateNetwork = bool(*)(PowerGrid< GraphType > &, GraphType &, std::string const &)
 
Writer function pointer
using WriterFunctionStreamBased = bool(*)(PowerGrid< GraphType > const &, std::ostream &)
 
using WriterFunctionStreamBasedtionStringBased = bool(*)(PowerGrid< GraphType > const &, std::string const &)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

General reader
static bool read (PowerGrid< GraphType > &network, std::istream &input_stream)
 Function to read a power grid.
 
static bool read (PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)
 Function to read a power grid.
 
static bool read (PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStreamBased reader=PowerGridIO< GraphType >::read)
 Function to read a power grid.
 
static bool read (PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStringBased reader=PowerGridIO< GraphType >::read)
 Function to read a power grid.
 
static bool read (PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename, ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader=PowerGridIO< GraphType >::read)
 Function to read a power grid.
 
General writer
static bool write (PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)
 Function to write a power grid.
 
static bool write (PowerGrid< GraphType > const &network, std::string const &filename, WriterFunctionStreamBasedtionStringBased writer=PowerGridIO< GraphType >::write)
 Function to write a power grid.
 
IEEE CDF MATLAB DATA
static bool readIeeeCdfMatlab (PowerGrid< GraphType > &network, std::istream &input_stream)
 Reads an IEEE CDF Matlab file.
 
static bool writeIeeeCdfMatlab (PowerGrid< GraphType > const &network, std::ostream &output_stream)
 Writes an IEEE CDF Matlab file.
 
PYPSA DATA
static bool ReadPyPsa (PowerGrid< GraphType > &network, std::string const &filename)
 Reads a PyPsa file.
 
static bool ReadPyPsa (PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)
 Reads a PyPsa file.
 
GeoJson

For more information on GeoJson see GeoJson and RFC7946.

+
static bool WriteGeoJson (PowerGrid< GraphType > const &network, std::string const &filename)
 Write the network into a GeoJson format.
 
static bool WriteGeoJson (PowerGrid< GraphType > const &network, std::ostream &outputStream)
 Write the network into a GeoJson format.
 
Graph modeling language (GML)

For more information on GML see GML.

+
static bool ReadGraphGml (PowerGrid< GraphType > &network, std::istream &input_stream)
 Reads a graph from a gml file.
 
static bool WriteGraphGml (PowerGrid< GraphType > const &network, std::ostream &output_stream)
 Writes a graph into a gml file.
 
static bool WriteGraphGml (PowerGrid< GraphType > const &network, std::string const &filename)
 Writes a graph into a gml file.
 
Graph DOT
static bool WriteGraphDot (PowerGrid< GraphType > const &network, std::ostream &outputStream)
 Writes a graph dot.
 
static bool WriteGraphDot (PowerGrid< GraphType > const &network, std::string const &filename)
 
static std::string Stroke2DotStyle (Stroke::Name const &stroke)
 Convert a stroke into a dot style stroke.
 
+ + + + + + + + + + + + + +

+Static Public Attributes

Vector of reader function pointers
static std::vector< ReaderFunctionStreamBased > const streamReaders
 
static std::vector< ReaderFunctionStringBased > const fileReaders
 
static std::vector< ReaderFunctionStreamBasedPowerGridAndCandidateNetwork > const streamReadersPowerGridAndCandidateNetwork
 
Vector of writer function pointers
static std::vector< WriterFunctionStreamBased > const streamWriters
 
static std::vector< WriterFunctionStreamBasedtionStringBased > const fileWriters
 
+ + + + + + + +

+Private Types

using TGraph = GraphType
 
using TElectricalVertex = typename TGraph::TVertex
 
using TElectricalEdge = typename TGraph::TEdge
 
+ + + + + +

+Static Private Attributes

static char indentChar_
 
static int indentWidth_
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::PowerGridIO< GraphType >

Class for power grid io.

+
Template Parameters
+ + +
GraphTypeThe graph $\graph = (\vertices, \edges)$.
+
+
+ +

Definition at line 33 of file PowerGridIO.hpp.

+

Member Typedef Documentation

+ +

◆ ReaderFunctionStreamBased

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::PowerGridIO< GraphType >::ReaderFunctionStreamBased = bool (*)( PowerGrid< GraphType> & , std::istream & )
+
+ +

Definition at line 46 of file PowerGridIO.hpp.

+ +
+
+ +

◆ ReaderFunctionStreamBasedPowerGridAndCandidateNetwork

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::PowerGridIO< GraphType >::ReaderFunctionStreamBasedPowerGridAndCandidateNetwork = bool (*)( PowerGrid< GraphType> & , GraphType & , std::string const & )
+
+ +

Definition at line 50 of file PowerGridIO.hpp.

+ +
+
+ +

◆ ReaderFunctionStringBased

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::PowerGridIO< GraphType >::ReaderFunctionStringBased = bool (*)( PowerGrid< GraphType> & , std::string const & )
+
+ +

Definition at line 48 of file PowerGridIO.hpp.

+ +
+
+ +

◆ TElectricalEdge

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::PowerGridIO< GraphType >::TElectricalEdge = typename TGraph::TEdge
+ 		+private
+
+ +

Definition at line 38 of file PowerGridIO.hpp.

+ +
+
+ +

◆ TElectricalVertex

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::PowerGridIO< GraphType >::TElectricalVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 37 of file PowerGridIO.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::PowerGridIO< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 36 of file PowerGridIO.hpp.

+ +
+
+ +

◆ WriterFunctionStreamBased

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::PowerGridIO< GraphType >::WriterFunctionStreamBased = bool (*)( PowerGrid<GraphType> const & , std::ostream & )
+
+ +

Definition at line 58 of file PowerGridIO.hpp.

+ +
+
+ +

◆ WriterFunctionStreamBasedtionStringBased

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::PowerGridIO< GraphType >::WriterFunctionStreamBasedtionStringBased = bool (*)( PowerGrid<GraphType> const & , std::string const & )
+
+ +

Definition at line 60 of file PowerGridIO.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ read() [1/5]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::read (PowerGrid< GraphType > & network,
GraphType & candidateNetwork,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Function to read a power grid.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
candidateNetworkThe candidate network $\network $.
filenameThe filename from which the data is read.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 119 of file PowerGridIO.hpp.

+ +
+
+ +

◆ read() [2/5]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::read (PowerGrid< GraphType > & network,
GraphType & candidateNetwork,
std::string const & filename,
ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader = PowerGridIO<GraphType>::read 
)
+ 		+inlinestatic
+
+ +

Function to read a power grid.

+
Parameters
+ + + + + +
networkThe network $\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$.
candidateNetworkThe candidate network $\graph $.
filenameThe filename from which the data is read.
[in]readerThe reader, e.g., ReadPyPsa.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 185 of file PowerGridIO.hpp.

+ +
+
+ +

◆ read() [3/5]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::read (PowerGrid< GraphType > & network,
std::istream & input_stream 
)
+ 		+inlinestatic
+
+ +

Function to read a power grid.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
input_streamThe stream from which the data is read.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 93 of file PowerGridIO.hpp.

+ +
+
+ +

◆ read() [4/5]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::read (PowerGrid< GraphType > & network,
std::string const & filename,
ReaderFunctionStreamBased reader = PowerGridIO<GraphType>::read 
)
+ 		+inlinestatic
+
+ +

Function to read a power grid.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename from which the data is read.
[in]readerThe reader, e.g., ReadPyPsa.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 145 of file PowerGridIO.hpp.

+ +
+
+ +

◆ read() [5/5]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::read (PowerGrid< GraphType > & network,
std::string const & filename,
ReaderFunctionStringBased reader = PowerGridIO<GraphType>::read 
)
+ 		+inlinestatic
+
+ +

Function to read a power grid.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename from which we read the data.
[in]readerThe reader, e.g., ReadPyPsa.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 165 of file PowerGridIO.hpp.

+ +
+
+ +

◆ ReadGraphGml()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::ReadGraphGml (PowerGrid< GraphType > & network,
std::istream & input_stream 
)
+ 		+inlinestatic
+
+ +

Reads a graph from a gml file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
input_streamThe input stream to read data from, e.g., a file.
+
+
+
Returns
@true if the reading was successful, @false otherwise.
+ +

Definition at line 383 of file PowerGridIO.hpp.

+ +
+
+ +

◆ readIeeeCdfMatlab()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::readIeeeCdfMatlab (PowerGrid< GraphType > & network,
std::istream & input_stream 
)
+ 		+inlinestatic
+
+ +

Reads an IEEE CDF Matlab file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
input_streamThe input stream to read data from, e.g., a file.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 252 of file PowerGridIO.hpp.

+ +
+
+ +

◆ ReadPyPsa() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::ReadPyPsa (PowerGrid< GraphType > & network,
GraphType & candidateNetwork,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Reads a PyPsa file.

+
Parameters
+ + + + +
networkThe network $\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$.
candidateNetworkThe candidate network $\network $.
filenameThe filename
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 313 of file PowerGridIO.hpp.

+ +

References egoa::PyPsaParser< GraphType >::read().

+ +
+
+ +

◆ ReadPyPsa() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::ReadPyPsa (PowerGrid< GraphType > & network,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Reads a PyPsa file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 294 of file PowerGridIO.hpp.

+ +

References egoa::PyPsaParser< GraphType >::read().

+ +
+
+ +

◆ Stroke2DotStyle()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
static std::string egoa::PowerGridIO< GraphType >::Stroke2DotStyle (Stroke::Name const & stroke)
+ 		+inlinestatic
+
+ +

Convert a stroke into a dot style stroke.

+
Parameters
+ + +
strokeThe stroke.
+
+
+
Returns
The dot style stroke.
+ +

Definition at line 721 of file PowerGridIO.hpp.

+ +
+
+ +

◆ write() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::write (PowerGrid< GraphType > const & network,
std::ostream & outputStream,
WriterFunctionStreamBased writer = PowerGridIO<GraphType>::write 
)
+ 		+inlinestatic
+
+ +

Function to write a power grid.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename to which the data is written.
[in]writerThe writer.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 210 of file PowerGridIO.hpp.

+ +
+
+ +

◆ write() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::write (PowerGrid< GraphType > const & network,
std::string const & filename,
WriterFunctionStreamBasedtionStringBased writer = PowerGridIO<GraphType>::write 
)
+ 		+inlinestatic
+
+ +

Function to write a power grid.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename
[in]writerThe writer, e.g., WriteGeoJson.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 229 of file PowerGridIO.hpp.

+ +
+
+ +

◆ WriteGeoJson() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGeoJson (PowerGrid< GraphType > const & network,
std::ostream & outputStream 
)
+ 		+inlinestatic
+
+ +

Write the network into a GeoJson format.

+
Parameters
+ + + +
networkThe network $\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$.
outputStreamThe stream to which the data is written.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 358 of file PowerGridIO.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::write().

+ +
+
+ +

◆ WriteGeoJson() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGeoJson (PowerGrid< GraphType > const & network,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Write the network into a GeoJson format.

+
Parameters
+ + + +
networkThe network $\network = ( + \graph, \generators, \consumers, \capacity, \susceptance, + \dots )$.
filenameThe file to which the data is written.
+
+
+
Returns
true if the reading was successful, false otherwise.
+ +

Definition at line 340 of file PowerGridIO.hpp.

+ +

References egoa::IO::GeoJsonWriter< GraphType >::write().

+ +
+
+ +

◆ WriteGraphDot() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGraphDot (PowerGrid< GraphType > const & network,
std::ostream & outputStream 
)
+ 		+inlinestatic
+
+ +

Writes a graph dot.

+
Parameters
+ + + +
networkThe network
outputStreamThe stream to write data to
+
+
+
Returns
@true if the writing was successful, @false otherwise.
+
Todo:
Improve and put in its own file.
+ +

Definition at line 631 of file PowerGridIO.hpp.

+ +

References egoa::PowerGridIO< GraphType >::Stroke2DotStyle().

+ +
+
+ +

◆ WriteGraphDot() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGraphDot (PowerGrid< GraphType > const & network,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Definition at line 672 of file PowerGridIO.hpp.

+ +
+
+ +

◆ WriteGraphGml() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGraphGml (PowerGrid< GraphType > const & network,
std::ostream & output_stream 
)
+ 		+inlinestatic
+
+ +

Writes a graph into a gml file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
output_streamThe output stream to write data to, e.g., a file.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 402 of file PowerGridIO.hpp.

+ +
+
+ +

◆ WriteGraphGml() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::WriteGraphGml (PowerGrid< GraphType > const & network,
std::string const & filename 
)
+ 		+inlinestatic
+
+ +

Writes a graph into a gml file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
filenameThe filename to write the data.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 419 of file PowerGridIO.hpp.

+ +
+
+ +

◆ writeIeeeCdfMatlab()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::PowerGridIO< GraphType >::writeIeeeCdfMatlab (PowerGrid< GraphType > const & network,
std::ostream & output_stream 
)
+ 		+inlinestatic
+
+ +

Writes an IEEE CDF Matlab file.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
output_streamThe output stream to write data to, e.g., a file.
+
+
+
Returns
true if the writing was successful, false otherwise.
+ +

Definition at line 271 of file PowerGridIO.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ fileReaders

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
const std::vector< typename PowerGridIO< GraphType >::ReaderFunctionStringBased > egoa::PowerGridIO< GraphType >::fileReaders
+ 		+static
+
+Initial value:
= {
+
PowerGridIO<GraphType>::ReadPyPsa
+
+
}
+
egoa::PowerGridIO::ReadPyPsa
static bool ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)
Reads a PyPsa file.
Definition PowerGridIO.hpp:294
+
+

Definition at line 68 of file PowerGridIO.hpp.

+ +
+
+ +

◆ fileWriters

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
const std::vector< typename PowerGridIO< GraphType >::WriterFunctionStreamBasedtionStringBased > egoa::PowerGridIO< GraphType >::fileWriters
+ 		+static
+
+Initial value:
= {
+
PowerGridIO<GraphType>::WriteGraphGml
+
, PowerGridIO<GraphType>::WriteGraphDot
+
, PowerGridIO<GraphType>::WriteGeoJson
+
+
}
+
egoa::PowerGridIO::WriteGraphDot
static bool WriteGraphDot(PowerGrid< GraphType > const &network, std::ostream &outputStream)
Writes a graph dot.
Definition PowerGridIO.hpp:631
+
egoa::PowerGridIO::WriteGraphGml
static bool WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes a graph into a gml file.
Definition PowerGridIO.hpp:402
+
egoa::PowerGridIO::WriteGeoJson
static bool WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)
Write the network into a GeoJson format.
Definition PowerGridIO.hpp:340
+
+

Definition at line 75 of file PowerGridIO.hpp.

+ +
+
+ +

◆ indentChar_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
char egoa::PowerGridIO< GraphType >::indentChar_
+ 		+staticprivate
+
+

Character used for indentation.

+ +

Definition at line 736 of file PowerGridIO.hpp.

+ +
+
+ +

◆ indentWidth_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
int egoa::PowerGridIO< GraphType >::indentWidth_
+ 		+staticprivate
+
+

Number of indent characters used for indentation.

+ +

Definition at line 737 of file PowerGridIO.hpp.

+ +
+
+ +

◆ streamReaders

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
const std::vector< typename PowerGridIO< GraphType >::ReaderFunctionStreamBased > egoa::PowerGridIO< GraphType >::streamReaders
+ 		+static
+
+Initial value:
= {
+
PowerGridIO<GraphType>::readIeeeCdfMatlab
+
+
}
+
egoa::PowerGridIO::readIeeeCdfMatlab
static bool readIeeeCdfMatlab(PowerGrid< GraphType > &network, std::istream &input_stream)
Reads an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:252
+
+

Definition at line 67 of file PowerGridIO.hpp.

+ +
+
+ +

◆ streamReadersPowerGridAndCandidateNetwork

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
const std::vector< typename PowerGridIO< GraphType >::ReaderFunctionStreamBasedPowerGridAndCandidateNetwork > egoa::PowerGridIO< GraphType >::streamReadersPowerGridAndCandidateNetwork
+ 		+static
+
+Initial value:
= {
+
PowerGridIO<GraphType>::ReadPyPsa
+
+
}
+
+

Definition at line 69 of file PowerGridIO.hpp.

+ +
+
+ +

◆ streamWriters

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
const std::vector< typename PowerGridIO< GraphType >::WriterFunctionStreamBased > egoa::PowerGridIO< GraphType >::streamWriters
+ 		+static
+
+Initial value:
= {
+
PowerGridIO<GraphType>::writeIeeeCdfMatlab
+
, PowerGridIO<GraphType>::WriteGraphDot
+
, PowerGridIO<GraphType>::WriteGeoJson
+
+
}
+
egoa::PowerGridIO::writeIeeeCdfMatlab
static bool writeIeeeCdfMatlab(PowerGrid< GraphType > const &network, std::ostream &output_stream)
Writes an IEEE CDF Matlab file.
Definition PowerGridIO.hpp:271
+
+

Definition at line 74 of file PowerGridIO.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_prim-members.html b/classegoa_1_1_prim-members.html new file mode 100644 index 00000000..bea9e615 --- /dev/null +++ b/classegoa_1_1_prim-members.html @@ -0,0 +1,105 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Prim< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::Prim< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
Comparator() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
comparator_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
Graph() const (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
Graph() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlineprotected
graph_egoa::MST< GraphType >private
MST(TGraph &graph, TComparator comparator) (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inline
Prim(TGraph &graph, TComparator comparator) (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >inline
Result() constegoa::MST< GraphType >inline
Run() overrideegoa::Prim< GraphType >inlinevirtual
SetResult(std::vector< Types::edgeId > &&edges)egoa::MST< GraphType >inlineprotected
spanningTree_ (defined in egoa::MST< GraphType >)egoa::MST< GraphType >private
TComparator typedef (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >private
TEdge typedef (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >private
TGraph typedef (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >private
TSpanningTree typedef (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >private
~MST() (defined in egoa::MST< GraphType >)egoa::MST< GraphType >inlinevirtual
~Prim() (defined in egoa::Prim< GraphType >)egoa::Prim< GraphType >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_prim.html b/classegoa_1_1_prim.html new file mode 100644 index 00000000..e59b8d89 --- /dev/null +++ b/classegoa_1_1_prim.html @@ -0,0 +1,386 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Prim< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +List of all members
+
egoa::Prim< GraphType > Class Template Referencefinal
+
+
+ +

An implementation of Prim's algorithm for finding minimum spanning trees. + More...

+ +

#include <Prim.hpp>

+
+Inheritance diagram for egoa::Prim< GraphType >:
+
+
+ + +egoa::MST< GraphType > + +
+ + + + + + + + + + + + + +

+Public Member Functions

 Prim (TGraph &graph, TComparator comparator)
 
virtual void Run () override
 Prim's algorithm @detail Prim's algorithm is quite similar to Dijkstra's algorithm. Prim runs in O(|E| log |V|) using binary heaps. While using Fibonacci heaps the running time is then in O(|E| + |V| log |V|). The latter is an improvement while |V| << |E|.
 
- Public Member Functions inherited from egoa::MST< GraphType >
 MST (TGraph &graph, TComparator comparator)
 
Subgraph< TGraph > const & Result () const
 Returns the caluclated spanning tree after Run() has been called.
 
+ + + + + + + + + +

+Private Types

using TSpanningTree = MST< GraphType >
 
using TGraph = GraphType
 
using TEdge = typename TGraph::TEdge
 
using TComparator = std::function< bool(Types::edgeId, Types::edgeId)>
 
+ + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Types inherited from egoa::MST< GraphType >
using TGraph = GraphType
 
using TEdge = typename TGraph::TEdge
 
using TComparator = std::function< bool(Types::edgeId, Types::edgeId)>
 
- Protected Member Functions inherited from egoa::MST< GraphType >
void SetResult (std::vector< Types::edgeId > &&edges)
 Builds a subgraph object representing the spanning tree given by the edges.
 
GraphType const & Graph () const
 
GraphType & Graph ()
 
TComparator const & Comparator () const
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::Prim< GraphType >

An implementation of Prim's algorithm for finding minimum spanning trees.

+
Prim<TGraph> prim(graph, comparator);
+
prim.Run();
+
Subgraph<TGraph> spanningTree = prim.Result();
+
egoa::Prim
An implementation of Prim's algorithm for finding minimum spanning trees.
Definition Prim.hpp:30
+
egoa::Subgraph
A subgraph of an existing graph.
Definition Subgraph.hpp:28
+
Template Parameters
+ + + +
GraphTypeThe type of the graph.
WeightTypeThe type of the edge weights.
+
+
+ +

Definition at line 30 of file Prim.hpp.

+

Member Typedef Documentation

+ +

◆ TComparator

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TComparator = std::function<bool(Types::edgeId, Types::edgeId)>
+ 		+private
+
+ +

Definition at line 42 of file MST.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TEdge = typename TGraph::TEdge
+ 		+private
+
+ +

Definition at line 41 of file MST.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::MST< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 40 of file MST.hpp.

+ +
+
+ +

◆ TSpanningTree

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::Prim< GraphType >::TSpanningTree = MST<GraphType>
+ 		+private
+
+ +

Definition at line 32 of file Prim.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Prim()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Prim< GraphType >::Prim (TGraph & graph,
TComparator comparator 
)
+ 		+inline
+
+ +

Definition at line 38 of file Prim.hpp.

+ +
+
+ +

◆ ~Prim()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual egoa::Prim< GraphType >::~Prim ()
+ 		+inlinevirtual
+
+ +

Definition at line 43 of file Prim.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Run()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
virtual void egoa::Prim< GraphType >::Run ()
+ 		+inlineoverridevirtual
+
+ +

Prim's algorithm @detail Prim's algorithm is quite similar to Dijkstra's algorithm. Prim runs in O(|E| log |V|) using binary heaps. While using Fibonacci heaps the running time is then in O(|E| + |V| log |V|). The latter is an improvement while |V| << |E|.

+

Steps:

    +
  1. While not all vertices are in the MST component
    2. +
  2. Relax the incident edges to u if necessary
    3. +
  3. Choose the edge that has the minimum weight between the grown MST component and the non-MST component, i.e., no cycle will be created
    4. +
+
Precondition
This algorithm assumes that the vertex identifiers all lie in the interval [0, NumberOfVertices() - 1].
+ +

Implements egoa::MST< GraphType >.

+ +

Definition at line 62 of file Prim.hpp.

+ +

References egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::ChangeKey(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::DeleteTop(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Empty(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::Insert(), egoa::MappingBinaryHeap< ElementType, KeyType, MapType >::KeyOf(), and egoa::MST< GraphType >::SetResult().

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/Algorithms/SpanningTree/Prim.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_prim.png b/classegoa_1_1_prim.png new file mode 100644 index 00000000..89424ac1 Binary files /dev/null and b/classegoa_1_1_prim.png differ diff --git a/classegoa_1_1_priority_queue-members.html b/classegoa_1_1_priority_queue-members.html new file mode 100644 index 00000000..f0f23634 --- /dev/null +++ b/classegoa_1_1_priority_queue-members.html @@ -0,0 +1,115 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::PriorityQueue< Type > Member List
+
+
+ +

This is the complete list of members for egoa::PriorityQueue< Type >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
breakable_for_all_elements(FUNCTION function) (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
breakable_for_all_elements(FUNCTION function) const (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
BuildWith(std::vector< TElement > const &elements)=0egoa::PriorityQueue< Type >inlinepure virtual
ChangeKey(Types::index index, TElement const &element)=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
Clear() override=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
DecreaseKey(Types::index index, TElement const &element)=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
DeleteMin() override=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
Empty() const override=0egoa::PriorityQueue< Type >inlinepure virtual
for_all_elements(FUNCTION function) (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
for_all_elements(FUNCTION function) const (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
Pop() override=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
PriorityQueue() (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
PriorityQueue(Compare const &compare) (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
PriorityQueue(Container const &container) (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
PriorityQueue(Compare const &compare, Container const &container) (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inline
Push(TElement const &value) override=0egoa::PriorityQueue< Type >inlinepure virtual
Push(TElement &&value) override=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
Queue() (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Compare const &compare) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Container const &container) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Compare const &compare, Container const &container) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Size() const override=0 (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinepure virtual
Swap(Queue &rhs) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
TElement typedef (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >private
Top() const override=0egoa::PriorityQueue< Type >inlinepure virtual
~PriorityQueue() override (defined in egoa::PriorityQueue< Type >)egoa::PriorityQueue< Type >inlinevirtual
~Queue() (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_priority_queue.html b/classegoa_1_1_priority_queue.html new file mode 100644 index 00000000..800d1629 --- /dev/null +++ b/classegoa_1_1_priority_queue.html @@ -0,0 +1,745 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::PriorityQueue< Type > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +List of all members
+
egoa::PriorityQueue< Type > Class Template Referenceabstract
+
+
+
+Inheritance diagram for egoa::PriorityQueue< Type >:
+
+
+ + +egoa::Queue< Type > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Compare , class Container >
 PriorityQueue (Compare const &compare)
 
template<class Container >
 PriorityQueue (Container const &container)
 
template<typename Compare , class Container >
 PriorityQueue (Compare const &compare, Container const &container)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function)
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function) const
 
virtual TElement const & Top () const override=0
 
virtual void BuildWith (std::vector< TElement > const &elements)=0
 
virtual void Push (TElement const &value) override=0
 
virtual void Push (TElement &&value) override=0
 
virtual void Pop () override=0
 
+virtual TElement DeleteMin () override=0
 
virtual void Clear () override=0
 
+virtual void ChangeKey (Types::index index, TElement const &element)=0
 
+virtual void DecreaseKey (Types::index index, TElement const &element)=0
 
virtual bool Empty () const override=0
 
virtual Types::count Size () const override=0
 
- Public Member Functions inherited from egoa::Queue< Type >
template<typename Compare , class Container >
 Queue (Compare const &compare)
 
template<class Container >
 Queue (Container const &container)
 
template<typename Compare , class Container >
 Queue (Compare const &compare, Container const &container)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function)
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function) const
 
void Swap (Queue &rhs)
 
+ + + +

+Private Types

using TElement = Type
 
+

Detailed Description

+
template<typename Type>
+class egoa::PriorityQueue< Type >
+

Definition at line 18 of file PriorityQueue.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::PriorityQueue< Type >::TElement = Type
+ 		+private
+
+ +

Definition at line 20 of file PriorityQueue.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ PriorityQueue() [1/4]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
egoa::PriorityQueue< Type >::PriorityQueue ()
+ 		+inline
+
+ +

Definition at line 24 of file PriorityQueue.hpp.

+ +
+
+ +

◆ PriorityQueue() [2/4]

+ +
+
+
+template<typename Type >
+
+template<typename Compare , class Container >
+ + + + + +
+ + + + + + + + +
egoa::PriorityQueue< Type >::PriorityQueue (Compare const & compare)
+ 		+inline
+
+ +

Definition at line 27 of file PriorityQueue.hpp.

+ +
+
+ +

◆ PriorityQueue() [3/4]

+ +
+
+
+template<typename Type >
+
+template<class Container >
+ + + + + +
+ + + + + + + + +
egoa::PriorityQueue< Type >::PriorityQueue (Container const & container)
+ 		+inline
+
+ +

Definition at line 30 of file PriorityQueue.hpp.

+ +
+
+ +

◆ PriorityQueue() [4/4]

+ +
+
+
+template<typename Type >
+
+template<typename Compare , class Container >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::PriorityQueue< Type >::PriorityQueue (Compare const & compare,
Container const & container 
)
+ 		+inline
+
+ +

Definition at line 33 of file PriorityQueue.hpp.

+ +
+
+ +

◆ ~PriorityQueue()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual egoa::PriorityQueue< Type >::~PriorityQueue ()
+ 		+inlineoverridevirtual
+
+ +

Definition at line 36 of file PriorityQueue.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ breakable_for_all_elements() [1/2]

+ +
+
+
+template<typename Type >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PriorityQueue< Type >::breakable_for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

Definition at line 46 of file PriorityQueue.hpp.

+ +
+
+ +

◆ breakable_for_all_elements() [2/2]

+ +
+
+
+template<typename Type >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PriorityQueue< Type >::breakable_for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Definition at line 49 of file PriorityQueue.hpp.

+ +
+
+ +

◆ BuildWith()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + +
virtual void egoa::PriorityQueue< Type >::BuildWith (std::vector< TElement > const & elements)
+ 		+inlinepure virtual
+
+

@Name Modifiers

+ +
+
+ +

◆ Clear()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual void egoa::PriorityQueue< Type >::Clear ()
+ 		+inlineoverridepure virtual
+
+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual bool egoa::PriorityQueue< Type >::Empty () const
+ 		+inlineoverridepure virtual
+
+

@Name Capacity

+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ for_all_elements() [1/2]

+ +
+
+
+template<typename Type >
+
+template<bool IsParallel, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PriorityQueue< Type >::for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

Definition at line 40 of file PriorityQueue.hpp.

+ +
+
+ +

◆ for_all_elements() [2/2]

+ +
+
+
+template<typename Type >
+
+template<bool IsParallel, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::PriorityQueue< Type >::for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Definition at line 43 of file PriorityQueue.hpp.

+ +
+
+ +

◆ Pop()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual void egoa::PriorityQueue< Type >::Pop ()
+ 		+inlineoverridepure virtual
+
+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ Push() [1/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + +
virtual void egoa::PriorityQueue< Type >::Push (TElement && value)
+ 		+inlineoverridepure virtual
+
+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ Push() [2/2]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + +
virtual void egoa::PriorityQueue< Type >::Push (TElement const & element)
+ 		+inlineoverridepure virtual
+
+

@Name Modifiers

+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ Size()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual Types::count egoa::PriorityQueue< Type >::Size () const
+ 		+inlineoverridepure virtual
+
+ +

Implements egoa::Queue< Type >.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual TElement const & egoa::PriorityQueue< Type >::Top () const
+ 		+inlineoverridepure virtual
+
+

@Name Element Access

+ +

Implements egoa::Queue< Type >.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_priority_queue.png b/classegoa_1_1_priority_queue.png new file mode 100644 index 00000000..5379c268 Binary files /dev/null and b/classegoa_1_1_priority_queue.png differ diff --git a/classegoa_1_1_py_psa_parser-members.html b/classegoa_1_1_py_psa_parser-members.html new file mode 100644 index 00000000..5e7560ab --- /dev/null +++ b/classegoa_1_1_py_psa_parser-members.html @@ -0,0 +1,262 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::PyPsaParser< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::PyPsaParser< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AddBusName(Types::name const &name, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddBusTypeToVertexProperty(Types::name const &type, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddCapitalCostToEdge(Types::name const &capitalCost, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddCapitalCostToGenerator(Types::string const &capitalCost, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddCarrierToGenerator(Types::string const &carrier, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddCarrierToVertexProperty(Types::name const &carrier, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddCommittabilityToGenerator(Types::string const &committable, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddConductancePuToEdge(Types::name const &conductancePu, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddConductanceToEdge(Types::name const &conductance, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddControlTypeToGenerator(Types::string const &control, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddControlTypeToVertexProperty(Types::string const &control, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddCountryToVertexProperty(Types::name const &country, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddEdge(Graph &network, TIoEdge const &ioEdge)egoa::PyPsaParser< GraphType >inlineprivate
AddEffectiveReactancePuToEdge(Types::name const &reactancePuEffective, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddEffectiveResistancePuToEdge(Types::name const &resistancePuEffective, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddGeneratorEfficiencyToGenerator(Types::string const &efficiency, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddGeneratorSignToGenerator(Types::string const &sign, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddInitialStatusToGenerator(Types::string const &initialStatus, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddLengthToEdge(Types::name const &length, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddLineTypeToEdge(Types::name const &type, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddLoadTimestampName(Types::name const &name, TNetwork &network)egoa::PyPsaParser< GraphType >inlineprivate
AddMarginalCostToGenerator(Types::string const &marginalCost, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMarginalPriceToVertexProperty(Types::name const &marginalPrice, TVertexProperties &vertex)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximalNominalApparentPowerToEdge(Types::name const &apparentPowerNominalMaximum, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumApparentPowerPuToEdge(Types::name const &apparentPowerMaximumPu, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumRealPowerPuToGenerator(Types::string const &pMaxPu, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumRealPowerSnapshotPuToGenerator(Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId generatorId)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumRealPowerSnapshotPuToLoad(Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId loadId)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumVoltageAngleToEdge(Types::name const &voltageAngleMax, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMaximumVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePuMaximum, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumDownTimeToGenerator(Types::string const &minDownTime, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumNominalApparentPowerToEdge(Types::name const &apparentPowerNominalMinimum, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumRealPowerPuToGenerator(Types::string const &pMinPu, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumUpTimeToGenerator(Types::string const &minUpTime, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumVoltageAngleToEdge(Types::name const &voltageAngleMin, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMinimumVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePuMinimum, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddMuLowerToEdge(Types::name const &muLower, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddMuUpperToEdge(Types::name const &muUpper, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddNameToEdge(Types::name const &name, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddNameToGenerator(Types::name const &name, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNameToLoad(Types::string const &name, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalApparentPowerToEdge(Types::name const &apparentPowerNominal, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalExtendableApparentPowerToEdge(Types::name const &apparentPowerNominalExtendable, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalRealPowerToGenerator(Types::string const &pNom, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalRealPowerToGeneratorExtendable(Types::string const &pNomExtendable, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalRealPowerToGeneratorMax(Types::string const &pNomMax, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalRealPowerToGeneratorMin(Types::string const &pNomMin, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalRealPowerToGeneratorOpt(Types::name const &pNomOpt, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalVoltageToEdge(Types::name const &voltageNominal, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddNominalVoltageToVertexProperty(Types::name const &voltageNominal, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddNumberOfParallelLinesToEdge(Types::name const &numberParallelLines, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddOptimalNominalApparentPowerToEdge(Types::name const &apparentPowerNominalOptimal, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddP0ToEdge(Types::name const &p0, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddP1ToEdge(Types::name const &p1, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddQ0ToEdge(Types::name const &q0, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddQ1ToEdge(Types::name const &q1, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddRampLimitDownToGenerator(Types::string const &rampLimitDown, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRampLimitShutDownToGenerator(Types::string const &rampLimitShutDown, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRampLimitStartUpToGenerator(Types::string const &rampLimitStartUp, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRampLimitUpToGenerator(Types::string const &rampLimitUp, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddReactancePuToEdge(Types::name const &reactancePu, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddReactanceToEdge(Types::name const &reactance, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddReactivePowerSetPointToGenerator(Types::string const &qSet, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddReactivePowerSetPointToLoad(Types::string const &qset, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddReactivePowerToGenerator(Types::name const &reactivePower, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddReactivePowerToLoad(Types::string const &reactivePower, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddReactivePowerToVertexProperty(Types::name const &reactivePower, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRealPowerSetPointToGenerator(Types::string const &pSet, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRealPowerSetPointToLoad(Types::string const &pset, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRealPowerToGenerator(Types::name const &realPower, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRealPowerToLoad(Types::string const &realPower, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddRealPowerToVertexProperty(Types::name const &realPower, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddResistancePuToEdge(Types::name const &resistancePu, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddResistanceToEdge(Types::name const &resistance, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddShutDownCostToGenerator(Types::string const &shutDownCost, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddSignToLoad(Types::string const &sign, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddSourceVertexToEdge(Types::name const &source, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddStartUpCostToGenerator(Types::string const &startUpCost, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddStatusToGenerator(Types::name const &status, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddSubnetworkToEdge(Types::name const &subnetwork, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddSubnetworkToVertexProperty(Types::name const &subnetwork, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddSusceptancePuToEdge(Types::name const &susceptancePu, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddSusceptanceToEdge(Types::name const &susceptance, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddTargetVertexToEdge(Types::name const &target, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddTerrainFactorToEdge(Types::name const &terrainFactor, TIoEdge &edge)egoa::PyPsaParser< GraphType >inlineprivate
AddTimestampOfGenerator(Types::name const &name, TNetwork &network)egoa::PyPsaParser< GraphType >inlineprivate
AddTypeToGenerator(Types::string const &type, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddTypeToLoad(Types::string const &type, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddVertex(Graph &network, TVertexProperties const &vertexProperties)egoa::PyPsaParser< GraphType >inlineprivate
AddVoltageAngleToVertexProperty(Types::name const &voltageAngle, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddVoltageMagnitudePuSetPointToVertexProperty(Types::name const &voltageMagnitudePuSetpoint, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddVoltageMagnitudePuToVertexProperty(Types::name const &voltageMagnitudePu, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddWeightToGenerator(Types::name const &weight, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddXcoordinateToVertexProperty(Types::name const &xCoordinate, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AddYcoordinateToVertexProperty(Types::name const &yCoordinate, TVertexProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
AssociateGeneratorWithBus(Types::name const &bus, TGeneratorProperties &generatorProperty)egoa::PyPsaParser< GraphType >inlineprivate
AssociateLoadWithVertex(Types::string const &bus, TLoadProperties &vertexProperty)egoa::PyPsaParser< GraphType >inlineprivate
CompressString(QByteArray &list)egoa::PyPsaParser< GraphType >inlineprivate
dataMapperBuses_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperCandidateNetwork_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperGenerators_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperGeneratorsRealPowerMaxPu_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperLines_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperLoads_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
dataMapperLoadsRealPowerMaxPu_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
ElectricalEdgeFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
ElectricalVertexFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
ExtractBusHeader(QList< QByteArray > const &splitted)egoa::PyPsaParser< GraphType >inlineprivate
ExtractGeneratorHeader(QList< QByteArray > const &splitted)egoa::PyPsaParser< GraphType >inlineprivate
ExtractGeneratorMaximumRealPowerPuHeader(QList< QByteArray > const &splitted)egoa::PyPsaParser< GraphType >inlineprivate
ExtractLineHeader(QList< QByteArray > const &splitted)egoa::PyPsaParser< GraphType >inlineprivate
ExtractLoadHeader(QList< QByteArray > const &splitted, Types::index &column)egoa::PyPsaParser< GraphType >inlineprivate
ExtractLoadMaximumRealPowerPuHeader(QList< QByteArray > const &splitted)egoa::PyPsaParser< GraphType >inlineprivate
filenameBuses_egoa::PyPsaParser< GraphType >private
filenameCarriers_egoa::PyPsaParser< GraphType >private
filenameGenerators_egoa::PyPsaParser< GraphType >private
filenameGeneratorsPMaxPu_egoa::PyPsaParser< GraphType >private
filenameGlobalConstraints_egoa::PyPsaParser< GraphType >private
filenameLines_egoa::PyPsaParser< GraphType >private
filenameLinesNew_egoa::PyPsaParser< GraphType >private
filenameLoads_egoa::PyPsaParser< GraphType >private
filenameLoadsPSet_egoa::PyPsaParser< GraphType >private
filenameNetwork_egoa::PyPsaParser< GraphType >private
filenameSnapshots_egoa::PyPsaParser< GraphType >private
filenameStorageUnits_egoa::PyPsaParser< GraphType >private
filenameStorageUnitsInflow_egoa::PyPsaParser< GraphType >private
GeneratorMaximumRealPowerPuFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
generatorSnapshotsSize (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
GeneratorVertexFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
HasCorrectSnapshotSizes()egoa::PyPsaParser< GraphType >inlineprivate
headerGeneratorMaximumRealPowerPu_ (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
LoadMaximumRealPowerPuFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
loadSnapshotsSize (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
LoadVertexFunc typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
mapBusName2VertexId_egoa::PyPsaParser< GraphType >private
mapGeneratorName2BusName_egoa::PyPsaParser< GraphType >private
mapGeneratorName2Generator_egoa::PyPsaParser< GraphType >private
mapGeneratorName2Identifier_egoa::PyPsaParser< GraphType >private
mapLoadName2Identifier_egoa::PyPsaParser< GraphType >private
OpenFile(QFile &file)egoa::PyPsaParser< GraphType >inlineprivate
path2FileDirectory_egoa::PyPsaParser< GraphType >private
PyPsaParser(std::string const &filename) (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >inlineexplicit
PyPsaParser(std::string filenameBuses, std::string filenameCarriers, std::string filenameGenerators, std::string filenameGeneratorsPMaxPu, std::string filenameGlobalConstraints, std::string filenameLines, std::string filenameLinesNew, std::string filenameLoads, std::string filenameLoadsPSet, std::string filenameNetwork, std::string filenameSnapshots, std::string filenameStorageUnits, std::string filenameStorageUnitsInflow) (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >inline
read(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
read(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadBuses(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadCarriers()egoa::PyPsaParser< GraphType >inline
ReadCompleteNetwork(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadCompleteNetwork(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadGenerators(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadGeneratorsRealPowerMaxPu(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadGlobalConstraints()egoa::PyPsaParser< GraphType >inline
ReadLine(QFile &file, bool compress=true)egoa::PyPsaParser< GraphType >inlineprivate
ReadLines(Graph &network, const std::string &filename)egoa::PyPsaParser< GraphType >inline
ReadLoads(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadLoadsPset(TNetwork &network, std::string const &filename)egoa::PyPsaParser< GraphType >inline
ReadNetwork(TNetwork &network)egoa::PyPsaParser< GraphType >inline
ReadSnapshots(TNetwork &network)egoa::PyPsaParser< GraphType >inline
ReadStorageUnits()egoa::PyPsaParser< GraphType >inline
ReadStorageUnitsInflows()egoa::PyPsaParser< GraphType >inline
SetLineDefaultValues(TIoEdge &edge)egoa::PyPsaParser< GraphType >inline
SetLoadDefaultValues(TLoadProperties &vertex)egoa::PyPsaParser< GraphType >inline
TBound typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TEdge typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TEdgeProperties typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TGeneratorProperties typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TGraph typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TIoEdge typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TLoadProperties typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TNetwork typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TVertex typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TVertexProperties typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
TVertexType typedef (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >private
~PyPsaParser() (defined in egoa::PyPsaParser< GraphType >)egoa::PyPsaParser< GraphType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_py_psa_parser.html b/classegoa_1_1_py_psa_parser.html new file mode 100644 index 00000000..d879fd04 --- /dev/null +++ b/classegoa_1_1_py_psa_parser.html @@ -0,0 +1,8054 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::PyPsaParser< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +Private Attributes | +List of all members
+
egoa::PyPsaParser< GraphType > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and destructor
 PyPsaParser (std::string const &filename)
 
 PyPsaParser (std::string filenameBuses, std::string filenameCarriers, std::string filenameGenerators, std::string filenameGeneratorsPMaxPu, std::string filenameGlobalConstraints, std::string filenameLines, std::string filenameLinesNew, std::string filenameLoads, std::string filenameLoadsPSet, std::string filenameNetwork, std::string filenameSnapshots, std::string filenameStorageUnits, std::string filenameStorageUnitsInflow)
 
Reader Methods
bool ReadStorageUnitsInflows ()
 Read storage units in flow.
 
bool ReadStorageUnits ()
 Reads storage units.
 
bool ReadBuses (TNetwork &network, std::string const &filename)
 Read the bus matrix.
 
bool ReadCarriers ()
 Reads carriers.
 
bool ReadGeneratorsRealPowerMaxPu (TNetwork &network, std::string const &filename)
 Read generators maximum real power production snapshot in p.u.
 
bool ReadGenerators (TNetwork &network, std::string const &filename)
 Read the generator matrix.
 
bool ReadGlobalConstraints ()
 Sets the generator default values.
 
template<typename Graph = TNetwork>
bool ReadLines (Graph &network, const std::string &filename)
 Reads branch (lines) matrix.
 
void SetLineDefaultValues (TIoEdge &edge)
 Sets the branch default values.
 
bool ReadLoadsPset (TNetwork &network, std::string const &filename)
 Read loads real power set.
 
bool ReadLoads (TNetwork &network, std::string const &filename)
 Read the load matrix that is a mapping of load to bus.
 
void SetLoadDefaultValues (TLoadProperties &vertex)
 Sets the load default values.
 
bool ReadNetwork (TNetwork &network)
 Reads a network.
 
bool ReadSnapshots (TNetwork &network)
 Reads snapshots.
 
bool ReadCompleteNetwork (TNetwork &network, std::string const &filename)
 Reads a complete network.
 
bool ReadCompleteNetwork (TNetwork &network, TGraph &candidateNetwork, std::string const &filename)
 Reads a complete network and a candidate network.
 
Reader
bool read (TNetwork &network, std::string const &filename)
 Read network $ \network $ from file.
 
bool read (TNetwork &network, TGraph &candidateNetwork, std::string const &filename)
 Read network and candidate network from file.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TNetwork = PowerGrid< GraphType >
 
using TVertex = typename TGraph::TVertex
 
using TVertexProperties = typename TGraph::TVertexProperties
 
using TVertexType = typename TVertexProperties::TVertexType
 
using TGeneratorProperties = typename TNetwork::TGeneratorProperties
 
using TLoadProperties = typename TNetwork::TLoadProperties
 
using TEdge = typename TGraph::TEdge
 
using TEdgeProperties = typename TGraph::TEdgeProperties
 
using TIoEdge = io::Edge< TEdgeProperties >
 
using TBound = Bound<>
 
Function pointer types
using ElectricalVertexFunc = void(PyPsaParser::*)(Types::name const &, TVertexProperties &)
 
using GeneratorVertexFunc = void(PyPsaParser::*)(Types::name const &, TGeneratorProperties &)
 
using GeneratorMaximumRealPowerPuFunc = std::function< void(Types::string const &, TNetwork &)>
 
using LoadVertexFunc = void(PyPsaParser::*)(Types::name const &, TLoadProperties &)
 
using LoadMaximumRealPowerPuFunc = std::function< void(Types::string const &, TNetwork &)>
 
using ElectricalEdgeFunc = void(PyPsaParser::*)(Types::name const &, TIoEdge &)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Auxiliary
template<typename Graph = TNetwork>
Types::vertexId AddVertex (Graph &network, TVertexProperties const &vertexProperties)
 Wrapper for adding a vertex.
 
template<typename Graph = TNetwork>
Types::edgeId AddEdge (Graph &network, TIoEdge const &ioEdge)
 Wrapper for adding an edge.
 
QList< QByteArray > ReadLine (QFile &file, bool compress=true)
 Reads a line.
 
void CompressString (QByteArray &list)
 Compress the string by removing spaces.
 
bool OpenFile (QFile &file)
 Opens a file.
 
bool HasCorrectSnapshotSizes ()
 Check if the snapshot size maps.
 
Header extraction
bool ExtractBusHeader (QList< QByteArray > const &splitted)
 Extract the bus header.
 
bool ExtractLineHeader (QList< QByteArray > const &splitted)
 Extract the line (branch) header.
 
bool ExtractGeneratorHeader (QList< QByteArray > const &splitted)
 Extract the generator header.
 
bool ExtractGeneratorMaximumRealPowerPuHeader (QList< QByteArray > const &splitted)
 Extract the existing generator maximum real power p.u. header.
 
bool ExtractLoadHeader (QList< QByteArray > const &splitted, Types::index &column)
 Extract the existing load header data.
 
bool ExtractLoadMaximumRealPowerPuHeader (QList< QByteArray > const &splitted)
 Extract load maximum real power p.u.
 
Bus (also known as vertex) data
void AddBusName (Types::name const &name, TVertexProperties &vertexProperty)
 Add bus name to the vertex property.
 
void AddNominalVoltageToVertexProperty (Types::name const &voltageNominal, TVertexProperties &vertexProperty)
 Add the nominal voltage to the vertex property.
 
void AddBusTypeToVertexProperty (Types::name const &type, TVertexProperties &vertexProperty)
 Add the bus type to the vertex property.
 
void AddXcoordinateToVertexProperty (Types::name const &xCoordinate, TVertexProperties &vertexProperty)
 Add x-coordinate to the vertex property.
 
void AddYcoordinateToVertexProperty (Types::name const &yCoordinate, TVertexProperties &vertexProperty)
 Add y-coordinate to the vertex property.
 
void AddCarrierToVertexProperty (Types::name const &carrier, TVertexProperties &vertexProperty)
 Add carrier to the vertex property.
 
void AddCountryToVertexProperty (Types::name const &country, TVertexProperties &vertexProperty)
 Add data country to the vertex property.
 
void AddVoltageMagnitudePuSetPointToVertexProperty (Types::name const &voltageMagnitudePuSetpoint, TVertexProperties &vertexProperty)
 Add voltage magnitude set point to the vertex property.
 
void AddMinimumVoltageMagnitudePuToVertexProperty (Types::name const &voltageMagnitudePuMinimum, TVertexProperties &vertexProperty)
 Add minimum voltage magnitude to the vertex property.
 
void AddMaximumVoltageMagnitudePuToVertexProperty (Types::name const &voltageMagnitudePuMaximum, TVertexProperties &vertexProperty)
 Add maximum voltage to the vertex property.
 
Vertex data output
void AddControlTypeToVertexProperty (Types::string const &control, TVertexProperties &vertexProperty)
 Add the control type to the vertex property.
 
void AddSubnetworkToVertexProperty (Types::name const &subnetwork, TVertexProperties &vertexProperty)
 Add the subnetwork to the vertex property.
 
void AddRealPowerToVertexProperty (Types::name const &realPower, TVertexProperties &vertexProperty)
 Add the real power to the vertex property.
 
void AddReactivePowerToVertexProperty (Types::name const &reactivePower, TVertexProperties &vertexProperty)
 Add reactive power to the vertex property.
 
void AddVoltageMagnitudePuToVertexProperty (Types::name const &voltageMagnitudePu, TVertexProperties &vertexProperty)
 Add the voltage magnitude in p.u. to the vertex property.
 
void AddVoltageAngleToVertexProperty (Types::name const &voltageAngle, TVertexProperties &vertexProperty)
 Add voltage angle to the vertex property.
 
void AddMarginalPriceToVertexProperty (Types::name const &marginalPrice, TVertexProperties &vertex)
 Add the marginal price to the vertex property.
 
Generator (also known as source) data
void AddControlTypeToGenerator (Types::string const &control, TGeneratorProperties &generatorProperty)
 Adds a control type to the generator.
 
void AddNominalRealPowerToGenerator (Types::string const &pNom, TGeneratorProperties &generatorProperty)
 Adds a nominal real power to the generator.
 
void AddNominalRealPowerToGeneratorExtendable (Types::string const &pNomExtendable, TGeneratorProperties &generatorProperty)
 Changes whether the generator is extendable or not.
 
void AddNameToGenerator (Types::name const &name, TGeneratorProperties &generatorProperty)
 Adds a name to the generator.
 
void AssociateGeneratorWithBus (Types::name const &bus, TGeneratorProperties &generatorProperty)
 Associate the generator with a bus.
 
void AddTypeToGenerator (Types::string const &type, TGeneratorProperties &generatorProperty)
 Adds a type to the generator.
 
void AddGeneratorEfficiencyToGenerator (Types::string const &efficiency, TGeneratorProperties &generatorProperty)
 Adds a generator efficiency to generator.
 
void AddNominalRealPowerToGeneratorMin (Types::string const &pNomMin, TGeneratorProperties &generatorProperty)
 Adds a minimum nominal real power to the generator.
 
void AddNominalRealPowerToGeneratorMax (Types::string const &pNomMax, TGeneratorProperties &generatorProperty)
 Adds a maximum nominal real power to the generator.
 
void AddMinimumRealPowerPuToGenerator (Types::string const &pMinPu, TGeneratorProperties &generatorProperty)
 Adds a minimum real power in p.u. to the generator.
 
void AddMaximumRealPowerPuToGenerator (Types::string const &pMaxPu, TGeneratorProperties &generatorProperty)
 Adds a maximum real power in p.u.
 
void AddRealPowerSetPointToGenerator (Types::string const &pSet, TGeneratorProperties &generatorProperty)
 Adds a real power set point to the generator.
 
void AddReactivePowerSetPointToGenerator (Types::string const &qSet, TGeneratorProperties &generatorProperty)
 Adds a reactive power set point to the generator.
 
void AddGeneratorSignToGenerator (Types::string const &sign, TGeneratorProperties &generatorProperty)
 Add the generator's sign to the generator.
 
void AddCarrierToGenerator (Types::string const &carrier, TGeneratorProperties &generatorProperty)
 Adds a carrier to the generator.
 
void AddMarginalCostToGenerator (Types::string const &marginalCost, TGeneratorProperties &generatorProperty)
 Adds a marginal cost to the generator.
 
void AddCapitalCostToGenerator (Types::string const &capitalCost, TGeneratorProperties &generatorProperty)
 Adds a capital cost to the generator.
 
void AddCommittabilityToGenerator (Types::string const &committable, TGeneratorProperties &generatorProperty)
 Add if the generator is committable or not.
 
void AddStartUpCostToGenerator (Types::string const &startUpCost, TGeneratorProperties &generatorProperty)
 Adds a start up cost to the generator.
 
void AddShutDownCostToGenerator (Types::string const &shutDownCost, TGeneratorProperties &generatorProperty)
 Adds a shut down cost to the generator.
 
void AddMinimumUpTimeToGenerator (Types::string const &minUpTime, TGeneratorProperties &generatorProperty)
 Adds a minimum up time to the generator.
 
void AddMinimumDownTimeToGenerator (Types::string const &minDownTime, TGeneratorProperties &generatorProperty)
 Adds a minimum down time to the generator.
 
void AddInitialStatusToGenerator (Types::string const &initialStatus, TGeneratorProperties &generatorProperty)
 Adds an initial status to the generator.
 
void AddRampLimitUpToGenerator (Types::string const &rampLimitUp, TGeneratorProperties &generatorProperty)
 Adds a ramp up time limit to the generator.
 
void AddRampLimitDownToGenerator (Types::string const &rampLimitDown, TGeneratorProperties &generatorProperty)
 Adds a ramp down time limit to the generator.
 
void AddRampLimitStartUpToGenerator (Types::string const &rampLimitStartUp, TGeneratorProperties &generatorProperty)
 Adds a ramp start up time limit to the generator.
 
void AddRampLimitShutDownToGenerator (Types::string const &rampLimitShutDown, TGeneratorProperties &generatorProperty)
 Adds a ramp limit shut down to the generator.
 
Generator data output
void AddRealPowerToGenerator (Types::name const &realPower, TGeneratorProperties &generatorProperty)
 Adds a real power to the generator.
 
void AddReactivePowerToGenerator (Types::name const &reactivePower, TGeneratorProperties &generatorProperty)
 Adds a reactive power to the generator.
 
void AddNominalRealPowerToGeneratorOpt (Types::name const &pNomOpt, TGeneratorProperties &generatorProperty)
 Adds a optimal nominal real power to the generator.
 
void AddStatusToGenerator (Types::name const &status, TGeneratorProperties &generatorProperty)
 Adds a status to the generator $\vertex\in\generators$.
 
void AddWeightToGenerator (Types::name const &weight, TGeneratorProperties &generatorProperty)
 Adds a weight to the generator $\vertex\in\generators$.
 
Generator snapshot extraction
void AddTimestampOfGenerator (Types::name const &name, TNetwork &network)
 Add the time stamp of the maximum real power.
 
void AddMaximumRealPowerSnapshotPuToGenerator (Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId generatorId)
 Add the maximum real power generation snapshot in p.u. to a generator.
 
Line (also known as Branch or Circuit) Data
void AddNameToEdge (Types::name const &name, TIoEdge &edge)
 Add the name to the line.
 
void AddSourceVertexToEdge (Types::name const &source, TIoEdge &edge)
 Associate the line with the source vertex.
 
void AddTargetVertexToEdge (Types::name const &target, TIoEdge &edge)
 Associate the line with the target bus.
 
void AddCapitalCostToEdge (Types::name const &capitalCost, TIoEdge &edge)
 Add the capital cost to the line.
 
void AddLengthToEdge (Types::name const &length, TIoEdge &edge)
 Add the length to the line.
 
void AddNumberOfParallelLinesToEdge (Types::name const &numberParallelLines, TIoEdge &edge)
 Add the number of parallel lines to the line.
 
void AddMaximumApparentPowerPuToEdge (Types::name const &apparentPowerMaximumPu, TIoEdge &edge)
 Add the maximum apparent power in p.u. to the line.
 
void AddNominalApparentPowerToEdge (Types::name const &apparentPowerNominal, TIoEdge &edge)
 Add the nominal apparent power to the line.
 
void AddLineTypeToEdge (Types::name const &type, TIoEdge &edge)
 Add the line type to the line.
 
void AddNominalVoltageToEdge (Types::name const &voltageNominal, TIoEdge &edge)
 Add the nominal voltage to the line.
 
void AddMinimumNominalApparentPowerToEdge (Types::name const &apparentPowerNominalMinimum, TIoEdge &edge)
 Add the minimum nominal apparent power.
 
void AddMaximalNominalApparentPowerToEdge (Types::name const &apparentPowerNominalMaximum, TIoEdge &edge)
 Add the maximum nominal apparent power to the line.
 
void AddResistanceToEdge (Types::name const &resistance, TIoEdge &edge)
 Add the resistance to the line.
 
void AddReactanceToEdge (Types::name const &reactance, TIoEdge &edge)
 Add the reactance to the line.
 
void AddConductanceToEdge (Types::name const &conductance, TIoEdge &edge)
 Add the conductance to the line.
 
void AddSusceptanceToEdge (Types::name const &susceptance, TIoEdge &edge)
 Add the susceptance to the line.
 
void AddNominalExtendableApparentPowerToEdge (Types::name const &apparentPowerNominalExtendable, TIoEdge &edge)
 Add the nominal extendable apparent power to the line.
 
void AddTerrainFactorToEdge (Types::name const &terrainFactor, TIoEdge &edge)
 Add the terrain factor to the line.
 
void AddMinimumVoltageAngleToEdge (Types::name const &voltageAngleMin, TIoEdge &edge)
 Add the minimum voltage angle to the line.
 
void AddMaximumVoltageAngleToEdge (Types::name const &voltageAngleMax, TIoEdge &edge)
 Add maximum voltage angle to the line.
 
Line data output.

Each row in the line data creates an edge.

+
Note
Currently only used for output.
+
void AddSubnetworkToEdge (Types::name const &subnetwork, TIoEdge &edge)
 Add the subnetwork.
 
void AddP0ToEdge (Types::name const &p0, TIoEdge &edge)
 Add the real power P0.
 
void AddQ0ToEdge (Types::name const &q0, TIoEdge &edge)
 Add the reactive power Q0.
 
void AddP1ToEdge (Types::name const &p1, TIoEdge &edge)
 Add the real power P1.
 
void AddQ1ToEdge (Types::name const &q1, TIoEdge &edge)
 Add the reactive power Q1.
 
void AddReactancePuToEdge (Types::name const &reactancePu, TIoEdge &edge)
 Add the reactance in p.u.
 
void AddResistancePuToEdge (Types::name const &resistancePu, TIoEdge &edge)
 Add the resistance in p.u.
 
void AddConductancePuToEdge (Types::name const &conductancePu, TIoEdge &edge)
 Add the conductance G in p.u.
 
void AddSusceptancePuToEdge (Types::name const &susceptancePu, TIoEdge &edge)
 Add the susceptance in p.u.
 
void AddEffectiveReactancePuToEdge (Types::name const &reactancePuEffective, TIoEdge &edge)
 Add the effective reactance in p.u.
 
void AddEffectiveResistancePuToEdge (Types::name const &resistancePuEffective, TIoEdge &edge)
 Add the effective resistance in p.u.
 
void AddOptimalNominalApparentPowerToEdge (Types::name const &apparentPowerNominalOptimal, TIoEdge &edge)
 Add the optimal nominal apparent power.
 
void AddMuLowerToEdge (Types::name const &muLower, TIoEdge &edge)
 Add mu lower of a line.
 
void AddMuUpperToEdge (Types::name const &muUpper, TIoEdge &edge)
 Add mu upper of a line.
 
Load Data.

Each row in the load data creates an load vertex.

+
Note
Currently only the name and type is set.
+
void AddNameToLoad (Types::string const &name, TLoadProperties &vertexProperty)
 Add the name of the load.
 
void AssociateLoadWithVertex (Types::string const &bus, TLoadProperties &vertexProperty)
 Associating the load with a bus.
 
void AddTypeToLoad (Types::string const &type, TLoadProperties &vertexProperty)
 Add the load type.
 
void AddRealPowerSetPointToLoad (Types::string const &pset, TLoadProperties &vertexProperty)
 Add the real power load set point.
 
void AddReactivePowerSetPointToLoad (Types::string const &qset, TLoadProperties &vertexProperty)
 Add the reactive power set point.
 
void AddSignToLoad (Types::string const &sign, TLoadProperties &vertexProperty)
 Add the data sign of the load.
 
void AddRealPowerToLoad (Types::string const &realPower, TLoadProperties &vertexProperty)
 Add the real power load to the vertex property.
 
void AddReactivePowerToLoad (Types::string const &reactivePower, TLoadProperties &vertexProperty)
 Add the reactive power loads.
 
Load's Real Power Data Snapshot per Timestamp.

Each row in the load's real power set data creates an snapshot entry.

+
Note
The snapshots are managed in the network $\network$ and not in the load.
+
void AddLoadTimestampName (Types::name const &name, TNetwork &network)
 Add a maximum real power load time stamp in p.u.
 
void AddMaximumRealPowerSnapshotPuToLoad (Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId loadId)
 Add a maximum real power load in p.u.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

std::vector< TGeneratorProperties * > headerGeneratorMaximumRealPowerPu_
 
Mappers for Reading Data
std::vector< ElectricalVertexFunc > dataMapperBuses_
 
std::vector< GeneratorMaximumRealPowerPuFunc > dataMapperGeneratorsRealPowerMaxPu_
 
std::vector< GeneratorVertexFunc > dataMapperGenerators_
 
std::vector< ElectricalEdgeFunc > dataMapperCandidateNetwork_
 
std::vector< ElectricalEdgeFunc > dataMapperLines_
 
std::vector< LoadVertexFunc > dataMapperLoads_
 
std::vector< LoadMaximumRealPowerPuFunc > dataMapperLoadsRealPowerMaxPu_
 
File and Directory Information
Types::name path2FileDirectory_
 
Types::name const filenameBuses_
 
Types::name const filenameCarriers_
 
Types::name const filenameGenerators_
 
Types::name const filenameGeneratorsPMaxPu_
 
Types::name const filenameGlobalConstraints_
 
Types::name const filenameLines_
 
Types::name const filenameLinesNew_
 
Types::name const filenameLoads_
 
Types::name const filenameLoadsPSet_
 
Types::name const filenameNetwork_
 
Types::name const filenameSnapshots_
 
Types::name const filenameStorageUnits_
 
Types::name const filenameStorageUnitsInflow_
 
Mapping of Different Inputs
std::unordered_map< Types::name, Types::vertexId > mapBusName2VertexId_
 
std::unordered_map< Types::name, TGeneratorProperties > mapGeneratorName2Generator_
 
std::unordered_map< Types::name, Types::vertexId > mapGeneratorName2Identifier_
 
std::unordered_map< Types::name, Types::name > mapGeneratorName2BusName_
 
std::unordered_map< Types::name, Types::vertexId > mapLoadName2Identifier_
 
Counter
Types::count generatorSnapshotsSize
 
Types::count loadSnapshotsSize
 
+

Detailed Description

+
template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+class egoa::PyPsaParser< GraphType >
+

Definition at line 38 of file PyPsaParser.hpp.

+

Member Typedef Documentation

+ +

◆ ElectricalEdgeFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::ElectricalEdgeFunc = void (PyPsaParser::*)( Types::name const &, TIoEdge& )
+ 		+private
+
+ +

Definition at line 1226 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ElectricalVertexFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::ElectricalVertexFunc = void (PyPsaParser::*)( Types::name const &, TVertexProperties& )
+ 		+private
+
+ +

Definition at line 1218 of file PyPsaParser.hpp.

+ +
+
+ +

◆ GeneratorMaximumRealPowerPuFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::GeneratorMaximumRealPowerPuFunc = std::function<void(Types::string const &, TNetwork&)>
+ 		+private
+
+ +

Definition at line 1221 of file PyPsaParser.hpp.

+ +
+
+ +

◆ GeneratorVertexFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::GeneratorVertexFunc = void (PyPsaParser::*)( Types::name const &, TGeneratorProperties& )
+ 		+private
+
+ +

Definition at line 1220 of file PyPsaParser.hpp.

+ +
+
+ +

◆ LoadMaximumRealPowerPuFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::LoadMaximumRealPowerPuFunc = std::function<void(Types::string const &, TNetwork&)>
+ 		+private
+
+ +

Definition at line 1224 of file PyPsaParser.hpp.

+ +
+
+ +

◆ LoadVertexFunc

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::LoadVertexFunc = void (PyPsaParser::*)( Types::name const &, TLoadProperties& )
+ 		+private
+
+ +

Definition at line 1223 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TBound

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TBound = Bound<>
+ 		+private
+
+ +

Definition at line 55 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TEdge = typename TGraph::TEdge
+ 		+private
+
+ +

Definition at line 51 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TEdgeProperties = typename TGraph::TEdgeProperties
+ 		+private
+
+ +

Definition at line 52 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TGeneratorProperties = typename TNetwork::TGeneratorProperties
+ 		+private
+
+ +

Definition at line 48 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 42 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TIoEdge

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TIoEdge = io::Edge<TEdgeProperties>
+ 		+private
+
+ +

Definition at line 53 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TLoadProperties = typename TNetwork::TLoadProperties
+ 		+private
+
+ +

Definition at line 49 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TNetwork = PowerGrid<GraphType>
+ 		+private
+
+ +

Definition at line 43 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 45 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TVertexProperties = typename TGraph::TVertexProperties
+ 		+private
+
+ +

Definition at line 46 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
using egoa::PyPsaParser< GraphType >::TVertexType = typename TVertexProperties::TVertexType
+ 		+private
+
+ +

Definition at line 47 of file PyPsaParser.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ PyPsaParser() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
egoa::PyPsaParser< GraphType >::PyPsaParser (std::string const & filename)
+ 		+inlineexplicit
+
+ +

Definition at line 63 of file PyPsaParser.hpp.

+ +
+
+ +

◆ PyPsaParser() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::PyPsaParser< GraphType >::PyPsaParser (std::string filenameBuses,
std::string filenameCarriers,
std::string filenameGenerators,
std::string filenameGeneratorsPMaxPu,
std::string filenameGlobalConstraints,
std::string filenameLines,
std::string filenameLinesNew,
std::string filenameLoads,
std::string filenameLoadsPSet,
std::string filenameNetwork,
std::string filenameSnapshots,
std::string filenameStorageUnits,
std::string filenameStorageUnitsInflow 
)
+ 		+inline
+
+ +

Definition at line 82 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ~PyPsaParser()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
egoa::PyPsaParser< GraphType >::~PyPsaParser ()
+ 		+inline
+
+ +

Definition at line 112 of file PyPsaParser.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddBusName()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddBusName (Types::name const & name,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add bus name to the vertex property.

+
Parameters
+ + + +
nameThe name.
vertexThe vertex property.
+
+
+ +

Definition at line 1258 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddBusTypeToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddBusTypeToVertexProperty (Types::name const & type,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the bus type to the vertex property.

+
Precondition
Assume IEEE type.
+
Parameters
+ + + +
typeThe type.
vertexPropertyThe vertex property.
+
+
+
Note
Placeholder in PyPsa data, i.e., not used yet.
+ +

Definition at line 1294 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCapitalCostToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCapitalCostToEdge (Types::name const & capitalCost,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the capital cost to the line.

+
Parameters
+ + + +
capitalCostThe capital cost.
edgeThe edge.
+
+
+ +

Definition at line 2320 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCapitalCostToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCapitalCostToGenerator (Types::string const & capitalCost,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a capital cost to the generator.

+
Parameters
+ + + +
capitalCostThe capital cost.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1892 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCarrierToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCarrierToGenerator (Types::string const & carrier,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a carrier to the generator.

+
Parameters
+ + + +
carrierThe carrier.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1857 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCarrierToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCarrierToVertexProperty (Types::name const & carrier,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add carrier to the vertex property.

+
Parameters
+ + + +
carrierThe carrier.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1339 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCommittabilityToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCommittabilityToGenerator (Types::string const & committable,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Add if the generator is committable or not.

+
Parameters
+ + + +
committableThe committable.
generatorThe generator.
+
+
+

Changes the committability property of the generator.

+
Parameters
+ + + +
committableThe committable property.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1919 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddConductancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddConductancePuToEdge (Types::name const & conductancePu,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the conductance G in p.u.

+
Parameters
+ + + +
conductancePuThe conductance in p.u.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2816 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddConductanceToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddConductanceToEdge (Types::name const & conductance,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the conductance to the line.

+
Parameters
+ + + +
conductanceThe conductance.
edgeThe edge.
+
+
+ +

Definition at line 2535 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddControlTypeToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddControlTypeToGenerator (Types::string const & control,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a control type to the generator.

+
Parameters
+ + + +
controlThe control type.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1588 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddControlTypeToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddControlTypeToVertexProperty (Types::string const & control,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the control type to the vertex property.

+
Parameters
+ + + +
controlThe control type of the bus.
vertexPropertyThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1436 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddCountryToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddCountryToVertexProperty (Types::name const & country,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add data country to the vertex property.

+
Parameters
+ + + +
countryThe country.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1354 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+
+template<typename Graph = TNetwork>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::PyPsaParser< GraphType >::AddEdge (Graph & network,
TIoEdge const & ioEdge 
)
+ 		+inlineprivate
+
+ +

Wrapper for adding an edge.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
ioEdgeThe i/o edge
+
+
+
Template Parameters
+ + +
GraphThe graph type, e.g., PowerGrid.
+
+
+
Returns
The edge identifier of a edge.
+ +

Definition at line 697 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddEffectiveReactancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddEffectiveReactancePuToEdge (Types::name const & reactancePuEffective,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the effective reactance in p.u.

+
Parameters
+ + + +
reactancePuEffectiveThe effective reactance in p.u.
edgeThe edge
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2860 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddEffectiveResistancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddEffectiveResistancePuToEdge (Types::name const & resistancePuEffective,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the effective resistance in p.u.

+
Parameters
+ + + +
resistancePuEffectiveThe effective resistance in p.u.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2882 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddGeneratorEfficiencyToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddGeneratorEfficiencyToGenerator (Types::string const & efficiency,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a generator efficiency to generator.

+
Parameters
+ + + +
efficiencyThe generator's efficiency.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1695 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddGeneratorSignToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddGeneratorSignToGenerator (Types::string const & sign,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Add the generator's sign to the generator.

+
Parameters
+ + + +
signThe sign.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1835 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddInitialStatusToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddInitialStatusToGenerator (Types::string const & initialStatus,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds an initial status to the generator.

+
Parameters
+ + + +
initialStatusThe initial status.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2016 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddLengthToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddLengthToEdge (Types::name const & length,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the length to the line.

+
Parameters
+ + + +
lengthThe length.
edgeThe edge.
+
+
+ +

Definition at line 2340 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddLineTypeToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddLineTypeToEdge (Types::name const & type,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the line type to the line.

+
Parameters
+ + + +
typeThe line type.
edgeThe edge.
+
+
+ +

Definition at line 2420 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddLoadTimestampName()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddLoadTimestampName (Types::name const & name,
TNetwork & network 
)
+ 		+inlineprivate
+
+ +

Add a maximum real power load time stamp in p.u.

+
Parameters
+ + + +
nameThe real power load time stamp in p.u.
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
+
+
+ +

Definition at line 3137 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMarginalCostToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMarginalCostToGenerator (Types::string const & marginalCost,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a marginal cost to the generator.

+
Parameters
+ + + +
marginalCostThe marginal cost.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1872 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMarginalPriceToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMarginalPriceToVertexProperty (Types::name const & marginalPrice,
TVertexProperties & vertex 
)
+ 		+inlineprivate
+
+ +

Add the marginal price to the vertex property.

+
Parameters
+ + + +
marginalPriceThe marginal price.
vertexThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1563 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximalNominalApparentPowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximalNominalApparentPowerToEdge (Types::name const & apparentPowerNominalMaximum,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the maximum nominal apparent power to the line.

+
Parameters
+ + + +
apparentPowerNominalMaximumThe maximum nominal apparent power.
edgeThe edge.
+
+
+ +

Definition at line 2475 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumApparentPowerPuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumApparentPowerPuToEdge (Types::name const & apparentPowerMaximumPu,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the maximum apparent power in p.u. to the line.

+
Parameters
+ + + +
apparentPowerMaximumPuThe maximum apparent power in p.u.
edgeThe edge.
+
+
+ +

Definition at line 2380 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumRealPowerPuToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumRealPowerPuToGenerator (Types::string const & pMaxPu,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a maximum real power in p.u.

+
Parameters
+ + + +
pMaxPuThe maximum real power in p.u.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1775 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumRealPowerSnapshotPuToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumRealPowerSnapshotPuToGenerator (Types::name const & maximumRealPowerPu,
TNetwork & network,
Types::vertexId generatorId 
)
+ 		+inlineprivate
+
+ +

Add the maximum real power generation snapshot in p.u. to a generator.

+
Parameters
+ + + + +
maximumRealPowerPuThe maximum real power in p.u.
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
[in]generatorIdThe generator identifier.
+
+
+
Todo:
Check if the number of timestamps are correct
+ +

Definition at line 2243 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumRealPowerSnapshotPuToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumRealPowerSnapshotPuToLoad (Types::name const & maximumRealPowerPu,
TNetwork & network,
Types::vertexId loadId 
)
+ 		+inlineprivate
+
+ +

Add a maximum real power load in p.u.

+
Parameters
+ + + + +
maximumRealPowerPuThe maximum real power load in p.u.
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
[in]loadIdThe load identifier.
+
+
+ +

Definition at line 3150 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumVoltageAngleToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumVoltageAngleToEdge (Types::name const & voltageAngleMax,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add maximum voltage angle to the line.

+
Parameters
+ + + +
voltageAngleMaxThe maximum voltage angle.
edgeThe edge.
+
+
+ +

Definition at line 2630 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMaximumVoltageMagnitudePuToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMaximumVoltageMagnitudePuToVertexProperty (Types::name const & voltageMagnitudePuMaximum,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add maximum voltage to the vertex property.

+
Parameters
+ + + +
voltageMagnitudePuMaximumThe maximum voltage magnitude in p.u.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1409 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::AddNameToLoad(), egoa::PyPsaParser< GraphType >::AddReactivePowerSetPointToLoad(), egoa::PyPsaParser< GraphType >::AddReactivePowerToLoad(), egoa::PyPsaParser< GraphType >::AddRealPowerSetPointToLoad(), egoa::PyPsaParser< GraphType >::AddRealPowerToLoad(), egoa::PyPsaParser< GraphType >::AddSignToLoad(), egoa::PyPsaParser< GraphType >::AddTypeToLoad(), and egoa::PyPsaParser< GraphType >::AssociateLoadWithVertex().

+ +
+
+ +

◆ AddMinimumDownTimeToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumDownTimeToGenerator (Types::string const & minDownTime,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a minimum down time to the generator.

+
Parameters
+ + + +
minDownTimeThe minimum down time.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1996 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMinimumNominalApparentPowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumNominalApparentPowerToEdge (Types::name const & apparentPowerNominalMinimum,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the minimum nominal apparent power.

+
Parameters
+ + + +
apparentPowerNominalMinimumThe minimum nominal apparent power.
edgeThe edge.
+
+
+ +

Definition at line 2455 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMinimumRealPowerPuToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumRealPowerPuToGenerator (Types::string const & pMinPu,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a minimum real power in p.u. to the generator.

+
Parameters
+ + + +
pMinPuThe minimum real power in p.u.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1755 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMinimumUpTimeToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumUpTimeToGenerator (Types::string const & minUpTime,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a minimum up time to the generator.

+
Parameters
+ + + +
minUpTimeThe minimum up time.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1976 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMinimumVoltageAngleToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumVoltageAngleToEdge (Types::name const & voltageAngleMin,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the minimum voltage angle to the line.

+
Parameters
+ + + +
voltageAngleMinThe minimum voltage angle.
edgeThe edge.
+
+
+ +

Definition at line 2610 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMinimumVoltageMagnitudePuToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMinimumVoltageMagnitudePuToVertexProperty (Types::name const & voltageMagnitudePuMinimum,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add minimum voltage magnitude to the vertex property.

+
Parameters
+ + + +
voltageMagnitudePuMinimumThe minimum voltage magnitude in p.u.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1389 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMuLowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMuLowerToEdge (Types::name const & muLower,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add mu lower of a line.

+
Parameters
+ + + +
muLowerThe mu lower.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2926 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddMuUpperToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddMuUpperToEdge (Types::name const & muUpper,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add mu upper of a line.

+
Parameters
+ + + +
muUpperThe mu upper.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2948 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNameToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNameToEdge (Types::name const & name,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the name to the line.

+
Parameters
+ + + +
nameThe name of the line.
edgeThe edge.
+
+
+ +

Definition at line 2272 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNameToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNameToGenerator (Types::name const & name,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a name to the generator.

+
Parameters
+ + + +
nameThe name.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1638 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNameToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNameToLoad (Types::string const & name,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the name of the load.

+
Parameters
+ + + +
nameThe name.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 2979 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalApparentPowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalApparentPowerToEdge (Types::name const & apparentPowerNominal,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the nominal apparent power to the line.

+
Parameters
+ + + +
apparentPowerNominalThe nominal apparent power.
edgeThe edge.
+
+
+ +

Definition at line 2400 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalExtendableApparentPowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalExtendableApparentPowerToEdge (Types::name const & apparentPowerNominalExtendable,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the nominal extendable apparent power to the line.

+
Parameters
+ + + +
apparentPowerNominalExtendableThe nominal extendable apparent power.
edgeThe edge.
+
+
+ +

Definition at line 2575 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::mapBusName2VertexId_.

+ +
+
+ +

◆ AddNominalRealPowerToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalRealPowerToGenerator (Types::string const & pNom,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a nominal real power to the generator.

+
Parameters
+ + + +
pNomThe nominal real power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1604 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalRealPowerToGeneratorExtendable()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalRealPowerToGeneratorExtendable (Types::string const & pNomExtendable,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Changes whether the generator is extendable or not.

+
Parameters
+ + + +
pNomExtendableThe nominal extendable boolean.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1621 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalRealPowerToGeneratorMax()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalRealPowerToGeneratorMax (Types::string const & pNomMax,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a maximum nominal real power to the generator.

+
Parameters
+ + + +
pNomMaxThe maximum nominal real power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1735 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalRealPowerToGeneratorMin()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalRealPowerToGeneratorMin (Types::string const & pNomMin,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a minimum nominal real power to the generator.

+
Parameters
+ + + +
pNomMinThe nominal minimum real power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1715 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalRealPowerToGeneratorOpt()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalRealPowerToGeneratorOpt (Types::name const & pNomOpt,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a optimal nominal real power to the generator.

+
Parameters
+ + + +
pNomOptThe optimal nominal real power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2160 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalVoltageToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalVoltageToEdge (Types::name const & voltageNominal,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the nominal voltage to the line.

+
Parameters
+ + + +
voltageNominalThe nominal voltage.
edgeThe edge.
+
+
+ +

Definition at line 2435 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNominalVoltageToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNominalVoltageToVertexProperty (Types::name const & voltageNominal,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the nominal voltage to the vertex property.

+
Parameters
+ + + +
voltageNominalThe nominal voltage.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1270 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddNumberOfParallelLinesToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddNumberOfParallelLinesToEdge (Types::name const & numberParallelLines,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the number of parallel lines to the line.

+
Parameters
+ + + +
numberParallelLinesThe number parallel lines.
edgeThe edge.
+
+
+ +

Definition at line 2360 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddOptimalNominalApparentPowerToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddOptimalNominalApparentPowerToEdge (Types::name const & apparentPowerNominalOptimal,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the optimal nominal apparent power.

+
Parameters
+ + + +
apparentPowerNominalOptimalThe optimal nominal apparent power.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2904 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddP0ToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddP0ToEdge (Types::name const & p0,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the real power P0.

+
Parameters
+ + + +
p0The real power P0.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2685 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddP1ToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddP1ToEdge (Types::name const & p1,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the real power P1.

+
Parameters
+ + + +
p1The real power P1.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2729 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddQ0ToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddQ0ToEdge (Types::name const & q0,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the reactive power Q0.

+
Parameters
+ + + +
q0The reactive power Q0.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2707 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddQ1ToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddQ1ToEdge (Types::name const & q1,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the reactive power Q1.

+
Parameters
+ + + +
q1The reactive power Q1.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2751 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRampLimitDownToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRampLimitDownToGenerator (Types::string const & rampLimitDown,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a ramp down time limit to the generator.

+
Parameters
+ + + +
rampLimitDownThe ramp limit down.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2055 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRampLimitShutDownToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRampLimitShutDownToGenerator (Types::string const & rampLimitShutDown,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a ramp limit shut down to the generator.

+
Parameters
+ + + +
rampLimitShutDownThe ramp limit shut down.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2095 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRampLimitStartUpToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRampLimitStartUpToGenerator (Types::string const & rampLimitStartUp,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a ramp start up time limit to the generator.

+
Parameters
+ + + +
rampLimitStartUpThe ramp start up time limit.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2075 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRampLimitUpToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRampLimitUpToGenerator (Types::string const & rampLimitUp,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a ramp up time limit to the generator.

+
Parameters
+ + + +
rampLimitUpThe ramp limit up.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2035 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactancePuToEdge (Types::name const & reactancePu,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the reactance in p.u.

+
Parameters
+ + + +
reactancePuThe reactance in p.u.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2773 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactanceToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactanceToEdge (Types::name const & reactance,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the reactance to the line.

+
Parameters
+ + + +
reactanceThe reactance.
edgeThe edge.
+
+
+ +

Definition at line 2515 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactivePowerSetPointToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactivePowerSetPointToGenerator (Types::string const & qSet,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a reactive power set point to the generator.

+
Parameters
+ + + +
qSetThe reactive power set point.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1815 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactivePowerSetPointToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactivePowerSetPointToLoad (Types::string const & qset,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the reactive power set point.

+
Parameters
+ + + +
qsetThe reactive power set point.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3044 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactivePowerToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactivePowerToGenerator (Types::name const & reactivePower,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a reactive power to the generator.

+
Parameters
+ + + +
reactivePowerThe reactive power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2140 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactivePowerToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactivePowerToLoad (Types::string const & reactivePower,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the reactive power loads.

+
Parameters
+ + + +
reactivePowerThe reactive power.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3104 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddReactivePowerToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddReactivePowerToVertexProperty (Types::name const & reactivePower,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add reactive power to the vertex property.

+
Parameters
+ + + +
reactivePowerThe reactive power
vertexPropertyThe vertex property
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1497 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRealPowerSetPointToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRealPowerSetPointToGenerator (Types::string const & pSet,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a real power set point to the generator.

+
Parameters
+ + + +
pSetThe real power set point.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1795 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRealPowerSetPointToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRealPowerSetPointToLoad (Types::string const & pset,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the real power load set point.

+
Parameters
+ + + +
psetThe real power set point.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3024 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRealPowerToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRealPowerToGenerator (Types::name const & realPower,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a real power to the generator.

+
Parameters
+ + + +
realPowerThe real power.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2120 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRealPowerToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRealPowerToLoad (Types::string const & realPower,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the real power load to the vertex property.

+
Parameters
+ + + +
realPowerThe real power.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3084 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddRealPowerToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddRealPowerToVertexProperty (Types::name const & realPower,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the real power to the vertex property.

+
Parameters
+ + + +
realPowerThe real power.
vertexPropertyThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1475 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddResistancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddResistancePuToEdge (Types::name const & resistancePu,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the resistance in p.u.

+
Parameters
+ + + +
resistancePuThe resistance in p.u.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2794 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddResistanceToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddResistanceToEdge (Types::name const & resistance,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the resistance to the line.

+
Parameters
+ + + +
resistanceThe resistance.
edgeThe edge.
+
+
+ +

Definition at line 2495 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddShutDownCostToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddShutDownCostToGenerator (Types::string const & shutDownCost,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a shut down cost to the generator.

+
Parameters
+ + + +
shutDownCostThe shut down cost.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1956 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddSignToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSignToLoad (Types::string const & sign,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the data sign of the load.

+
Parameters
+ + + +
signThe sign.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3064 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddSourceVertexToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSourceVertexToEdge (Types::name const & source,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Associate the line with the source vertex.

+
Parameters
+ + + +
sourceThe source vertex.
edgeThe edge.
+
+
+ +

Definition at line 2284 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddStartUpCostToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddStartUpCostToGenerator (Types::string const & startUpCost,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a start up cost to the generator.

+
Parameters
+ + + +
startUpCostThe start up cost.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1936 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddStatusToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddStatusToGenerator (Types::name const & status,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a status to the generator $\vertex\in\generators$.

+
Parameters
+ + + +
statusThe status.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2180 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddSubnetworkToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSubnetworkToEdge (Types::name const & subnetwork,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the subnetwork.

+
Parameters
+ + + +
subnetworkThe subnetwork.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2663 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddSubnetworkToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSubnetworkToVertexProperty (Types::name const & subnetwork,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the subnetwork to the vertex property.

+
Parameters
+ + + +
subnetworkThe subnetwork.
vertexPropertyThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1453 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::AddLoadTimestampName().

+ +
+
+ +

◆ AddSusceptancePuToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSusceptancePuToEdge (Types::name const & susceptancePu,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the susceptance in p.u.

+
Parameters
+ + + +
susceptancePuThe susceptance in p.u.
edgeThe edge.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 2838 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddSusceptanceToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddSusceptanceToEdge (Types::name const & susceptance,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the susceptance to the line.

+
Parameters
+ + + +
susceptanceThe susceptance.
edgeThe edge.
+
+
+ +

Definition at line 2555 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::mapBusName2VertexId_.

+ +
+
+ +

◆ AddTargetVertexToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddTargetVertexToEdge (Types::name const & target,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Associate the line with the target bus.

+
Parameters
+ + + +
targetThe target bus.
edgeThe edge.
+
+
+ +

Definition at line 2302 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddTerrainFactorToEdge()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddTerrainFactorToEdge (Types::name const & terrainFactor,
TIoEdge & edge 
)
+ 		+inlineprivate
+
+ +

Add the terrain factor to the line.

+
Parameters
+ + + +
terrainFactorThe terrain factor.
edgeThe edge.
+
+
+ +

Definition at line 2590 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddTimestampOfGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddTimestampOfGenerator (Types::name const & name,
TNetwork & network 
)
+ 		+inlineprivate
+
+ +

Add the time stamp of the maximum real power.

+
Parameters
+ + + +
nameThe name.
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
+
+
+
Todo:
What happens if load timestamps does not exist?
+ +

Definition at line 2228 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddTypeToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddTypeToGenerator (Types::string const & type,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a type to the generator.

+
Parameters
+ + + +
typeThe type.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1680 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddTypeToLoad()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddTypeToLoad (Types::string const & type,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the load type.

+
Parameters
+ + + +
typeThe load type.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 3006 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVertex()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+
+template<typename Graph = TNetwork>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::vertexId egoa::PyPsaParser< GraphType >::AddVertex (Graph & network,
TVertexProperties const & vertexProperties 
)
+ 		+inlineprivate
+
+ +

Wrapper for adding a vertex.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
vertexPropertiesThe vertex properties.
+
+
+
Template Parameters
+ + +
GraphThe graph type, e.g., PowerGrid.
+
+
+
Returns
The vertex identifier of a vertex.
+ +

Definition at line 679 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVoltageAngleToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddVoltageAngleToVertexProperty (Types::name const & voltageAngle,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add voltage angle to the vertex property.

+
Parameters
+ + + +
voltageAngleThe voltage angle.
vertexPropertyThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1541 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVoltageMagnitudePuSetPointToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddVoltageMagnitudePuSetPointToVertexProperty (Types::name const & voltageMagnitudePuSetpoint,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add voltage magnitude set point to the vertex property.

+
Parameters
+ + + +
voltageMagnitudePuSetpointThe voltage magnitude set point in p.u.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1369 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVoltageMagnitudePuToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddVoltageMagnitudePuToVertexProperty (Types::name const & voltageMagnitudePu,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add the voltage magnitude in p.u. to the vertex property.

+
Parameters
+ + + +
voltageMagnitudePuThe voltage magnitude in p.u.
vertexPropertyThe vertex property.
+
+
+
Note
Currently only output and not used yet.
+ +

Definition at line 1519 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddWeightToGenerator()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddWeightToGenerator (Types::name const & weight,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Adds a weight to the generator $\vertex\in\generators$.

+
Parameters
+ + + +
weightThe weight.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 2200 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddXcoordinateToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddXcoordinateToVertexProperty (Types::name const & xCoordinate,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add x-coordinate to the vertex property.

+
Parameters
+ + + +
xCoordinateThe x-coordinate or the bus.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1309 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddYcoordinateToVertexProperty()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AddYcoordinateToVertexProperty (Types::name const & yCoordinate,
TVertexProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Add y-coordinate to the vertex property.

+
Parameters
+ + + +
yCoordinateThe y-coordinate or the bus.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 1324 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AssociateGeneratorWithBus()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AssociateGeneratorWithBus (Types::name const & bus,
TGeneratorProperties & generatorProperty 
)
+ 		+inlineprivate
+
+ +

Associate the generator with a bus.

+
Parameters
+ + + +
busThe bus.
generatorPropertyThe generator property.
+
+
+ +

Definition at line 1657 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AssociateLoadWithVertex()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::PyPsaParser< GraphType >::AssociateLoadWithVertex (Types::string const & bus,
TLoadProperties & vertexProperty 
)
+ 		+inlineprivate
+
+ +

Associating the load with a bus.

+
Parameters
+ + + +
busThe bus.
vertexPropertyThe vertex property.
+
+
+ +

Definition at line 2991 of file PyPsaParser.hpp.

+ +
+
+ +

◆ CompressString()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::PyPsaParser< GraphType >::CompressString (QByteArray & list)
+ 		+inlineprivate
+
+ +

Compress the string by removing spaces.

+
Parameters
+ + +
listThe list.
+
+
+ +

Definition at line 727 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ExtractBusHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractBusHeader (QList< QByteArray > const & splitted)
+ 		+inlineprivate
+
+ +

Extract the bus header.

+

Dependent on the data some columns exist and some are missing. This method dynamically extracts the existing data.

+
Parameters
+ + +
splittedThe splitted line.
+
+
+
Returns
true if the extraction was successful, false otherwise.
+ +

Definition at line 775 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ExtractGeneratorHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractGeneratorHeader (QList< QByteArray > const & splitted)
+ 		+inlineprivate
+
+ +

Extract the generator header.

+

Dependent on the data some columns exist and some are missing. This method dynamically extracts the existing data.

+
Parameters
+ + +
splittedThe splitted line.
+
+
+
Returns
true if the extraction was successful, false otherwise.
+ +

Definition at line 970 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ExtractGeneratorMaximumRealPowerPuHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractGeneratorMaximumRealPowerPuHeader (QList< QByteArray > const & splitted)
+ 		+inlineprivate
+
+ +

Extract the existing generator maximum real power p.u. header.

+
Parameters
+ + +
splittedThe splitted string of one row/line.
+
+
+
Returns
true if the header could be extracted, false otherwise.
+ +

Definition at line 1087 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ExtractLineHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractLineHeader (QList< QByteArray > const & splitted)
+ 		+inlineprivate
+
+ +

Extract the line (branch) header.

+

Dependent on the data some columns exist and some are missing. This method dynamically extracts the existing data.

+
Parameters
+ + +
splittedThe splitted line.
+
+
+
Returns
true if the extraction was successful, false otherwise.
+ +

Definition at line 845 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::HasCorrectSnapshotSizes(), egoa::PyPsaParser< GraphType >::ReadBuses(), egoa::PyPsaParser< GraphType >::ReadGenerators(), egoa::PyPsaParser< GraphType >::ReadGeneratorsRealPowerMaxPu(), egoa::PyPsaParser< GraphType >::ReadLines(), egoa::PyPsaParser< GraphType >::ReadLoads(), and egoa::PyPsaParser< GraphType >::ReadLoadsPset().

+ +
+
+ +

◆ ExtractLoadHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractLoadHeader (QList< QByteArray > const & splitted,
Types::index & column 
)
+ 		+inlineprivate
+
+ +

Extract the existing load header data.

+
Parameters
+ + + +
splittedThe splitted string of one row/line.
columnThe column
+
+
+
Returns
true if the header could be extracted, false otherwise.
+ +

Definition at line 1132 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::AddCapitalCostToEdge().

+ +
+
+ +

◆ ExtractLoadMaximumRealPowerPuHeader()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ExtractLoadMaximumRealPowerPuHeader (QList< QByteArray > const & splitted)
+ 		+inlineprivate
+
+ +

Extract load maximum real power p.u.

+
Parameters
+ + +
splittedThe splitted string of one row/line.
+
+
+
Returns
true if the header could be extracted, false otherwise.
+ +

Definition at line 1176 of file PyPsaParser.hpp.

+ +
+
+ +

◆ HasCorrectSnapshotSizes()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::PyPsaParser< GraphType >::HasCorrectSnapshotSizes ()
+ 		+inlineprivate
+
+ +

Check if the snapshot size maps.

+
Returns
true the snapshot size maps, false otherwise.
+ +

Definition at line 754 of file PyPsaParser.hpp.

+ +
+
+ +

◆ OpenFile()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::OpenFile (QFile & file)
+ 		+inlineprivate
+
+ +

Opens a file.

+
Parameters
+ + +
fileThe file.
+
+
+
Returns
true file could be opened, false otherwise.
+ +

Definition at line 739 of file PyPsaParser.hpp.

+ +
+
+ +

◆ read() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::read (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read network $ \network $ from file.

+
Parameters
+ + + +
networkThe network network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename $\graph = (\vertices, \edges_{\mathrm{cand}})$.
+
+
+
Returns
true if the parsing was successful, false otherwise.
+ +

Definition at line 640 of file PyPsaParser.hpp.

+ +
+
+ +

◆ read() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::read (TNetwork & network,
TGraph & candidateNetwork,
std::string const & filename 
)
+ 		+inline
+
+ +

Read network and candidate network from file.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
candidateNetworkThe candidate network
filenameThe filename.
+
+
+
Returns
true if the parsing was successful, false otherwise.
+ +

Definition at line 655 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadBuses()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadBuses (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read the bus matrix.

+

While reading each line of the matrix a vertex is created and added to the network (see the bus section of https://pypsa.org/doc/components.html for more information).

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 171 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadCarriers()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadCarriers ()
+ 		+inline
+
+ +

Reads carriers.

+

For more information see the carrier section under https://pypsa.org/doc/components.html.

+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 211 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadCompleteNetwork() [1/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadCompleteNetwork (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Reads a complete network.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
[in]filenameThe filename.
+
+
+
Returns
true if the parsing was successful, false otherwise.
+ +

Definition at line 583 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadCompleteNetwork() [2/2]

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadCompleteNetwork (TNetwork & network,
TGraph & candidateNetwork,
std::string const & filename 
)
+ 		+inline
+
+ +

Reads a complete network and a candidate network.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
candidateNetworkThe candidate network $\graph = (\vertices, \edges_{\mathrm{cand}})$.
[in]filenameThe filename.
+
+
+
Returns
true if the parsing was successful, false otherwise.
+ +

Definition at line 606 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadGenerators()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadGenerators (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read the generator matrix.

+

While reading each row of the matrix a generator is created and added to the network. The description of the elements is as in https://pypsa.org/doc/components.html.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 276 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadGeneratorsRealPowerMaxPu()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadGeneratorsRealPowerMaxPu (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read generators maximum real power production snapshot in p.u.

+

For more information see the generator section under https://pypsa.org/doc/components.html.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 230 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::ExtractBusHeader(), egoa::PyPsaParser< GraphType >::filenameBuses_, egoa::PyPsaParser< GraphType >::mapBusName2VertexId_, egoa::PyPsaParser< GraphType >::OpenFile(), and egoa::PyPsaParser< GraphType >::ReadLine().

+ +
+
+ +

◆ ReadGlobalConstraints()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadGlobalConstraints ()
+ 		+inline
+
+ +

Sets the generator default values.

+

The description of the elements is as in https://pypsa.org/doc/components.html.

+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 334 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadLine()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
QList< QByteArray > egoa::PyPsaParser< GraphType >::ReadLine (QFile & file,
bool compress = true 
)
+ 		+inlineprivate
+
+ +

Reads a line.

+
Parameters
+ + + +
fileThe file.
[in]compressThe compress.
+
+
+
Returns
The line as array, where each field represents a column entry.
+ +

Definition at line 713 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadLines()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+
+template<typename Graph = TNetwork>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadLines (Graph & network,
const std::string & filename 
)
+ 		+inline
+
+ +

Reads branch (lines) matrix.

+

While reading each row of the matrix an arc is created and added to the network.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
[in]filenameThe filename.
+
+
+
Template Parameters
+ + +
GraphA graph type such as PowerGrid or StaticGraph.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 355 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadLoads()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadLoads (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read the load matrix that is a mapping of load to bus.

+

While reading each row of the matrix a mapping between load and bus is made and thus, the load is added to the network.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 476 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadLoadsPset()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadLoadsPset (TNetwork & network,
std::string const & filename 
)
+ 		+inline
+
+ +

Read loads real power set.

+

While reading each row of the matrix a real power load is added to the network.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
filenameThe filename.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 432 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadNetwork()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadNetwork (TNetwork & network)
+ 		+inline
+
+ +

Reads a network.

+

The description of the elements is as in https://pypsa.org/doc/components.html.

+
Parameters
+ + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 548 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadSnapshots()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadSnapshots (TNetwork & network)
+ 		+inline
+
+ +

Reads snapshots.

+

The description of the elements is as in https://pypsa.org/doc/components.html.

+
Parameters
+ + +
networkThe network $\network = ( \graph, \generators, \consumers, \capacity, \susceptance, \dots )$.
+
+
+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 565 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadStorageUnits()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadStorageUnits ()
+ 		+inline
+
+ +

Reads storage units.

+

For more information see the storage unit section under https://pypsa.org/doc/components.html.

+
Returns
True if the parsing was successful, False otherwise.
+ +

Definition at line 151 of file PyPsaParser.hpp.

+ +
+
+ +

◆ ReadStorageUnitsInflows()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + +
bool egoa::PyPsaParser< GraphType >::ReadStorageUnitsInflows ()
+ 		+inline
+
+ +

Read storage units in flow.

+

For more information see the storage unit section under https://pypsa.org/doc/components.html.

+
Returns
Returns true if the parsing was successful, false otherwise.
+ +

Definition at line 136 of file PyPsaParser.hpp.

+ +
+
+ +

◆ SetLineDefaultValues()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::PyPsaParser< GraphType >::SetLineDefaultValues (TIoEdge & edge)
+ 		+inline
+
+ +

Sets the branch default values.

+

The description of the elements is as in https://pypsa.org/doc/components.html.

+
Parameters
+ + +
edgeThe edge object.
+
+
+ +

Definition at line 395 of file PyPsaParser.hpp.

+ +

References egoa::PyPsaParser< GraphType >::mapBusName2VertexId_, egoa::PyPsaParser< GraphType >::mapGeneratorName2BusName_, egoa::PyPsaParser< GraphType >::mapGeneratorName2Identifier_, and egoa::PyPsaParser< GraphType >::ReadLine().

+ +
+
+ +

◆ SetLoadDefaultValues()

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + + + + + +
void egoa::PyPsaParser< GraphType >::SetLoadDefaultValues (TLoadProperties & vertex)
+ 		+inline
+
+ +

Sets the load default values.

+

The description of the elements is as in https://pypsa.org/doc/components.html.

+
Parameters
+ + +
vertexThe load vertex object.
+
+
+ +

Definition at line 532 of file PyPsaParser.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ dataMapperBuses_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<ElectricalVertexFunc> egoa::PyPsaParser< GraphType >::dataMapperBuses_
+ 		+private
+
+ +

Definition at line 1233 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperCandidateNetwork_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<ElectricalEdgeFunc> egoa::PyPsaParser< GraphType >::dataMapperCandidateNetwork_
+ 		+private
+
+ +

Definition at line 1239 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperGenerators_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<GeneratorVertexFunc> egoa::PyPsaParser< GraphType >::dataMapperGenerators_
+ 		+private
+
+ +

Definition at line 1236 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperGeneratorsRealPowerMaxPu_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<GeneratorMaximumRealPowerPuFunc> egoa::PyPsaParser< GraphType >::dataMapperGeneratorsRealPowerMaxPu_
+ 		+private
+
+ +

Definition at line 1235 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperLines_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<ElectricalEdgeFunc> egoa::PyPsaParser< GraphType >::dataMapperLines_
+ 		+private
+
+ +

Definition at line 1240 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperLoads_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<LoadVertexFunc> egoa::PyPsaParser< GraphType >::dataMapperLoads_
+ 		+private
+
+ +

Definition at line 1242 of file PyPsaParser.hpp.

+ +
+
+ +

◆ dataMapperLoadsRealPowerMaxPu_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<LoadMaximumRealPowerPuFunc> egoa::PyPsaParser< GraphType >::dataMapperLoadsRealPowerMaxPu_
+ 		+private
+
+ +

Definition at line 1243 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameBuses_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameBuses_
+ 		+private
+
+

Name of the bus file, e.g., buses.csv

+ +

Definition at line 3173 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameCarriers_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameCarriers_
+ 		+private
+
+

Name of the carriers file, e.g., carriers.csv

+ +

Definition at line 3174 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameGenerators_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameGenerators_
+ 		+private
+
+

Name of the generators file, e.g., generators.csv

+ +

Definition at line 3175 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameGeneratorsPMaxPu_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameGeneratorsPMaxPu_
+ 		+private
+
+

Name of the generators real power (in p.u.) snapshot file, e.g., generators-p_max_pu.csv

+ +

Definition at line 3176 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameGlobalConstraints_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameGlobalConstraints_
+ 		+private
+
+

Name of the global constraints file, e.g., global_constraints.csv

+ +

Definition at line 3177 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameLines_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameLines_
+ 		+private
+
+

Name of the branches file, e.g., lines.csv

+ +

Definition at line 3178 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameLinesNew_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameLinesNew_
+ 		+private
+
+

Name of the new branches file, e.g., lines_new.csv

+ +

Definition at line 3179 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameLoads_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameLoads_
+ 		+private
+
+

Name of the loads file, e.g., loads.csv

+ +

Definition at line 3180 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameLoadsPSet_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameLoadsPSet_
+ 		+private
+
+

Name of the loads real power set point snapshot file, e.g., loads-p_set.csv

+ +

Definition at line 3181 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameNetwork_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameNetwork_
+ 		+private
+
+

Name of the network file, e.g., network.csv

+ +

Definition at line 3182 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameSnapshots_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameSnapshots_
+ 		+private
+
+

Name of the file with the weighting of a snapshot, e.g., snapshot.csv

+ +

Definition at line 3183 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameStorageUnits_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameStorageUnits_
+ 		+private
+
+

Name of the file with the storage units, e.g., storage_units.csv

+ +

Definition at line 3184 of file PyPsaParser.hpp.

+ +
+
+ +

◆ filenameStorageUnitsInflow_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name const egoa::PyPsaParser< GraphType >::filenameStorageUnitsInflow_
+ 		+private
+
+

Name of the file with the storage units inflow, e.g., storage_units-inflow.csv

+ +

Definition at line 3185 of file PyPsaParser.hpp.

+ +
+
+ +

◆ generatorSnapshotsSize

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::count egoa::PyPsaParser< GraphType >::generatorSnapshotsSize
+ 		+private
+
+ +

Definition at line 3202 of file PyPsaParser.hpp.

+ +
+
+ +

◆ headerGeneratorMaximumRealPowerPu_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::vector<TGeneratorProperties*> egoa::PyPsaParser< GraphType >::headerGeneratorMaximumRealPowerPu_
+ 		+private
+
+ +

Definition at line 1214 of file PyPsaParser.hpp.

+ +
+
+ +

◆ loadSnapshotsSize

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::count egoa::PyPsaParser< GraphType >::loadSnapshotsSize
+ 		+private
+
+ +

Definition at line 3203 of file PyPsaParser.hpp.

+ +
+
+ +

◆ mapBusName2VertexId_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, Types::vertexId> egoa::PyPsaParser< GraphType >::mapBusName2VertexId_
+ 		+private
+
+

Mapping the bus name to the vertex identifier

+ +

Definition at line 3192 of file PyPsaParser.hpp.

+ +
+
+ +

◆ mapGeneratorName2BusName_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, Types::name> egoa::PyPsaParser< GraphType >::mapGeneratorName2BusName_
+ 		+private
+
+

Mapping the generator name to the vertex name

+ +

Definition at line 3195 of file PyPsaParser.hpp.

+ +
+
+ +

◆ mapGeneratorName2Generator_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, TGeneratorProperties> egoa::PyPsaParser< GraphType >::mapGeneratorName2Generator_
+ 		+private
+
+

Mapping the generator name to the generator

+ +

Definition at line 3193 of file PyPsaParser.hpp.

+ +
+
+ +

◆ mapGeneratorName2Identifier_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, Types::vertexId> egoa::PyPsaParser< GraphType >::mapGeneratorName2Identifier_
+ 		+private
+
+

Mapping the generator name to the vertex identifier

+ +

Definition at line 3194 of file PyPsaParser.hpp.

+ +
+
+ +

◆ mapLoadName2Identifier_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
std::unordered_map<Types::name, Types::vertexId> egoa::PyPsaParser< GraphType >::mapLoadName2Identifier_
+ 		+private
+
+

Mapping the load name to the vertex identifier

+ +

Definition at line 3196 of file PyPsaParser.hpp.

+ +
+
+ +

◆ path2FileDirectory_

+ +
+
+
+template<typename GraphType = StaticGraph< Vertices::ElectricalProperties<Vertices::IeeeBusType>, Edges::ElectricalProperties >>
+ + + + + +
+ + + + +
Types::name egoa::PyPsaParser< GraphType >::path2FileDirectory_
+ 		+private
+
+

The path to the PyPsa file directory, e.g., elec_s1024_AT

+ +

Definition at line 3172 of file PyPsaParser.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_queue-members.html b/classegoa_1_1_queue-members.html new file mode 100644 index 00000000..28e9bda0 --- /dev/null +++ b/classegoa_1_1_queue-members.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Queue< Type > Member List
+
+
+ +

This is the complete list of members for egoa::Queue< Type >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
breakable_for_all_elements(FUNCTION function) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
breakable_for_all_elements(FUNCTION function) const (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Clear()=0 (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinepure virtual
Empty() const =0egoa::Queue< Type >inlinepure virtual
for_all_elements(FUNCTION function) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
for_all_elements(FUNCTION function) const (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Pop()=0 (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinepure virtual
Push(TElement const &element)=0egoa::Queue< Type >inlinepure virtual
Push(TElement &&element)=0 (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinepure virtual
Queue() (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Compare const &compare) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Container const &container) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Queue(Compare const &compare, Container const &container) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
Size() const =0 (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinepure virtual
Swap(Queue &rhs) (defined in egoa::Queue< Type >)egoa::Queue< Type >inline
TElement typedef (defined in egoa::Queue< Type >)egoa::Queue< Type >private
Top() const =0egoa::Queue< Type >inlinepure virtual
~Queue() (defined in egoa::Queue< Type >)egoa::Queue< Type >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_queue.html b/classegoa_1_1_queue.html new file mode 100644 index 00000000..7da780e7 --- /dev/null +++ b/classegoa_1_1_queue.html @@ -0,0 +1,600 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Queue< Type > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Types | +List of all members
+
egoa::Queue< Type > Class Template Referenceabstract
+
+
+
+Inheritance diagram for egoa::Queue< Type >:
+
+
+ + +egoa::PriorityQueue< Type > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename Compare , class Container >
 Queue (Compare const &compare)
 
template<class Container >
 Queue (Container const &container)
 
template<typename Compare , class Container >
 Queue (Compare const &compare, Container const &container)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function)
 
template<bool IsParallel, typename FUNCTION >
void for_all_elements (FUNCTION function) const
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function)
 
template<typename FUNCTION >
void breakable_for_all_elements (FUNCTION function) const
 
virtual TElement const & Top () const =0
 
virtual void Push (TElement const &element)=0
 
+virtual void Push (TElement &&element)=0
 
+virtual void Pop ()=0
 
+virtual void Clear ()=0
 
void Swap (Queue &rhs)
 
virtual bool Empty () const =0
 
+virtual Types::count Size () const =0
 
+ + + +

+Private Types

using TElement = Type
 
+

Detailed Description

+
template<typename Type>
+class egoa::Queue< Type >
+

Definition at line 16 of file Queue.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::Queue< Type >::TElement = Type
+ 		+private
+
+ +

Definition at line 17 of file Queue.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Queue() [1/4]

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
egoa::Queue< Type >::Queue ()
+ 		+inline
+
+ +

Definition at line 21 of file Queue.hpp.

+ +
+
+ +

◆ Queue() [2/4]

+ +
+
+
+template<typename Type >
+
+template<typename Compare , class Container >
+ + + + + +
+ + + + + + + + +
egoa::Queue< Type >::Queue (Compare const & compare)
+ 		+inline
+
+ +

Definition at line 24 of file Queue.hpp.

+ +
+
+ +

◆ Queue() [3/4]

+ +
+
+
+template<typename Type >
+
+template<class Container >
+ + + + + +
+ + + + + + + + +
egoa::Queue< Type >::Queue (Container const & container)
+ 		+inline
+
+ +

Definition at line 27 of file Queue.hpp.

+ +
+
+ +

◆ Queue() [4/4]

+ +
+
+
+template<typename Type >
+
+template<typename Compare , class Container >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Queue< Type >::Queue (Compare const & compare,
Container const & container 
)
+ 		+inline
+
+ +

Definition at line 30 of file Queue.hpp.

+ +
+
+ +

◆ ~Queue()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual egoa::Queue< Type >::~Queue ()
+ 		+inlinevirtual
+
+ +

Definition at line 32 of file Queue.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ breakable_for_all_elements() [1/2]

+ +
+
+
+template<typename Type >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Queue< Type >::breakable_for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

Definition at line 42 of file Queue.hpp.

+ +
+
+ +

◆ breakable_for_all_elements() [2/2]

+ +
+
+
+template<typename Type >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Queue< Type >::breakable_for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Definition at line 45 of file Queue.hpp.

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual bool egoa::Queue< Type >::Empty () const
+ 		+inlinepure virtual
+
+

@Name Capacity

+ +

Implemented in egoa::PriorityQueue< Type >.

+ +
+
+ +

◆ for_all_elements() [1/2]

+ +
+
+
+template<typename Type >
+
+template<bool IsParallel, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Queue< Type >::for_all_elements (FUNCTION function)
+ 		+inline
+
+ +

Definition at line 36 of file Queue.hpp.

+ +
+
+ +

◆ for_all_elements() [2/2]

+ +
+
+
+template<typename Type >
+
+template<bool IsParallel, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::Queue< Type >::for_all_elements (FUNCTION function) const
+ 		+inline
+
+ +

Definition at line 39 of file Queue.hpp.

+ +
+
+ +

◆ Push()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + +
virtual void egoa::Queue< Type >::Push (TElement const & element)
+ 		+inlinepure virtual
+
+

@Name Modifiers

+ +

Implemented in egoa::PriorityQueue< Type >.

+ +
+
+ +

◆ Swap()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + +
void egoa::Queue< Type >::Swap (Queue< Type > & rhs)
+ 		+inline
+
+ +

Definition at line 61 of file Queue.hpp.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
virtual TElement const & egoa::Queue< Type >::Top () const
+ 		+inlinepure virtual
+
+

@Name Element Access

+ +

Implemented in egoa::PriorityQueue< Type >.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Queue.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_queue.png b/classegoa_1_1_queue.png new file mode 100644 index 00000000..47b0622c Binary files /dev/null and b/classegoa_1_1_queue.png differ diff --git a/classegoa_1_1_static_graph-members.html b/classegoa_1_1_static_graph-members.html new file mode 100644 index 00000000..32b4d39a --- /dev/null +++ b/classegoa_1_1_static_graph-members.html @@ -0,0 +1,187 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::StaticGraph< VertexProperties, EdgeProperties > Member List
+
+
+ +

This is the complete list of members for egoa::StaticGraph< VertexProperties, EdgeProperties >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
AddVertex(TVertexProperties const &properties)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
AddVertex(TVertexProperties &&properties)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
DegreeAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
DumpBranches(std::ostream &outputStream) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
DumpBuses(std::ostream &outputStream) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(Types::vertexId source, Types::vertexId target)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(Types::vertexId source, Types::vertexId target) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(int source, int target)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(char source, char target)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(char source, int target)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(int source, char target)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(int source, int target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(char source, char target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(int source, char target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edge(char source, int target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(Types::edgeId id)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(Types::edgeId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(int index)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(char index)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(int index) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeAt(char index) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeExists(Types::edgeId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeId(Types::vertexId source, Types::vertexId target) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeId(int source, int target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeId(char source, char target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeId(int source, char target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeId(char source, int target) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeIdsAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edges()egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Edges() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
edges_egoa::StaticGraph< VertexProperties, EdgeProperties >private
for_all_edge_identifiers(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edge_tuples(FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edge_tuples(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges(FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(TVertex const &vertex, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(TVertex const &vertex, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(Types::vertexId const vertexId, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_edges_at(Types::vertexId const vertexId, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_identifiers(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_tuples(FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_vertex_tuples(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_vertices(FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_all_vertices(FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(TVertex const &vertex, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(TVertex const &vertex, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(Types::vertexId vertexId, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_in_edges_at(Types::vertexId vertexId, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(TVertex const &vertex, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(TVertex const &vertex, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(Types::vertexId vertexId, FUNCTION function)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
for_out_edges_at(Types::vertexId vertexId, FUNCTION function) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
InDegreeAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
inEdgeIds_egoa::StaticGraph< VertexProperties, EdgeProperties >private
InEdgeIdsAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
MapEdges(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>egoa::StaticGraph< VertexProperties, EdgeProperties >inline
MapVertices(FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>egoa::StaticGraph< VertexProperties, EdgeProperties >inline
MaxDegree(Types::vertexId &id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
MaxDegree() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
MinDegree(Types::vertexId &id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
MinDegree() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
Name() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
name_egoa::StaticGraph< VertexProperties, EdgeProperties >private
NeighborsOf(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
NumberOfEdges() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
NumberOfVertices() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
operator<<egoa::StaticGraph< VertexProperties, EdgeProperties >friend
OutDegreeAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
outEdgeIds_egoa::StaticGraph< VertexProperties, EdgeProperties >private
OutEdgeIdsAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
StaticGraph() (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
StaticGraph(Types::name name) (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inlineexplicit
TConstEdgesView typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TConstVerticesView typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TEdge typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TEdgeId typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TEdgeProperties typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TEdgesView typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TGraph typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TVertex typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TVertexId typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TVertexProperties typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
TVerticesView typedef (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >
VertexAt(Types::vertexId id)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexAt(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexAt(int id)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexAt(char id)=delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexAt(int id) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexAt(char id) const =delete (defined in egoa::StaticGraph< VertexProperties, EdgeProperties >)egoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexExists(Types::vertexId id) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
VertexId(TVertex const &vertex) constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
Vertices()egoa::StaticGraph< VertexProperties, EdgeProperties >inline
Vertices() constegoa::StaticGraph< VertexProperties, EdgeProperties >inline
vertices_egoa::StaticGraph< VertexProperties, EdgeProperties >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_static_graph.html b/classegoa_1_1_static_graph.html new file mode 100644 index 00000000..d1fac5b0 --- /dev/null +++ b/classegoa_1_1_static_graph.html @@ -0,0 +1,3907 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::StaticGraph< VertexProperties, EdgeProperties > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +List of all members
+
egoa::StaticGraph< VertexProperties, EdgeProperties > Class Template Reference
+
+
+ +

A graph data structure that supports adding vertices and edges. + More...

+ +

#include <StaticGraph.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using TGraph = StaticGraph< VertexProperties, EdgeProperties >
 
using TVertexProperties = VertexProperties
 
using TVertex = Vertices::Vertex< TVertexProperties >
 
using TVertexId = Types::vertexId
 
using TEdgeProperties = EdgeProperties
 
using TEdge = Edges::Edge< TEdgeProperties >
 
using TEdgeId = Types::edgeId
 
using TVerticesView = VectorView< TVertex, false >
 
using TConstVerticesView = VectorView< TVertex, true >
 
using TEdgesView = VectorView< TEdge, false >
 
using TConstEdgesView = VectorView< TEdge, true >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 StaticGraph (Types::name name)
 
Getter and Setter
Types::name Name () const
 Name of the graph.
 
Types::count NumberOfVertices () const
 Number of vertices $n = |\vertices|$.
 
Types::count NumberOfEdges () const
 Number of edges $m = |\edges|$.
 
Vertex Related Methods
TVerticesView Vertices ()
 A view on the vertices.
 
TConstVerticesView Vertices () const
 A view on the vertices.
 
bool VertexExists (Types::vertexId id) const
 Whether a vertex with identifier id exists in the graph.
 
TVertex & VertexAt (Types::vertexId id)
 The vertex with identifier id.
 
TVertex const & VertexAt (Types::vertexId id) const
 The vertex with identifier id.
 
+TVertex & VertexAt (int id)=delete
 
+TVertex & VertexAt (char id)=delete
 
+TVertex const & VertexAt (int id) const =delete
 
+TVertex const & VertexAt (char id) const =delete
 
Types::vertexId VertexId (TVertex const &vertex) const
 The vertex identifier of a vertex object.
 
Types::vertexId AddVertex (TVertexProperties const &properties)
 Adds a vertex.
 
Types::vertexId AddVertex (TVertexProperties &&properties)
 Adds a vertex.
 
template<typename FUNCTION >
auto MapVertices (FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::vertexId >(), std::declval< TVertex >()))>
 Applies function to all vertices and collects the result in a vector.
 
std::vector< Types::vertexId > NeighborsOf (Types::vertexId id) const
 Neighbors of a vertex.
 
void NeighborsOf (Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const
 Neighbors of a vertex.
 
Types::count InDegreeAt (Types::vertexId id) const
 The indegree of the vertex with identifier id.
 
Types::count OutDegreeAt (Types::vertexId id) const
 The outdegree of the vertex with identifier id.
 
Types::count DegreeAt (Types::vertexId id) const
 The degree of the vertex with identifier id.
 
std::vector< Types::edgeId > const & InEdgeIdsAt (Types::vertexId id) const
 The identifiers of all incoming edges.
 
std::vector< Types::edgeId > const & OutEdgeIdsAt (Types::vertexId id) const
 The identifiers of all outgoing edges.
 
std::vector< Types::edgeId > EdgeIdsAt (Types::vertexId id) const
 All edge identifiers of edges incident to a vertex.
 
void EdgeIdsAt (Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const
 All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.
 
Edge related methods
TEdgesView Edges ()
 A view on the edges.
 
TConstEdgesView Edges () const
 A view on the edges.
 
bool EdgeExists (Types::edgeId id) const
 Whether an edge with the identifier id exists in the graph.
 
TEdge & EdgeAt (Types::edgeId id)
 The edge with identifier id.
 
TEdge const & EdgeAt (Types::edgeId id) const
 The edge with identifier id.
 
Types::edgeId EdgeId (Types::vertexId source, Types::vertexId target) const
 Searches for the identifier of the edge $(\vertexa, \vertexb)$.
 
TEdge & Edge (Types::vertexId source, Types::vertexId target)
 Searches for an edge $(\vertexa, \vertexb)$.
 
TEdge const & Edge (Types::vertexId source, Types::vertexId target) const
 Searches for an edge $(\vertexa, \vertexb)$.
 
Types::edgeId AddEdge (Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)
 Adds an edge to the set of edges $\edges$.
 
Types::edgeId AddEdge (Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)
 Adds an edge to the set of edges $\edges$.
 
template<typename FUNCTION >
auto MapEdges (FUNCTION function) const -> std::vector< decltype(function(std::declval< Types::edgeId >(), std::declval< TEdge >()))>
 Applies function to all edges and collects the result in a vector.
 
+TEdge & EdgeAt (int index)=delete
 
+TEdge & EdgeAt (char index)=delete
 
+TEdge const & EdgeAt (int index) const =delete
 
+TEdge const & EdgeAt (char index) const =delete
 
+Types::edgeId EdgeId (int source, int target) const =delete
 
+Types::edgeId EdgeId (char source, char target) const =delete
 
+Types::edgeId EdgeId (int source, char target) const =delete
 
+Types::edgeId EdgeId (char source, int target) const =delete
 
+TEdge & Edge (int source, int target)=delete
 
+TEdge & Edge (char source, char target)=delete
 
+TEdge & Edge (char source, int target)=delete
 
+TEdge & Edge (int source, char target)=delete
 
+TEdge const & Edge (int source, int target) const =delete
 
+TEdge const & Edge (char source, char target) const =delete
 
+TEdge const & Edge (int source, char target) const =delete
 
+TEdge const & Edge (char source, int target) const =delete
 
Graph Properties
Types::count MinDegree (Types::vertexId &id) const
 The minimum degree of the graph $\graph$.
 
Types::count MinDegree () const
 The minimum degree of the graph $\graph$.
 
Types::count MaxDegree (Types::vertexId &id) const
 The maximum degree of the graph $\graph$.
 
Types::count MaxDegree () const
 The maximum degree of the graph $\graph$.
 
Vertex Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_identifiers (FUNCTION function) const
 The for loop over all vertex identifiers in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertices (FUNCTION function)
 The for loop over all vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertices (FUNCTION function) const
 The for loop over all vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_tuples (FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_vertex_tuples (FUNCTION function) const
 The for loop over all pairs of vertex identifiers and vertex objects in the graph.
 
Edge Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_identifiers (FUNCTION function) const
 The for loop over all identifiers of edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges (FUNCTION function)
 The for loop over all edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges (FUNCTION function) const
 The for loop over all edges in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_tuples (FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edge_tuples (FUNCTION function) const
 The for loop over all pairs of edge identifiers and edge objects in the graph.
 
Neighborhood Loops
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex object.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all edges at a vertex object.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (Types::vertexId const vertexId, FUNCTION function)
 The for loop over all edges at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_all_edges_at (Types::vertexId const vertexId, FUNCTION function) const
 The for loop over all edges at a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_in_edges_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all incoming edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (TVertex const &vertex, FUNCTION function) const
 The for loop over all outgoing edges of a vertex.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (Types::vertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges.
 
template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
void for_out_edges_at (Types::vertexId vertexId, FUNCTION function) const
 The for loop over all outgoing edges.
 
+ + + + + + + + + + + +

+Private Attributes

Types::name name_
 
std::vector< TVertex > vertices_
 
std::vector< TEdge > edges_
 
std::vector< std::vector< Types::edgeId > > inEdgeIds_
 
std::vector< std::vector< Types::edgeId > > outEdgeIds_
 
+ + + + + + + + + + +

Output

void DumpBuses (std::ostream &outputStream) const
 Dumps buses.
 
void DumpBranches (std::ostream &outputStream) const
 Dumps branches.
 
std::ostream & operator<< (std::ostream &outputStream, StaticGraph const &rhs)
 Write the static graph to an output stream.
 
+

Detailed Description

+
template<typename VertexProperties, typename EdgeProperties>
+class egoa::StaticGraph< VertexProperties, EdgeProperties >

A graph data structure that supports adding vertices and edges.

+

Both VertexProperties and EdgeProperties must be able to store an identifier, which can be accessed in the following way. Here, vertex and constVertex are objects of type VertexProperties and VertexProperties const, respectively, and vId is of type Types::vertexId. Similarly, edge and constEdge are objects of type EdgeProperties and EdgeProperties const, respectively, and eId is of type Types::edgeId.

+ + + + + + + + + + + + + + + +
Operation Effect
vertex.Identifier() = vId;
+
egoa::StaticGraph::for_all_vertex_identifiers
void for_all_vertex_identifiers(FUNCTION function) const
The for loop over all vertex identifiers in the graph.
Definition StaticGraph.hpp:923
+
The identifier of vertex is set to vId.
Types::vertexId vId = constVertex.Identifier();
+
vId is set to the identifier of vertex.
edge.Identifier() = eId;
+
The identifier of edge is set to eId.
Types::edgeId eId = constEdge.Identifier();
+
eId is set to the identifier of edge.
Types::vertexId vId = constEdge.Source();
+
vId is set to the identifier of the source of edge.
Types::vertexId vId = constEdge.Target();
+
vId is set to the identifier of the target of edge.
+
Template Parameters
+ + + +
VertexPropertiesType of a vertex, e.g., ElectricalVertex.
EdgePropertiesType of an edge, e.g., ElectricalEdge.
+
+
+ +

Definition at line 52 of file StaticGraph.hpp.

+

Member Typedef Documentation

+ +

◆ TConstEdgesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TConstEdgesView = VectorView<TEdge, true>
+
+ +

Definition at line 69 of file StaticGraph.hpp.

+ +
+
+ +

◆ TConstVerticesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TConstVerticesView = VectorView<TVertex, true>
+
+ +

Definition at line 67 of file StaticGraph.hpp.

+ +
+
+ +

◆ TEdge

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TEdge = Edges::Edge<TEdgeProperties>
+
+ +

Definition at line 63 of file StaticGraph.hpp.

+ +
+
+ +

◆ TEdgeId

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TEdgeId = Types::edgeId
+
+ +

Definition at line 64 of file StaticGraph.hpp.

+ +
+
+ +

◆ TEdgeProperties

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TEdgeProperties = EdgeProperties
+
+ +

Definition at line 62 of file StaticGraph.hpp.

+ +
+
+ +

◆ TEdgesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TEdgesView = VectorView<TEdge, false>
+
+ +

Definition at line 68 of file StaticGraph.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TGraph = StaticGraph<VertexProperties , EdgeProperties>
+
+ +

Definition at line 55 of file StaticGraph.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TVertex = Vertices::Vertex<TVertexProperties>
+
+ +

Definition at line 59 of file StaticGraph.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TVertexId = Types::vertexId
+
+ +

Definition at line 60 of file StaticGraph.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TVertexProperties = VertexProperties
+
+ +

Definition at line 58 of file StaticGraph.hpp.

+ +
+
+ +

◆ TVerticesView

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + +
using egoa::StaticGraph< VertexProperties, EdgeProperties >::TVerticesView = VectorView<TVertex, false>
+
+ +

Definition at line 66 of file StaticGraph.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ StaticGraph() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
egoa::StaticGraph< VertexProperties, EdgeProperties >::StaticGraph ()
+ 		+inline
+
+ +

Definition at line 75 of file StaticGraph.hpp.

+ +
+
+ +

◆ StaticGraph() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
egoa::StaticGraph< VertexProperties, EdgeProperties >::StaticGraph (Types::name name)
+ 		+inlineexplicit
+
+ +

Definition at line 79 of file StaticGraph.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddEdge() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::StaticGraph< VertexProperties, EdgeProperties >::AddEdge (Types::vertexId source,
Types::vertexId target,
TEdgeProperties && properties 
)
+ 		+inline
+
+ +

Adds an edge to the set of edges $\edges$.

+
Precondition
Source and target of the edge are existing vertices.
+
Parameters
+ + + + +
[in]sourceThe source vertex identifier.
[in]targetThe target vertex identifier.
propertiesThe vertex properties.
+
+
+
Returns
The edge identifier.
+ +

Definition at line 672 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_, egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfEdges(), egoa::StaticGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ AddEdge() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::StaticGraph< VertexProperties, EdgeProperties >::AddEdge (Types::vertexId source,
Types::vertexId target,
TEdgeProperties const & properties 
)
+ 		+inline
+
+ +

Adds an edge to the set of edges $\edges$.

+
Precondition
Source and target of the edge are existing vertices.
+
Parameters
+ + + + +
[in]sourceThe source vertex identifier.
[in]targetThe target vertex identifier.
propertiesThe vertex properties.
+
+
+
Returns
The edge identifier.
+ +

Definition at line 652 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::AddEdge(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ AddVertex() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::StaticGraph< VertexProperties, EdgeProperties >::AddVertex (TVertexProperties && properties)
+ 		+inline
+
+ +

Adds a vertex.

+
Parameters
+ + +
propertiesThe vertex properties.
+
+
+
Returns
The identifier of the vertex.
+ +

Definition at line 241 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), egoa::StaticGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ AddVertex() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::StaticGraph< VertexProperties, EdgeProperties >::AddVertex (TVertexProperties const & properties)
+ 		+inline
+
+ +

Adds a vertex.

+
Parameters
+ + +
propertiesThe vertex properties.
+
+
+
Returns
The identifier of the vertex.
+ +

Definition at line 229 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::AddVertex(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ DegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::DegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The degree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of incident edges.
+ +

Definition at line 389 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::InDegreeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::OutDegreeAt(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ DumpBranches()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::DumpBranches (std::ostream & outputStream) const
+ 		+inline
+
+ +

Dumps branches.

+
Parameters
+ + +
outputStreamThe stream to write data to
+
+
+ +

Definition at line 860 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexAt().

+ +
+
+ +

◆ DumpBuses()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::DumpBuses (std::ostream & outputStream) const
+ 		+inline
+
+ +

Dumps buses.

+
Parameters
+ + +
outputStreamThe stream to write data to
+
+
+ +

Definition at line 844 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ Edge() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TEdge & egoa::StaticGraph< VertexProperties, EdgeProperties >::Edge (Types::vertexId source,
Types::vertexId target 
)
+ 		+inline
+
+ +

Searches for an edge $(\vertexa, \vertexb)$.

+
Precondition
Both source and target are identifiers of existing vertices, and there is an edge from source to target.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa, \vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa, \vertexb)$.
+
+
+
Returns
The edge $(\vertexa, \vertexb)$.
+ +

Definition at line 606 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeId(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ Edge() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
TEdge const & egoa::StaticGraph< VertexProperties, EdgeProperties >::Edge (Types::vertexId source,
Types::vertexId target 
) const
+ 		+inline
+
+ +

Searches for an edge $(\vertexa, \vertexb)$.

+
Precondition
Both source and target are identifiers of existing vertices, and there is an edge from source to target.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa, \vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa, \vertexb)$.
+
+
+
Returns
The edge $(\vertexa, \vertexb)$.
+ +

Definition at line 630 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeId(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TEdge & egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt (Types::edgeId id)
+ 		+inline
+
+ +

The edge with identifier id.

+
Precondition
The edge with identifier id exists.
+
Parameters
+ + +
[in]idThe edge identifier.
+
+
+
Returns
The edge object with identifier id.
+ +

Definition at line 533 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ EdgeAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TEdge const & egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt (Types::edgeId id) const
+ 		+inline
+
+ +

The edge with identifier id.

+
Precondition
The edge with identifier id exists.
+
Parameters
+ + +
[in]idThe edge identifier.
+
+
+
Returns
The edge object with identifier id.
+ +

Definition at line 548 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeExists(), egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ EdgeExists()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
bool egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeExists (Types::edgeId id) const
+ 		+inline
+
+ +

Whether an edge with the identifier id exists in the graph.

+
Parameters
+ + +
[in]idThe edge identifier
+
+
+
Returns
true if an edge with identifier id exists, false otherwise.
+ +

Definition at line 519 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfEdges().

+ +
+
+ +

◆ EdgeId()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Types::edgeId egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeId (Types::vertexId source,
Types::vertexId target 
) const
+ 		+inline
+
+ +

Searches for the identifier of the edge $(\vertexa, \vertexb)$.

+

If no such edge exists, Const::NONE is returned.

+
Precondition
Both source and target are identifiers of existing vertices.
+
Parameters
+ + + +
[in]sourceThe source vertex $\vertexa$ of the edge $(\vertexa,\vertexb)$.
[in]targetThe target vertex $\vertexb$ of the edge $(\vertexa,\vertexb)$.
+
+
+
Returns
The edge identifier, or Const::NONE if the edge does not exist.
+ +

Definition at line 569 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::InDegreeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::inEdgeIds_, egoa::StaticGraph< VertexProperties, EdgeProperties >::OutDegreeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeIdsAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

All edge identifiers of edges incident to a vertex.

+

The order of the identifiers is unspecified.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The edge identifiers at a vertex id.
+ +

Definition at line 435 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeIdsAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ EdgeIdsAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeIdsAt (Types::vertexId id,
std::vector< Types::edgeId > & edgeIds 
) const
+ 		+inline
+
+ +

All edge identifiers of edges incident to a vertex are added to the end of the vector edgeIds.

+

The order of the identifiers is unspecified.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + + +
[in]idThe vertex id
edgeIdsThe vector to which the edge identifiers are appended.
+
+
+ +

Definition at line 456 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ Edges() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TEdgesView egoa::StaticGraph< VertexProperties, EdgeProperties >::Edges ()
+ 		+inline
+
+ +

A view on the edges.

+

The edges can be modified via this view. 

        If an edge is added, the view is still valid but
+        the iterators obtained via this view are
+        invalidated.
+
+        If the graphs is destroyed, all view are
+        invalidated and calling any member function on them
+        has undefined behavior.
+
Returns
A view on the edges
+ +

Definition at line 486 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_.

+ +
+
+ +

◆ Edges() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TConstEdgesView egoa::StaticGraph< VertexProperties, EdgeProperties >::Edges () const
+ 		+inline
+
+ +

A view on the edges.

+

The edges cannot be modified via this view. 

        If an edge is added, the view is still valid but
+        the iterators obtained via this view are
+        invalidated.
+
+        If the graphs is destroyed, all view are
+        invalidated and calling any member function on them
+        has undefined behavior.
+
Returns
A view on the edges
+ +

Definition at line 505 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_.

+ +
+
+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edge_identifiers (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all identifiers of edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
for_all_edge_identifiers (
+
[]( Types::edgeId edgeId )
+
{
+
// Do something with the edge identifier.
+
}
+
);
+
egoa::StaticGraph::for_all_edge_identifiers
void for_all_edge_identifiers(FUNCTION function) const
The for loop over all identifiers of edges in the graph.
Definition StaticGraph.hpp:1061
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1061 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edge_tuples() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edge_tuples (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TEdge, e.g.,
for_all_edge_tuples (
+
[]( Types::edgeId edgeId, TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::Edges::Edge
Class for edge.
Definition Edge.hpp:27
+
egoa::StaticGraph::for_all_edge_tuples
void for_all_edge_tuples(FUNCTION function)
The for loop over all pairs of edge identifiers and edge objects in the graph.
Definition StaticGraph.hpp:1141
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1141 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edge_tuples() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edge_tuples (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TEdge, e.g.,
for_all_edge_tuples (
+
[]( Types::edgeId edgeId, TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1169 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type TEdge, e.g.,
for_all_edges (
+
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::StaticGraph::for_all_edges
void for_all_edges(FUNCTION function)
The for loop over all edges in the graph.
Definition StaticGraph.hpp:1087
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy..
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1087 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all edges in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all edges. It must accept one argument of type TEdge, e.g.,
for_all_edges (
+
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1113 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all edges at a vertex object.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_all_edges_at<ExecutionPolicy::sequential>( vertex
+
, []( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incident edges at vertexId.
+
+
+ +

Definition at line 1202 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all edges at a vertex object.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_all_edges_at<ExecutionPolicy::sequential>( vertex
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incident edges at vertexId.
+
+
+ +

Definition at line 1232 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges_at (Types::vertexId const vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all edges at a vertex.

+

This is a loop over incoming and outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_all_edges_at ( vertexId
+
, []( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::StaticGraph::for_all_edges_at
void for_all_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all edges at a vertex object.
Definition StaticGraph.hpp:1202
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incident edges at vertexId.
+
+
+ +

Definition at line 1264 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_all_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_edges_at (Types::vertexId const vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all edges at a vertex.

+

This is a loop over incoming and outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all edges at the vertex. It must accept one argument of type TEdge, e.g.,
+
+
+
for_all_edges_at ( vertexId
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incident edges at vertexId.
+
+
+ +

Definition at line 1298 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all vertex identifiers in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type Types::vertexId, e.g.,
for_all_vertex_identifiers (
+
[]( Types::vertexId vertexId )
+
{
+
// Do something with the vertex identifier.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 923 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertex_tuples() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_tuples (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all pairs of vertex identifiers and vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TVertex, e.g.,
for_all_vertex_tuples (
+
[]( Types::vertexId id, TVertex const & vertex )
+
{
+
// Do something with the vertex identifier and object
+
}
+
);
+
egoa::StaticGraph::for_all_vertex_tuples
void for_all_vertex_tuples(FUNCTION function)
The for loop over all pairs of vertex identifiers and vertex objects in the graph.
Definition StaticGraph.hpp:1003
+
egoa::Vertices::Vertex
Class for a vertex.
Definition Vertex.hpp:29
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1003 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertex_tuples() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_tuples (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all pairs of vertex identifiers and vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TVertex, e.g.,
for_all_vertex_tuples (
+
[]( Types::vertexId id, TVertex const & vertex )
+
{
+
// Do something with the vertex identifier and object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 1030 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertices() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertices (FUNCTION function)
+ 		+inline
+
+ +

The for loop over all vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type TVertex, e.g.,
for_all_vertices (
+
[]( TVertex & vertex )
+
{
+
// Do something with the vertex object.
+
}
+
);
+
egoa::StaticGraph::for_all_vertices
void for_all_vertices(FUNCTION function)
The for loop over all vertex objects in the graph.
Definition StaticGraph.hpp:949
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 949 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_all_vertices() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertices (FUNCTION function) const
+ 		+inline
+
+ +

The for loop over all vertex objects in the graph.

+
Parameters
+ + +
[in]functionThe function object that is called for all vertices. It must accept one argument of type TVertex, e.g.,
for_all_vertices (
+
[]( TVertex const & vertex )
+
{
+
// Do something with the vertex object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 975 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_in_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_all_edges_at ( vertex
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
FUNCTIONThe function object that is called for all incident incoming edges at vertexId.
+
+
+ +

Definition at line 1328 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_in_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_in_edges_at ( vertex
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::StaticGraph::for_in_edges_at
void for_in_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all incoming edges of a vertex.
Definition StaticGraph.hpp:1328
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId.
+
+
+ +

Definition at line 1357 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_in_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_in_edges_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe identifier of the vertex
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_in_edges_at ( vertexId
+
, []( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId
+
+
+ +

Definition at line 1387 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_in_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_in_edges_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all incoming edges of a vertex.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe identifier of the vertex
[in]functionThe function object that is called for all incoming edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_in_edges_at ( vertexId
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all incoming edges at vertexId
+
+
+ +

Definition at line 1418 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_out_edges_at() [1/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_out_edges_at (TVertex const & vertex,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all outgoing edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_out_edges_at ( vertex
+
, []( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::StaticGraph::for_out_edges_at
void for_out_edges_at(TVertex const &vertex, FUNCTION function)
The for loop over all outgoing edges of a vertex.
Definition StaticGraph.hpp:1447
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy
FUNCTIONThe function object that is called for all outgoing edges of vertex
+
+
+ +

Definition at line 1447 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_out_edges_at() [2/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_out_edges_at (TVertex const & vertex,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all outgoing edges of a vertex.

+
Parameters
+ + + +
[in]vertexThe vertex object.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_out_edges_at ( vertex
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex
+
+
+ +

Definition at line 1475 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ for_out_edges_at() [3/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_out_edges_at (Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inline
+
+ +

The for loop over all outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_out_edges_at ( vertexId
+
, []( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1507 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ for_out_edges_at() [4/4]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<ExecutionPolicy Policy = ExecutionPolicy::sequential, typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::for_out_edges_at (Types::vertexId vertexId,
FUNCTION function 
) const
+ 		+inline
+
+ +

The for loop over all outgoing edges.

+
Precondition
There is a vertex with identifier vertexId.
+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]functionThe function object that is called for all outgoing edges at the vertex. It must accept one argument of type TEdge, e.g.,
for_out_edges_at ( vertexId
+
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
+
+
+
Template Parameters
+ + + +
PolicyThe execution policy.
FUNCTIONThe function object that is called for all outgoing edges of vertex.
+
+
+ +

Definition at line 1540 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ InDegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::InDegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The indegree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of incoming edges.
+ +

Definition at line 359 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ InEdgeIdsAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > const & egoa::StaticGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

The identifiers of all incoming edges.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The identifiers of the incoming edges at vertex id.
+ +

Definition at line 404 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::inEdgeIds_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ MapEdges()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
auto egoa::StaticGraph< VertexProperties, EdgeProperties >::MapEdges (FUNCTION function) const -> std::vector<decltype(function(std::declval<Types::edgeId>(), std::declval<TEdge>()))> +
+ 		+inline
+
+ +

Applies function to all edges and collects the result in a vector.

+
Parameters
+ + +
[in]functionThe function that is applied to all edges.
TResult function(Types::edgeId, TEdge)
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+
Returns
A vector containing the results of the applications of function to all edges.
+ +

Definition at line 708 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ MapVertices()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + +
auto egoa::StaticGraph< VertexProperties, EdgeProperties >::MapVertices (FUNCTION function) const -> std::vector<decltype(function(std::declval<Types::vertexId>(), std::declval<TVertex>()))> +
+ 		+inline
+
+ +

Applies function to all vertices and collects the result in a vector.

+
Parameters
+ + +
[in]functionThe function that is applied to all edges.
TResult function ( Types::vertexId, TVertex )
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+
Returns
A vector containing the results of the applications of function to all vertices.
+ +

Definition at line 272 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ MaxDegree() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::MaxDegree () const
+ 		+inline
+
+ +

The maximum degree of the graph $\graph$.

+

The maximum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Returns
The maximum degree.
+ +

Definition at line 828 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::MaxDegree().

+ +
+
+ +

◆ MaxDegree() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::MaxDegree (Types::vertexId & id) const
+ 		+inline
+
+ +

The maximum degree of the graph $\graph$.

+

The maximum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Parameters
+ + +
[in/out]id The vertex identifier with the maximum degree. If there are multiple vertices with the maximum degree, the one with the smallest identifier is returned. If the graph is empty, id is set to Const::NONE.
+
+
+
Returns
The maximum degree.
+ +

Definition at line 803 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::DegreeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ MinDegree() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::MinDegree () const
+ 		+inline
+
+ +

The minimum degree of the graph $\graph$.

+

The minimum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Returns
The minimum degree.
+ +

Definition at line 783 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::MinDegree().

+ +
+
+ +

◆ MinDegree() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::MinDegree (Types::vertexId & id) const
+ 		+inline
+
+ +

The minimum degree of the graph $\graph$.

+

The minimum number of edges incident to any vertex in the graph. If the graph is empty, 0 is returned.

+
Parameters
+ + +
idThe vertex identifier with the minimum degree. If there are multiple vertices with the minimum degree, the one with the smallest identifier is returned. If the graph is empty, id is set to Const::NONE.
+
+
+
Returns
The minimum degree.
+ +

Definition at line 758 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::DegreeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ Name()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::name egoa::StaticGraph< VertexProperties, EdgeProperties >::Name () const
+ 		+inline
+
+ +

Name of the graph.

+
Returns
The name of the graph.
+ +

Definition at line 93 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::name_.

+ +
+
+ +

◆ NeighborsOf() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::vertexId > egoa::StaticGraph< VertexProperties, EdgeProperties >::NeighborsOf (Types::vertexId id) const
+ 		+inline
+
+ +

Neighbors of a vertex.

+

A vector containing the identifiers of the neighbors of the given vertex is returned. The order of the neighbors is unspecified.

+
Precondition
The vertex with identifier id exists.
+
Parameters
+ + +
[in]idThe id of a vertex.
+
+
+
Returns
The vertex identifiers of all neighbors.
+ +

Definition at line 300 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::NeighborsOf(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ NeighborsOf() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::StaticGraph< VertexProperties, EdgeProperties >::NeighborsOf (Types::vertexId id,
std::vector< Types::vertexId > & vertexIds 
) const
+ 		+inline
+
+ +

Neighbors of a vertex.

+

The neighbors of the vertex are appended to the vector vertexId. The order of the neighbors is unspecified.

+

Time complexity: $O(|\vertices|)$.

+
Precondition
The vertex with identifier id exists.
+
Parameters
+ + + +
[in]idThe vertex identifier.
vertexIdsThe vector to which the identifiers of the neighbors are appended.
+
+
+ +

Definition at line 323 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::EdgeAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::InEdgeIdsAt(), egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices(), egoa::StaticGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ NumberOfEdges()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfEdges () const
+ 		+inline
+
+ +

Number of edges $m = |\edges|$.

+
Returns
The number of edges $m = |\edges|$.
+ +

Definition at line 113 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_.

+ +
+
+ +

◆ NumberOfVertices()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices () const
+ 		+inline
+
+ +

Number of vertices $n = |\vertices|$.

+
Returns
The number of vertices $n = |\vertices|$.
+ +

Definition at line 103 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ OutDegreeAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::count egoa::StaticGraph< VertexProperties, EdgeProperties >::OutDegreeAt (Types::vertexId id) const
+ 		+inline
+
+ +

The outdegree of the vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The number of outgoing edges.
+ +

Definition at line 374 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ OutEdgeIdsAt()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
std::vector< Types::edgeId > const & egoa::StaticGraph< VertexProperties, EdgeProperties >::OutEdgeIdsAt (Types::vertexId id) const
+ 		+inline
+
+ +

The identifiers of all outgoing edges.

+
Precondition
There is a vertex with identifier id in the graph.
+
Parameters
+ + +
[in]idThe vertex identifier.
+
+
+
Returns
The identifiers of the outgoing edges at vertex id.
+ +

Definition at line 419 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::outEdgeIds_, and egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists().

+ +
+
+ +

◆ VertexAt() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TVertex & egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexAt (Types::vertexId id)
+ 		+inline
+
+ +

The vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+

param[in] id The identifier of the vertex.

+
Returns
The vertex object.
+ +

Definition at line 182 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ VertexAt() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
TVertex const & egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexAt (Types::vertexId id) const
+ 		+inline
+
+ +

The vertex with identifier id.

+
Precondition
There is a vertex with identifier id in the graph.
+

param[in] id The identifier of the vertex.

+
Returns
The vertex object.
+ +

Definition at line 197 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers(), egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists(), and egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ VertexExists()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
bool egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexExists (Types::vertexId id) const
+ 		+inline
+
+ +

Whether a vertex with identifier id exists in the graph.

+
Parameters
+ + +
[in]idThe identifier of the vertex.
+
+
+
Returns
true if a vertex with identifier id exists, false otherwise.
+ +

Definition at line 168 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::NumberOfVertices().

+ +
+
+ +

◆ VertexId()

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::StaticGraph< VertexProperties, EdgeProperties >::VertexId (TVertex const & vertex) const
+ 		+inline
+
+ +

The vertex identifier of a vertex object.

+

Calls vertex.Identifier().

+
Parameters
+ + +
[in]vertexThe vertex.
+
+
+
Returns
The vertex identifier.
+ +

Definition at line 217 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::for_all_vertex_identifiers().

+ +
+
+ +

◆ Vertices() [1/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TVerticesView egoa::StaticGraph< VertexProperties, EdgeProperties >::Vertices ()
+ 		+inline
+
+ +

A view on the vertices.

+

If a vertex is added, the view is still valid but the iterators obtained via this view are invalidated.

+

If the graphs is destroyed, all views are invalidated and calling any member function on them has undefined behavior.

+
Returns
A view on the vertices
+ +

Definition at line 136 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+ +

◆ Vertices() [2/2]

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + +
TConstVerticesView egoa::StaticGraph< VertexProperties, EdgeProperties >::Vertices () const
+ 		+inline
+
+ +

A view on the vertices.

+

The vertices can be modified via this view. 

        If a vertex is added, the view is still valid but
+        the iterators obtained via this view are
+        invalidated.
+
+        If the graphs is destroyed, all views are
+        invalidated and calling any member function on them
+        has undefined behavior.
+
Returns
A view on the vertices.
+ +

Definition at line 155 of file StaticGraph.hpp.

+ +

References egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
StaticGraph< VertexProperties, EdgeProperties > const & rhs 
)
+ 		+friend
+
+ +

Write the static graph to an output stream.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
rhsThe right hand side static graph.
+
+
+
Returns
The output stream.
+ +

Definition at line 881 of file StaticGraph.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ edges_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<TEdge> egoa::StaticGraph< VertexProperties, EdgeProperties >::edges_
+ 		+private
+
+

Vector of edges

+ +

Definition at line 1555 of file StaticGraph.hpp.

+ +
+
+ +

◆ inEdgeIds_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector< std::vector<Types::edgeId> > egoa::StaticGraph< VertexProperties, EdgeProperties >::inEdgeIds_
+ 		+private
+
+

Ids of the incoming edges per vertex

+ +

Definition at line 1557 of file StaticGraph.hpp.

+ +
+
+ +

◆ name_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
Types::name egoa::StaticGraph< VertexProperties, EdgeProperties >::name_
+ 		+private
+
+

Name of the graph, e.g., bus14

+ +

Definition at line 1551 of file StaticGraph.hpp.

+ +
+
+ +

◆ outEdgeIds_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector< std::vector<Types::edgeId> > egoa::StaticGraph< VertexProperties, EdgeProperties >::outEdgeIds_
+ 		+private
+
+

Ids of the outgoing edges per vertex

+ +

Definition at line 1558 of file StaticGraph.hpp.

+ +
+
+ +

◆ vertices_

+ +
+
+
+template<typename VertexProperties , typename EdgeProperties >
+ + + + + +
+ + + + +
std::vector<TVertex> egoa::StaticGraph< VertexProperties, EdgeProperties >::vertices_
+ 		+private
+
+

Vector of vertices

+ +

Definition at line 1553 of file StaticGraph.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_std_queue-members.html b/classegoa_1_1_std_queue-members.html new file mode 100644 index 00000000..59012339 --- /dev/null +++ b/classegoa_1_1_std_queue-members.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::StdQueue< ElementType > Member List
+
+
+ +

This is the complete list of members for egoa::StdQueue< ElementType >, including all inherited members.

+ + + + + + + + + + + + + + + +
Clear() (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
DeleteTop() (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
Emplace(TElement const &element) (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
Empty() constegoa::StdQueue< ElementType >inlinevirtual
Pop() (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
Push(TElement const &element)egoa::StdQueue< ElementType >inlinevirtual
Push(TElement &&element) (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
queue_ (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >private
Size() const (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
StdQueue() (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inline
Swap(StdQueue &rhs) (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
TElement typedef (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >
Top() constegoa::StdQueue< ElementType >inlinevirtual
~StdQueue() (defined in egoa::StdQueue< ElementType >)egoa::StdQueue< ElementType >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_std_queue.html b/classegoa_1_1_std_queue.html new file mode 100644 index 00000000..db5dd958 --- /dev/null +++ b/classegoa_1_1_std_queue.html @@ -0,0 +1,536 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::StdQueue< ElementType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Attributes | +List of all members
+
egoa::StdQueue< ElementType > Class Template Reference
+
+
+ + + + +

+Public Types

using TElement = ElementType
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual TElement const & Top () const
 
virtual void Push (TElement const &element)
 
virtual void Push (TElement &&element)
 
virtual void Emplace (TElement const &element)
 
virtual void Pop ()
 
virtual TElement DeleteTop ()
 
virtual void Clear ()
 
virtual void Swap (StdQueue &rhs)
 
virtual bool Empty () const
 
virtual Types::count Size () const
 
+ + + +

+Private Attributes

std::queue< TElement > queue_
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::StdQueue< ElementType >
+

Definition at line 21 of file StdQueue.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + +
using egoa::StdQueue< ElementType >::TElement = ElementType
+
+ +

Definition at line 24 of file StdQueue.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ StdQueue()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
egoa::StdQueue< ElementType >::StdQueue ()
+ 		+inline
+
+ +

Definition at line 28 of file StdQueue.hpp.

+ +
+
+ +

◆ ~StdQueue()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual egoa::StdQueue< ElementType >::~StdQueue ()
+ 		+inlinevirtual
+
+ +

Definition at line 31 of file StdQueue.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Clear()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual void egoa::StdQueue< ElementType >::Clear ()
+ 		+inlinevirtual
+
+ +

Definition at line 71 of file StdQueue.hpp.

+ +
+
+ +

◆ DeleteTop()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual TElement egoa::StdQueue< ElementType >::DeleteTop ()
+ 		+inlinevirtual
+
+ +

Definition at line 63 of file StdQueue.hpp.

+ +
+
+ +

◆ Emplace()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::StdQueue< ElementType >::Emplace (TElement const & element)
+ 		+inlinevirtual
+
+ +

Definition at line 54 of file StdQueue.hpp.

+ +
+
+ +

◆ Empty()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual bool egoa::StdQueue< ElementType >::Empty () const
+ 		+inlinevirtual
+
+

@Name Capacity

+ +

Definition at line 84 of file StdQueue.hpp.

+ +
+
+ +

◆ Pop()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual void egoa::StdQueue< ElementType >::Pop ()
+ 		+inlinevirtual
+
+ +

Definition at line 58 of file StdQueue.hpp.

+ +
+
+ +

◆ Push() [1/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::StdQueue< ElementType >::Push (TElement && element)
+ 		+inlinevirtual
+
+ +

Definition at line 49 of file StdQueue.hpp.

+ +
+
+ +

◆ Push() [2/2]

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::StdQueue< ElementType >::Push (TElement const & element)
+ 		+inlinevirtual
+
+

@Name Modifiers

+ +

Definition at line 45 of file StdQueue.hpp.

+ +
+
+ +

◆ Size()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual Types::count egoa::StdQueue< ElementType >::Size () const
+ 		+inlinevirtual
+
+ +

Definition at line 88 of file StdQueue.hpp.

+ +
+
+ +

◆ Swap()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::StdQueue< ElementType >::Swap (StdQueue< ElementType > & rhs)
+ 		+inlinevirtual
+
+ +

Definition at line 76 of file StdQueue.hpp.

+ +
+
+ +

◆ Top()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + +
virtual TElement const & egoa::StdQueue< ElementType >::Top () const
+ 		+inlinevirtual
+
+

@Name Element Access

+ +

Definition at line 36 of file StdQueue.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ queue_

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
std::queue<TElement> egoa::StdQueue< ElementType >::queue_
+ 		+private
+
+ +

Definition at line 94 of file StdQueue.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_stroke-members.html b/classegoa_1_1_stroke-members.html new file mode 100644 index 00000000..7e83c229 --- /dev/null +++ b/classegoa_1_1_stroke-members.html @@ -0,0 +1,97 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Stroke Member List
+
+
+ +

This is the complete list of members for egoa::Stroke, including all inherited members.

+ + + + + + + + + + +
Name enum name (defined in egoa::Stroke)egoa::Stroke
operator!=(const Stroke &rhs) (defined in egoa::Stroke)egoa::Strokeinline
operator<< (defined in egoa::Stroke)egoa::Strokefriend
operator==(const Stroke &rhs) (defined in egoa::Stroke)egoa::Strokeinline
Stroke(Stroke::Name name)egoa::Strokeinline
Stroke()egoa::Strokeinline
stroke_ (defined in egoa::Stroke)egoa::Strokeprivate
Type() const (defined in egoa::Stroke)egoa::Strokeinline
~Stroke() (defined in egoa::Stroke)egoa::Strokeinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_stroke.html b/classegoa_1_1_stroke.html new file mode 100644 index 00000000..d68b78ee --- /dev/null +++ b/classegoa_1_1_stroke.html @@ -0,0 +1,407 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Stroke Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::Stroke Class Reference
+
+
+ +

#include <Stroke.hpp>

+ + + + +

+Public Types

enum class  Name {
+  solid +, dashed +, dotted +, dasheddotted +,
+  bold +, none +
+ }
 
+ + + + + + + + + + +

+Public Member Functions

Types::count Type () const
 
Constructors and destructor
 Stroke (Stroke::Name name)
 Constructs a new instance.
 
 Stroke ()
 Constructs a new instance.
 
+ + + +

+Private Attributes

Types::count stroke_
 
+ + + + + + + +

Operators

bool operator== (const Stroke &rhs)
 
bool operator!= (const Stroke &rhs)
 
std::ostream & operator<< (std::ostream &outputStream, Name stroke)
 
+

Detailed Description

+
...
+
//code example TODO
+
...
+
+

Definition at line 24 of file Stroke.hpp.

+

Member Enumeration Documentation

+ +

◆ Name

+ +
+
+ + + + + +
+ + + + +
enum class egoa::Stroke::Name
+ 		+strong
+
+ +

Definition at line 26 of file Stroke.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Stroke() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
egoa::Stroke::Stroke (Stroke::Name name)
+ 		+inline
+
+ +

Constructs a new instance.

+
Parameters
+ + +
[in]nameThe name
+
+
+ +

Definition at line 43 of file Stroke.hpp.

+ +
+
+ +

◆ Stroke() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
egoa::Stroke::Stroke ()
+ 		+inline
+
+ +

Constructs a new instance.

+ +

Definition at line 49 of file Stroke.hpp.

+ +
+
+ +

◆ ~Stroke()

+ +
+
+ + + + + +
+ + + + + + + +
egoa::Stroke::~Stroke ()
+ 		+inline
+
+ +

Definition at line 52 of file Stroke.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + +
bool egoa::Stroke::operator!= (const Stroke & rhs)
+ 		+inline
+
+ +

Definition at line 63 of file Stroke.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + +
bool egoa::Stroke::operator== (const Stroke & rhs)
+ 		+inline
+
+ +

Definition at line 58 of file Stroke.hpp.

+ +
+
+ +

◆ Type()

+ +
+
+ + + + + +
+ + + + + + + +
Types::count egoa::Stroke::Type () const
+ 		+inline
+
+ +

Definition at line 69 of file Stroke.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
Name stroke 
)
+ 		+friend
+
+ +

Definition at line 74 of file Stroke.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ stroke_

+ +
+
+ + + + + +
+ + + + +
Types::count egoa::Stroke::stroke_
+ 		+private
+
+ +

Definition at line 89 of file Stroke.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_subgraph-members.html b/classegoa_1_1_subgraph-members.html new file mode 100644 index 00000000..f68dca45 --- /dev/null +++ b/classegoa_1_1_subgraph-members.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Subgraph< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::Subgraph< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + +
Edges() constegoa::Subgraph< GraphType >inline
edges_egoa::Subgraph< GraphType >private
operator!= (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >friend
operator== (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >friend
Subgraph(TUnderlyingGraph *graph, std::vector< TVertexId > vertices, std::vector< TEdgeId > edges)egoa::Subgraph< GraphType >inline
TEdgeId typedef (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >
TEdgesView typedef (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >
TUnderlyingGraph typedefegoa::Subgraph< GraphType >
TVertexId typedef (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >
TVerticesView typedef (defined in egoa::Subgraph< GraphType >)egoa::Subgraph< GraphType >
UnderlyingGraph()egoa::Subgraph< GraphType >inline
UnderlyingGraph() constegoa::Subgraph< GraphType >inline
underlyingGraph_egoa::Subgraph< GraphType >private
Vertices() constegoa::Subgraph< GraphType >inline
vertices_egoa::Subgraph< GraphType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_subgraph.html b/classegoa_1_1_subgraph.html new file mode 100644 index 00000000..240cb4ed --- /dev/null +++ b/classegoa_1_1_subgraph.html @@ -0,0 +1,619 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Subgraph< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::Subgraph< GraphType > Class Template Reference
+
+
+ +

A subgraph of an existing graph. + More...

+ +

#include <Subgraph.hpp>

+ + + + + + + + + + + + + +

+Public Types

using TUnderlyingGraph = GraphType
 The type of the underlying graph.
 
using TVertexId = typename TUnderlyingGraph::TVertexId
 
using TEdgeId = typename TUnderlyingGraph::TEdgeId
 
using TVerticesView = VectorView< TVertexId, true >
 
using TEdgesView = VectorView< TEdgeId, true >
 
+ + + + + + + + + + + + + + + + +

+Public Member Functions

 Subgraph (TUnderlyingGraph *graph, std::vector< TVertexId > vertices, std::vector< TEdgeId > edges)
 The constructor.
 
TUnderlyingGraph & UnderlyingGraph ()
 The underlying graph.
 
TUnderlyingGraph const & UnderlyingGraph () const
 The underlying graph.
 
TVerticesView Vertices () const
 A view on the identifiers of the vertices in the subgraph.
 
TEdgesView Edges () const
 A view on the identifiers of the edges in the subgraph.
 
+ + + + + + + + + + +

+Private Attributes

TUnderlyingGraph * underlyingGraph_
 A pointer to the underlying graph.
 
std::vector< TVertexId > vertices_
 The identifiers of the vertices belonging to the subgraph.
 
std::vector< TEdgeId > edges_
 The identifiers of the edges belong to the subgraph.
 
+ + + + + +

+Friends

bool operator== (Subgraph const &lhs, Subgraph const &rhs)
 
bool operator!= (Subgraph const &lhs, Subgraph const &rhs)
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::Subgraph< GraphType >

A subgraph of an existing graph.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 28 of file Subgraph.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::Subgraph< GraphType >::TEdgeId = typename TUnderlyingGraph::TEdgeId
+
+ +

Definition at line 33 of file Subgraph.hpp.

+ +
+
+ +

◆ TEdgesView

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::Subgraph< GraphType >::TEdgesView = VectorView<TEdgeId, true>
+
+ +

Definition at line 35 of file Subgraph.hpp.

+ +
+
+ +

◆ TUnderlyingGraph

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::Subgraph< GraphType >::TUnderlyingGraph = GraphType
+
+ +

The type of the underlying graph.

+ +

Definition at line 31 of file Subgraph.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::Subgraph< GraphType >::TVertexId = typename TUnderlyingGraph::TVertexId
+
+ +

Definition at line 32 of file Subgraph.hpp.

+ +
+
+ +

◆ TVerticesView

+ +
+
+
+template<typename GraphType >
+ + + + +
using egoa::Subgraph< GraphType >::TVerticesView = VectorView<TVertexId, true>
+
+ +

Definition at line 34 of file Subgraph.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Subgraph()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::Subgraph< GraphType >::Subgraph (TUnderlyingGraph * graph,
std::vector< TVertexId > vertices,
std::vector< TEdgeId > edges 
)
+ 		+inline
+
+ +

The constructor.

+
Precondition
All vertex identifiers and edge identifiers must correspond to existing vertices and edges in the graph, respectively.
+
Parameters
+ + + + +
graphA pointer to the underlying graph.
[in]verticesThe identifiers of the vertices in the subgraph.
[in]edgesThe identifiers of the edges in the subgraph.
+
+
+ +

Definition at line 47 of file Subgraph.hpp.

+ +

References egoa::Subgraph< GraphType >::edges_, and egoa::Subgraph< GraphType >::vertices_.

+ +
+
+

Member Function Documentation

+ +

◆ Edges()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TEdgesView egoa::Subgraph< GraphType >::Edges () const
+ 		+inline
+
+ +

A view on the identifiers of the edges in the subgraph.

+

The identifiers are sorted in increasing order.

+ +

Definition at line 99 of file Subgraph.hpp.

+ +

References egoa::Subgraph< GraphType >::edges_.

+ +
+
+ +

◆ UnderlyingGraph() [1/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TUnderlyingGraph & egoa::Subgraph< GraphType >::UnderlyingGraph ()
+ 		+inline
+
+ +

The underlying graph.

+
Returns
A reference to the underlying graph.
+ +

Definition at line 72 of file Subgraph.hpp.

+ +

References egoa::Subgraph< GraphType >::underlyingGraph_.

+ +
+
+ +

◆ UnderlyingGraph() [2/2]

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TUnderlyingGraph const & egoa::Subgraph< GraphType >::UnderlyingGraph () const
+ 		+inline
+
+ +

The underlying graph.

+
Returns
A reference to the underlying graph.
+ +

Definition at line 81 of file Subgraph.hpp.

+ +

References egoa::Subgraph< GraphType >::underlyingGraph_.

+ +
+
+ +

◆ Vertices()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
TVerticesView egoa::Subgraph< GraphType >::Vertices () const
+ 		+inline
+
+ +

A view on the identifiers of the vertices in the subgraph.

+

The identifiers are sorted in increasing order.

+ +

Definition at line 90 of file Subgraph.hpp.

+ +

References egoa::Subgraph< GraphType >::vertices_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator!=

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (Subgraph< GraphType > const & lhs,
Subgraph< GraphType > const & rhs 
)
+ 		+friend
+
+ +

Definition at line 109 of file Subgraph.hpp.

+ +
+
+ +

◆ operator==

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (Subgraph< GraphType > const & lhs,
Subgraph< GraphType > const & rhs 
)
+ 		+friend
+
+ +

Definition at line 103 of file Subgraph.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ edges_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<TEdgeId> egoa::Subgraph< GraphType >::edges_
+ 		+private
+
+ +

The identifiers of the edges belong to the subgraph.

+ +

Definition at line 129 of file Subgraph.hpp.

+ +
+
+ +

◆ underlyingGraph_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
TUnderlyingGraph* egoa::Subgraph< GraphType >::underlyingGraph_
+ 		+private
+
+ +

A pointer to the underlying graph.

+

A pointer is used instead of a reference since otherwise a Subgraph object would not be assignable.

+ +

Definition at line 121 of file Subgraph.hpp.

+ +
+
+ +

◆ vertices_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
std::vector<TVertexId> egoa::Subgraph< GraphType >::vertices_
+ 		+private
+
+ +

The identifiers of the vertices belonging to the subgraph.

+ +

Definition at line 125 of file Subgraph.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_susceptance_norm_label-members.html b/classegoa_1_1_susceptance_norm_label-members.html new file mode 100644 index 00000000..4a3f4017 --- /dev/null +++ b/classegoa_1_1_susceptance_norm_label-members.html @@ -0,0 +1,137 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > Member List
+
+
+ +

This is the complete list of members for egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Index() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Index()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
index_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Label(Types::vertexId vertexId)egoa::Label< ElementType, VertexSetContainer, PointerType >inline
Label(Label const &label)=defaultegoa::Label< ElementType, VertexSetContainer, PointerType >
operator!=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator+egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >friend
operator+=(TElement const &rhs)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator<(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator<<egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >friend
operator<=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator==(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator>(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator>=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
PreviousLabel() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousLabel()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousLabelId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
PreviousVertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousVertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousVertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
SourceLabel(Types::vertexId vertexId)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inlinestatic
SusceptanceNorm() constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNorm()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
susceptanceNorm_egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >private
SusceptanceNormLabel()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(SusceptanceNormLabel const &label)=defaultegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
TElement typedefegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
TLabel typedefegoa::Label< ElementType, VertexSetContainer, PointerType >
TPointer typedef (defined in egoa::Label< ElementType, VertexSetContainer, PointerType >)egoa::Label< ElementType, VertexSetContainer, PointerType >
TVertexId typedefegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
TVertexSet typedefegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
Valid() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Valid()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
valid_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Value() constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
Vertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Vertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
vertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
VertexSet() constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
VertexSet()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
vertexSet_egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >private
~Label()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
~SusceptanceNormLabel()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_susceptance_norm_label.html b/classegoa_1_1_susceptance_norm_label.html new file mode 100644 index 00000000..8980cc35 --- /dev/null +++ b/classegoa_1_1_susceptance_norm_label.html @@ -0,0 +1,1402 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Static Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > Class Template Reference
+
+
+ +

Class for Susceptance norm label. + More...

+ +

#include <SusceptanceNormLabel.hpp>

+
+Inheritance diagram for egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >:
+
+
+ + +egoa::Label< ElementType, VertexSetContainer, PointerType > +egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > + +
+ + + + + + + + + + + + + + + + + + + +

+Public Types

using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
- Public Types inherited from egoa::Label< ElementType, VertexSetContainer, PointerType >
using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
using TPointer = PointerType
 
using TLabel = Label< TElement, TVertexSet, TPointer >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 SusceptanceNormLabel ()
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId, Types::real susceptanceNorm)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (SusceptanceNormLabel const &label)=default
 Copy constructor.
 
 ~SusceptanceNormLabel ()
 Destroys the susceptance norm label object.
 
Getter and Setter
TVertexSet const & VertexSet () const
 Getter of the set of all visited vertices from the source.
 
TVertexSet & VertexSet ()
 Getter of the set of all visited vertices from the source.
 
Types::real SusceptanceNorm () const
 Getter and setter for the susceptance norm.
 
Types::real & SusceptanceNorm ()
 Getter and setter for the susceptance norm.
 
Types::real Value () const
 Susceptance norm label value.
 
Domination Operators
bool operator< (SusceptanceNormLabel const &rhs) const
 Strict domination using less than.
 
bool operator<= (SusceptanceNormLabel const &rhs) const
 Weak domination using less or equal than.
 
bool operator> (SusceptanceNormLabel const &rhs) const
 Strict domination using greater than.
 
bool operator>= (SusceptanceNormLabel const &rhs) const
 Weak domination using greater or equal than.
 
Comparison Operators
bool operator== (SusceptanceNormLabel const &rhs) const
 Equality check.
 
bool operator!= (SusceptanceNormLabel const &rhs) const
 Inequality check.
 
- Public Member Functions inherited from egoa::Label< ElementType, VertexSetContainer, PointerType >
 Label (Types::vertexId vertexId)
 Constructs the label object.
 
 Label (Label const &label)=default
 Copy constructor.
 
 ~Label ()
 Destroys the label object.
 
Types::labelId Index () const
 Getter for the label identifier.
 
Types::labelId & Index ()
 Setter for the label identifier.
 
bool Valid () const
 Getter for the valid flag.
 
bool & Valid ()
 Setter for the valid flag.
 
Types::vertexId Vertex () const
 Getter for the value of the label.
 
Types::vertexId & Vertex ()
 Setter for the vertex identifier.
 
TPointer PreviousVertex () const
 Getter for the previous vertex.
 
TPointer & PreviousVertex ()
 Setter for the previous vertex.
 
TPointer PreviousLabel () const
 Getter and setter for the previous label.
 
TPointer & PreviousLabel ()
 Setter for the previous label.
 
+ + + + +

+Static Public Member Functions

static SusceptanceNormLabel SourceLabel (Types::vertexId vertexId)
 Generate source label.
 
+ + + + + +

+Private Attributes

Types::real susceptanceNorm_
 
TVertexSet vertexSet_
 
+ + + + +

+Friends

std::ostream & operator<< (std::ostream &os, SusceptanceNormLabel const &rhs)
 Output stream.
 
+ + + + + + + + + + + + + + + + +

Concatenation Operators

SusceptanceNormLabel & operator+= (TElement const &rhs)
 In place addition.
 
bool operator+ (SusceptanceNormLabel const &lhs, TVertexId const &vertexId)
 Addition operators testing for cycles.
 
std::pair< TVertexSet, bool > operator+ (TVertexId const &vertexId, SusceptanceNormLabel const &rhs)
 Addition operators testing for cycles.
 
std::pair< SusceptanceNormLabel, bool > operator+ (TElement const &edge, SusceptanceNormLabel const &rhs)
 Addition operators testing for cycles.
 
std::pair< SusceptanceNormLabel, bool > operator+ (SusceptanceNormLabel const &lhs, TElement const &edge)
 Addition operators testing for cycles.
 
+

Detailed Description

+
template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+class egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >

Class for Susceptance norm label.

+

The susceptance norm is defined by

+\[ + \bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}, + \] +

+

where $\susceptance(\vertexa,\vertexb)\in\reals$ is the susceptance defined for all $(\vertexa,\vertexb)\in\edges$. For more information see Section 3 in the paper The Maximum Transmission Switching Flow Problem.

+
Template Parameters
+ + +
ElementTypeAn edge providing access to the susceptance, e.g., an electrical edge.
+
+
+
Todo:
What are the formal requirements for ElementType? From what I can see below, the following expressions must be valid:
+
Types::real b = element.template Susceptance<Edge::CarrierDifferentiationType::DC>();
+
Types::vertexId id = ...;
+
element.Other(id);
+
See also
Edge::ElectricalEdge representing an ElementType interface.
+
+BucketElement representing an minimum interface requirement for a bucket.
+
+Label representing the base class.
+
+VoltageAngleDifferenceLabel representing an extension of this label.
+ +

Definition at line 44 of file SusceptanceNormLabel.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TElement = ElementType
+
+

Some element to cover such as an edge.

+ +

Definition at line 39 of file Label.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexId = Types::vertexId
+
+

The vertex identifier type used in LabelStruct.

+ +

Definition at line 37 of file Label.hpp.

+ +
+
+ +

◆ TVertexSet

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexSet = VertexSetContainer
+
+

A hash map of TVertex.

+ +

Definition at line 40 of file Label.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ SusceptanceNormLabel() [1/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel ()
+ 		+inline
+
+ +

Constructs the Susceptance Norm label object.

+

The label and vertex identifier and previous label and vertex identifiers are set to Const::NONE. The valid flag is set to true. Note that the susceptance norm is set to infinity.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 66 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ SusceptanceNormLabel() [2/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel (Types::vertexId vertexId)
+ 		+inline
+
+ +

Constructs the Susceptance Norm label object.

+

The label identifier and previous label/vertex identifiers are set to Const::NONE. The valid flag is set to true. Note that the susceptance norm is set to infinity.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 79 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ SusceptanceNormLabel() [3/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel (Types::vertexId vertexId,
Types::real susceptanceNorm 
)
+ 		+inline
+
+ +

Constructs the Susceptance Norm label object.

+

The label identifier and previous label and vertex identifiers are set to Const::NONE. The valid flag is set to true.

+
Parameters
+ + + +
[in]vertexIdThe vertex identifier.
[in]susceptanceNormThe susceptance norm $\bnorm{\fpath{}{\vertexa}{\vertexb}}$.
+
+
+ +

Definition at line 92 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ SusceptanceNormLabel() [4/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel (Types::vertexId vertexId,
Types::real susceptanceNorm,
TVertexSet vertexSet 
)
+ 		+inline
+
+ +

Constructs the Susceptance Norm label object.

+

The label identifier and previous label and vertex identifiers are set to Const::NONE. The valid flag is set to true.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
[in]susceptanceNormThe susceptance norm $\bnorm{\fpath{}{\vertexa}{\vertexb}}$.
[in]vertexSetThe vertex set of visited vertices.
+
+
+ +

Definition at line 107 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ SusceptanceNormLabel() [5/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & label)
+ 		+default
+
+ +

Copy constructor.

+

Constructs the susceptance norm label object.

+
Parameters
+ + +
labelThe susceptance norm label.
+
+
+ +
+
+ +

◆ ~SusceptanceNormLabel()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::~SusceptanceNormLabel ()
+ 		+inline
+
+ +

Destroys the susceptance norm label object.

+ +

Definition at line 126 of file SusceptanceNormLabel.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator!= (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Inequality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs != rhs, false otherwise.
+ +

Definition at line 242 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
SusceptanceNormLabel & egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator+= (TElement const & rhs)
+ 		+inline
+
+ +

In place addition.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
The susceptance norm label with added TElement.
+ +

Definition at line 353 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm(), and egoa::Label< ElementType, VertexSetContainer, PointerType >::Vertex().

+ +
+
+ +

◆ operator<()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator< (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using less than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs < rhs, false otherwise.
+ +

Definition at line 177 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator<=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator<= (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using less or equal than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs <= rhs, false otherwise.
+ +

Definition at line 189 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator== (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Equality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs == rhs, false otherwise.
+ +

Definition at line 230 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator>()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator> (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using greater than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs > rhs, false otherwise.
+ +

Definition at line 201 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator>=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::operator>= (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using greater or equal than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs >= rhs, false otherwise.
+ +

Definition at line 213 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ SourceLabel()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
static SusceptanceNormLabel egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SourceLabel (Types::vertexId vertexId)
+ 		+inlinestatic
+
+ +

Generate source label.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The susceptance norm source label.
+ +

Definition at line 136 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNormLabel().

+ +
+
+ +

◆ SusceptanceNorm() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real & egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm ()
+ 		+inline
+
+ +

Getter and setter for the susceptance norm.

+
Returns
The susceptance norm value $\bnorm{\fpath{}{\vertexa}{\vertexb}}$ on a path $\fpath{}{\vertexa}{\vertexb}$ of the label.
+ +

Definition at line 388 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::susceptanceNorm_.

+ +
+
+ +

◆ SusceptanceNorm() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm () const
+ 		+inline
+
+ +

Getter and setter for the susceptance norm.

+
Returns
The susceptance norm value $\bnorm{\fpath{}{\vertexa}{\vertexb}}$ on a path $\fpath{}{\vertexa}{\vertexb}$ of the label.
+ +

Definition at line 376 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::susceptanceNorm_.

+ +
+
+ +

◆ Value()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::Value () const
+ 		+inline
+
+ +

Susceptance norm label value.

+

Represents the objective of this label that is the total susceptance norm of the path.

+
Returns
The susceptance norm label value $\bnorm{\fpath{}{\vertexa}{\vertexb}}$.
+ +

Definition at line 401 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ VertexSet() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TVertexSet & egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::VertexSet ()
+ 		+inline
+
+ +

Getter of the set of all visited vertices from the source.

+
Returns
Set of all visited vertices.
+ +

Definition at line 160 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::vertexSet_.

+ +
+
+ +

◆ VertexSet() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
TVertexSet const & egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::VertexSet () const
+ 		+inline
+
+ +

Getter of the set of all visited vertices from the source.

+
Returns
Set of all visited vertices.
+ +

Definition at line 150 of file SusceptanceNormLabel.hpp.

+ +

References egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::vertexSet_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator+ [1/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< SusceptanceNormLabel, bool > operator+ (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & lhs,
TElement const & edge 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
lhsThe susceptance norm label SusceptanceNormLabel.
edgeThe edge.
+
+
+
Returns
A pair of a LabelStruct and boolean. The boolean is true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 337 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator+ [2/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator+ (SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & lhs,
TVertexId const & vertexId 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+

A cycle is created if and only if the vertex is already in the set of visited vertices vertexSet.

+
Parameters
+ + + +
lhsThe left hand side representing a SusceptanceNormLabel.
vertexIdThe vertex identifier.
+
+
+
Returns
true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 263 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator+ [3/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< SusceptanceNormLabel, bool > operator+ (TElement const & edge,
SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
edgeThe edge.
rhsThe susceptance norm label SusceptanceNormLabel.
+
+
+
Returns
A pair of a SusceptanceNormLabel and boolean. The boolean is true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 308 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator+ [4/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< TVertexSet, bool > operator+ (TVertexId const & vertexId,
SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
rhsThe right hand side representing a SusceptanceNormLabel.
+
+
+
Returns
A pair of a hash map and boolean. The boolean is True if the element could be added without creating a cycle, False otherwise.
+ +

Definition at line 284 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ operator<<

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Output stream.

+
Parameters
+ + + +
osThe output stream such as std::cout.
rhsThe right hand side susceptance norm label.
+
+
+
Returns
The output stream.
+ +

Definition at line 416 of file SusceptanceNormLabel.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ susceptanceNorm_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
Types::real egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::susceptanceNorm_
+ 		+private
+
+

The susceptance norm value $\bnorm{\fpath{}{\vertexa}{\vertexb}}$ on a path $\fpath{}{\vertexa}{\vertexb}$.

+ +

Definition at line 424 of file SusceptanceNormLabel.hpp.

+ +
+
+ +

◆ vertexSet_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
TVertexSet egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::vertexSet_
+ 		+private
+
+

The vertex set representing the set of visited vertices.

+ +

Definition at line 425 of file SusceptanceNormLabel.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_susceptance_norm_label.png b/classegoa_1_1_susceptance_norm_label.png new file mode 100644 index 00000000..0d8fa4d1 Binary files /dev/null and b/classegoa_1_1_susceptance_norm_label.png differ diff --git a/classegoa_1_1_traversal-members.html b/classegoa_1_1_traversal-members.html new file mode 100644 index 00000000..4e9caa02 --- /dev/null +++ b/classegoa_1_1_traversal-members.html @@ -0,0 +1,113 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Traversal< GraphType, IsDirected > Member List
+
+
+ +

This is the complete list of members for egoa::Traversal< GraphType, IsDirected >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
Clear()egoa::Traversal< GraphType, IsDirected >inlineprotected
for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprotected
graph_egoa::Traversal< GraphType, IsDirected >private
internal::GraphTypeLoopDifferentiation< TGraph, false > (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >friend
internal::GraphTypeLoopDifferentiation< TGraph, true > (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >friend
NumberOfVertices() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
parent_egoa::Traversal< GraphType, IsDirected >private
ParentOf(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inline
ParentOf(TVertexId vertexId) const (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
processed_egoa::Traversal< GraphType, IsDirected >private
ProcessedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
Result(std::vector< TVertexId > parent) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
SetVertexProcessedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
SetVertexVisitedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprotected
Source() constegoa::Traversal< GraphType, IsDirected >inline
Source() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inline
source_egoa::Traversal< GraphType, IsDirected >private
TGraph typedef (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >
Traversal(TGraph const &graph, TVertexId source)egoa::Traversal< GraphType, IsDirected >inline
TVertexId typedef (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >
VertexExists(TVertexId vertexId) (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlineprotected
visited_egoa::Traversal< GraphType, IsDirected >private
VisitedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprotected
~Traversal() (defined in egoa::Traversal< GraphType, IsDirected >)egoa::Traversal< GraphType, IsDirected >inlinevirtual
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_traversal.html b/classegoa_1_1_traversal.html new file mode 100644 index 00000000..2a992a0d --- /dev/null +++ b/classegoa_1_1_traversal.html @@ -0,0 +1,1065 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Traversal< GraphType, IsDirected > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::Traversal< GraphType, IsDirected > Class Template Reference
+
+
+ +

Interface for graph traversal. + More...

+ +

#include <Traversal.hpp>

+
+Inheritance diagram for egoa::Traversal< GraphType, IsDirected >:
+
+
+ + +egoa::BFS< GraphType, QueueType, IsDirected > +egoa::DepthFirstSearch< GraphType, IsDirected, Recursive > +egoa::ArticulationVertexDetection< GraphType, IsDirected > + +
+ + + + + + +

+Public Types

using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual void Result (std::vector< TVertexId > parent)
 
Constructors and destructor
 Traversal (TGraph const &graph, TVertexId source)
 Constructs a new instance.
 
TVertexId Source () const
 Getter and setter for the source vertex.
 
TVertexId & Source ()
 
TVertexId & ParentOf (TVertexId vertexId)
 Getter and setter for the parent relation.
 
TVertexId ParentOf (TVertexId vertexId) const
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

void Clear ()
 Clear and resize all vectors.
 
bool VertexExists (TVertexId vertexId)
 
bool NumberOfVertices ()
 
Vertex visited methods
void SetVertexVisitedAt (TVertexId vertexId)
 Sets the vertex at vertexId to visited.
 
bool VisitedVertexAt (TVertexId vertexId) const
 Getter and setter to access the visited field.
 
Vertex processed methods
void SetVertexProcessedAt (TVertexId vertexId)
 Sets the vertex at vertexId to processed.
 
bool ProcessedVertexAt (TVertexId vertexId) const
 Getter and setter to access the process field.
 
Edge iterators.

If the template parameter IsDirected is set to true the iterators loop over outgoing edges of the vertex only, otherwise it loops over all edges at the vertex.

+
template<typename FUNCTION >
void breakable_for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges that is breakable.
 
template<typename FUNCTION >
void for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges.
 
+ + + + + + + + + + + +

+Private Attributes

TGraph const & graph_
 
TVertexId source_
 
std::vector< bool > visited_
 
std::vector< bool > processed_
 
std::vector< TVertexId > parent_
 
+ + + + + +

+Friends

class internal::GraphTypeLoopDifferentiation< TGraph, true >
 
class internal::GraphTypeLoopDifferentiation< TGraph, false >
 
+

Detailed Description

+
template<typename GraphType, bool IsDirected = false>
+class egoa::Traversal< GraphType, IsDirected >

Interface for graph traversal.

+
Template Parameters
+ + + +
GraphTypeGraphType The graph should at least provide the same interface as the StaticGraph().
IsDirectedIf true the graph is treated as a directed graph, if false the graph is treated as an undirected graph.
+
+
+ +

Definition at line 36 of file Traversal.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + +
using egoa::Traversal< GraphType, IsDirected >::TGraph = GraphType
+
+ +

Definition at line 38 of file Traversal.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + +
using egoa::Traversal< GraphType, IsDirected >::TVertexId = typename GraphType::TVertexId
+
+ +

Definition at line 39 of file Traversal.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Traversal()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Traversal< GraphType, IsDirected >::Traversal (TGraph const & graph,
TVertexId source 
)
+ 		+inline
+
+ +

Constructs a new instance.

+
Parameters
+ + + +
graphThe graph
[in]sourceThe source
+
+
+ +

Definition at line 51 of file Traversal.hpp.

+ +
+
+ +

◆ ~Traversal()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
virtual egoa::Traversal< GraphType, IsDirected >::~Traversal ()
+ 		+inlinevirtual
+
+ +

Definition at line 58 of file Traversal.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ breakable_for_all_edges_at()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::Traversal< GraphType, IsDirected >::breakable_for_all_edges_at (TVertexId const & vertexId,
FUNCTION function 
) const
+ 		+inlineprotected
+
+ +

The for loop over all (outgoing) edges that is breakable.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
[in]functionThe function, e.g., lambda function.
+
+
+
breakable_for_all_edges_at(
+
[]( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::Traversal::breakable_for_all_edges_at
void breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges that is breakable.
Definition Traversal.hpp:231
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all incident (outgoing) edges at vertexId.
+
+
+ +

Definition at line 231 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_.

+ +
+
+ +

◆ Clear()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
void egoa::Traversal< GraphType, IsDirected >::Clear ()
+ 		+inlineprotected
+
+ +

Clear and resize all vectors.

+ +

Definition at line 181 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, egoa::Traversal< GraphType, IsDirected >::parent_, egoa::Traversal< GraphType, IsDirected >::processed_, and egoa::Traversal< GraphType, IsDirected >::visited_.

+ +
+
+ +

◆ for_all_edges_at()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::Traversal< GraphType, IsDirected >::for_all_edges_at (TVertexId const & vertexId,
FUNCTION function 
) const
+ 		+inlineprotected
+
+ +

The for loop over all (outgoing) edges.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
[in]functionThe function
+
+
+
for_all_edges_at ( vertexId
+
, []( TEdge const & edge )
+
{
+
// Do something with the edge object.
+
}
+
);
+
egoa::Traversal::for_all_edges_at
void for_all_edges_at(TVertexId const &vertexId, FUNCTION function) const
The for loop over all (outgoing) edges.
Definition Traversal.hpp:257
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all incident (outgoing) edges at vertexId.
+
+
+ +

Definition at line 257 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_.

+ +
+
+ +

◆ NumberOfVertices()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
bool egoa::Traversal< GraphType, IsDirected >::NumberOfVertices ()
+ 		+inlineprotected
+
+ +

Definition at line 198 of file Traversal.hpp.

+ +
+
+ +

◆ ParentOf() [1/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
TVertexId & egoa::Traversal< GraphType, IsDirected >::ParentOf (TVertexId vertexId)
+ 		+inline
+
+ +

Getter and setter for the parent relation.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The vertex identifier of the parent.
+ +

Definition at line 152 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::Traversal< GraphType, IsDirected >::parent_.

+ +
+
+ +

◆ ParentOf() [2/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
TVertexId egoa::Traversal< GraphType, IsDirected >::ParentOf (TVertexId vertexId) const
+ 		+inline
+
+ +

Definition at line 158 of file Traversal.hpp.

+ +
+
+ +

◆ ProcessedVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::Traversal< GraphType, IsDirected >::ProcessedVertexAt (TVertexId vertexId) const
+ 		+inlineprotected
+
+ +

Getter and setter to access the process field.

+

A vertex is processed if it is removed from the queue. Note that this means all its children will be visited subsequently.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
true if the vertex is processed, otherwise false.
+ +

Definition at line 135 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::Traversal< GraphType, IsDirected >::processed_.

+ +
+
+ +

◆ Result()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
virtual void egoa::Traversal< GraphType, IsDirected >::Result (std::vector< TVertexId > parent)
+ 		+inlinevirtual
+
+ +

Definition at line 73 of file Traversal.hpp.

+ +
+
+ +

◆ SetVertexProcessedAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
void egoa::Traversal< GraphType, IsDirected >::SetVertexProcessedAt (TVertexId vertexId)
+ 		+inlineprotected
+
+ +

Sets the vertex at vertexId to processed.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 119 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::Traversal< GraphType, IsDirected >::processed_.

+ +
+
+ +

◆ SetVertexVisitedAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
void egoa::Traversal< GraphType, IsDirected >::SetVertexVisitedAt (TVertexId vertexId)
+ 		+inlineprotected
+
+ +

Sets the vertex at vertexId to visited.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 89 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::Traversal< GraphType, IsDirected >::visited_.

+ +
+
+ +

◆ Source() [1/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
TVertexId & egoa::Traversal< GraphType, IsDirected >::Source ()
+ 		+inline
+
+ +

Definition at line 69 of file Traversal.hpp.

+ +
+
+ +

◆ Source() [2/2]

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + +
TVertexId egoa::Traversal< GraphType, IsDirected >::Source () const
+ 		+inline
+
+ +

Getter and setter for the source vertex.

+
Returns
The source's identifier.
+ +

Definition at line 68 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::source_.

+ +
+
+ +

◆ VertexExists()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::Traversal< GraphType, IsDirected >::VertexExists (TVertexId vertexId)
+ 		+inlineprotected
+
+ +

Definition at line 193 of file Traversal.hpp.

+ +
+
+ +

◆ VisitedVertexAt()

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + + + + + +
bool egoa::Traversal< GraphType, IsDirected >::VisitedVertexAt (TVertexId vertexId) const
+ 		+inlineprotected
+
+ +

Getter and setter to access the visited field.

+

A vertex is visited if it is traversed (touched) for the first time (added to the queue).

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
true if the vertex was visited, otherwise false.
+ +

Definition at line 104 of file Traversal.hpp.

+ +

References egoa::Traversal< GraphType, IsDirected >::graph_, and egoa::Traversal< GraphType, IsDirected >::visited_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ internal::GraphTypeLoopDifferentiation< TGraph, false >

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
friend class internal::GraphTypeLoopDifferentiation< TGraph, false >
+ 		+friend
+
+ +

Definition at line 257 of file Traversal.hpp.

+ +
+
+ +

◆ internal::GraphTypeLoopDifferentiation< TGraph, true >

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
friend class internal::GraphTypeLoopDifferentiation< TGraph, true >
+ 		+friend
+
+ +

Definition at line 257 of file Traversal.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ graph_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
TGraph const& egoa::Traversal< GraphType, IsDirected >::graph_
+ 		+private
+
+

The graph G=(V,E)

+ +

Definition at line 271 of file Traversal.hpp.

+ +
+
+ +

◆ parent_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<TVertexId> egoa::Traversal< GraphType, IsDirected >::parent_
+ 		+private
+
+

BFS structure in form of parent pointers

+ +

Definition at line 276 of file Traversal.hpp.

+ +
+
+ +

◆ processed_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<bool> egoa::Traversal< GraphType, IsDirected >::processed_
+ 		+private
+
+

Vertex already processed

+ +

Definition at line 275 of file Traversal.hpp.

+ +
+
+ +

◆ source_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
TVertexId egoa::Traversal< GraphType, IsDirected >::source_
+ 		+private
+
+

Source vertex from which BFS starts

+ +

Definition at line 273 of file Traversal.hpp.

+ +
+
+ +

◆ visited_

+ +
+
+
+template<typename GraphType , bool IsDirected = false>
+ + + + + +
+ + + + +
std::vector<bool> egoa::Traversal< GraphType, IsDirected >::visited_
+ 		+private
+
+

Vertex already visited

+ +

Definition at line 274 of file Traversal.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_traversal.png b/classegoa_1_1_traversal.png new file mode 100644 index 00000000..b3e8e093 Binary files /dev/null and b/classegoa_1_1_traversal.png differ diff --git a/classegoa_1_1_union_find-members.html b/classegoa_1_1_union_find-members.html new file mode 100644 index 00000000..66f8466e --- /dev/null +++ b/classegoa_1_1_union_find-members.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::UnionFind Member List
+
+
+ +

This is the complete list of members for egoa::UnionFind, including all inherited members.

+ + + + + + + + + + + + + +
Find(Types::vertexId vertex)egoa::UnionFindinline
InSameComponent(Types::vertexId u, Types::vertexId v)egoa::UnionFindinline
NumberOfVertices()egoa::UnionFindinline
numberOfVertices_ (defined in egoa::UnionFind)egoa::UnionFindprivate
numberOfVerticesInSubtree_ (defined in egoa::UnionFind)egoa::UnionFindprivate
Parent(Types::vertexId vertex) (defined in egoa::UnionFind)egoa::UnionFindinline
Parent(Types::vertexId vertex) const (defined in egoa::UnionFind)egoa::UnionFindinline
parent_ (defined in egoa::UnionFind)egoa::UnionFindprivate
SubtreeSize(Types::vertexId vertex) (defined in egoa::UnionFind)egoa::UnionFindinline
SubtreeSize(Types::vertexId vertex) const (defined in egoa::UnionFind)egoa::UnionFindinline
Union(Types::vertexId u, Types::vertexId v)egoa::UnionFindinline
UnionFind(Types::count numberOfVertices) (defined in egoa::UnionFind)egoa::UnionFindinline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_union_find.html b/classegoa_1_1_union_find.html new file mode 100644 index 00000000..337b9bfc --- /dev/null +++ b/classegoa_1_1_union_find.html @@ -0,0 +1,517 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::UnionFind Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Attributes | +List of all members
+
egoa::UnionFind Class Reference
+
+
+ +

This class describes an union find. + More...

+ +

#include <UnionFind.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 UnionFind (Types::count numberOfVertices)
 
Types::vertexId Find (Types::vertexId vertex)
 Find the root of the vertex @detail Find the tree root of element vertex and return the root's identifier.
 
void Union (Types::vertexId u, Types::vertexId v)
 Merges the two subtrees—if exist—of both components together.
 
bool InSameComponent (Types::vertexId u, Types::vertexId v)
 Are both vertices in the same component.
 
Types::count NumberOfVertices ()
 
Types::vertexId & Parent (Types::vertexId vertex)
 
Types::vertexId Parent (Types::vertexId vertex) const
 
Types::count & SubtreeSize (Types::vertexId vertex)
 
Types::count SubtreeSize (Types::vertexId vertex) const
 
+ + + + + + + +

+Private Attributes

std::vector< Types::vertexId > parent_
 
std::vector< Types::count > numberOfVerticesInSubtree_
 
Types::count numberOfVertices_
 
+

Detailed Description

+

This class describes an union find.

+ +

Definition at line 19 of file UnionFind.hpp.

+

Constructor & Destructor Documentation

+ +

◆ UnionFind()

+ +
+
+ + + + + +
+ + + + + + + + +
egoa::UnionFind::UnionFind (Types::count numberOfVertices)
+ 		+inline
+
+ +

Definition at line 21 of file UnionFind.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Find()

+ +
+
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::UnionFind::Find (Types::vertexId vertex)
+ 		+inline
+
+ +

Find the root of the vertex @detail Find the tree root of element vertex and return the root's identifier.

+
Parameters
+ + +
[in]vertexThe vertex identifier.
+
+
+
Returns
The root's identifier.
+ +

Definition at line 44 of file UnionFind.hpp.

+ +

References Find().

+ +
+
+ +

◆ InSameComponent()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::UnionFind::InSameComponent (Types::vertexId u,
Types::vertexId v 
)
+ 		+inline
+
+ +

Are both vertices in the same component.

+
Parameters
+ + + +
[in]uThe vertex u.
[in]vThe vertex v.
+
+
+
Returns
If they are in the same component
+ +

Definition at line 82 of file UnionFind.hpp.

+ +

References Find().

+ +
+
+ +

◆ NumberOfVertices()

+ +
+
+ + + + + +
+ + + + + + + +
Types::count egoa::UnionFind::NumberOfVertices ()
+ 		+inline
+
+

@Name Getter and setter

+ +

Definition at line 89 of file UnionFind.hpp.

+ +
+
+ +

◆ Parent() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Types::vertexId & egoa::UnionFind::Parent (Types::vertexId vertex)
+ 		+inline
+
+ +

Definition at line 94 of file UnionFind.hpp.

+ +
+
+ +

◆ Parent() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Types::vertexId egoa::UnionFind::Parent (Types::vertexId vertex) const
+ 		+inline
+
+ +

Definition at line 101 of file UnionFind.hpp.

+ +
+
+ +

◆ SubtreeSize() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Types::count & egoa::UnionFind::SubtreeSize (Types::vertexId vertex)
+ 		+inline
+
+ +

Definition at line 108 of file UnionFind.hpp.

+ +
+
+ +

◆ SubtreeSize() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Types::count egoa::UnionFind::SubtreeSize (Types::vertexId vertex) const
+ 		+inline
+
+ +

Definition at line 114 of file UnionFind.hpp.

+ +
+
+ +

◆ Union()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::UnionFind::Union (Types::vertexId u,
Types::vertexId v 
)
+ 		+inline
+
+ +

Merges the two subtrees—if exist—of both components together.

+
Parameters
+ + + +
[in]uThe vertex u
[in]vThe vertex v
+
+
+ +

Definition at line 57 of file UnionFind.hpp.

+ +

References Find().

+ +
+
+

Member Data Documentation

+ +

◆ numberOfVertices_

+ +
+
+ + + + + +
+ + + + +
Types::count egoa::UnionFind::numberOfVertices_
+ 		+private
+
+ +

Definition at line 124 of file UnionFind.hpp.

+ +
+
+ +

◆ numberOfVerticesInSubtree_

+ +
+
+ + + + + +
+ + + + +
std::vector<Types::count> egoa::UnionFind::numberOfVerticesInSubtree_
+ 		+private
+
+ +

Definition at line 123 of file UnionFind.hpp.

+ +
+
+ +

◆ parent_

+ +
+
+ + + + + +
+ + + + +
std::vector<Types::vertexId> egoa::UnionFind::parent_
+ 		+private
+
+ +

Definition at line 122 of file UnionFind.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vector_based_comparator-members.html b/classegoa_1_1_vector_based_comparator-members.html new file mode 100644 index 00000000..c43796f6 --- /dev/null +++ b/classegoa_1_1_vector_based_comparator-members.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::VectorBasedComparator< WeightType, ComparatorType > Member List
+
+
+ +

This is the complete list of members for egoa::VectorBasedComparator< WeightType, ComparatorType >, including all inherited members.

+ + + + + +
comparator_ (defined in egoa::VectorBasedComparator< WeightType, ComparatorType >)egoa::VectorBasedComparator< WeightType, ComparatorType >private
operator()(Types::index lhs, Types::index rhs) const (defined in egoa::VectorBasedComparator< WeightType, ComparatorType >)egoa::VectorBasedComparator< WeightType, ComparatorType >inline
VectorBasedComparator(std::vector< WeightType > const &weights, ComparatorType comparator=std::less< WeightType >())egoa::VectorBasedComparator< WeightType, ComparatorType >inline
weights_ (defined in egoa::VectorBasedComparator< WeightType, ComparatorType >)egoa::VectorBasedComparator< WeightType, ComparatorType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vector_based_comparator.html b/classegoa_1_1_vector_based_comparator.html new file mode 100644 index 00000000..7f2209a1 --- /dev/null +++ b/classegoa_1_1_vector_based_comparator.html @@ -0,0 +1,269 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::VectorBasedComparator< WeightType, ComparatorType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Private Attributes | +List of all members
+
egoa::VectorBasedComparator< WeightType, ComparatorType > Class Template Reference
+
+
+ +

A comparator that compares based on elements in the vector. + More...

+ +

#include <Comparators.hpp>

+ + + + + + + +

+Public Member Functions

 VectorBasedComparator (std::vector< WeightType > const &weights, ComparatorType comparator=std::less< WeightType >())
 The constructor.
 
bool operator() (Types::index lhs, Types::index rhs) const
 
+ + + + + +

+Private Attributes

std::vector< WeightType > const & weights_
 
ComparatorType comparator_
 
+

Detailed Description

+
template<typename WeightType, typename ComparatorType = std::less<WeightType>>
+class egoa::VectorBasedComparator< WeightType, ComparatorType >

A comparator that compares based on elements in the vector.

+
Template Parameters
+ + + +
WeightTypeThe type of the vector elements.
ComparatorTypeTye type of the underlying comparator that is used to compare the vector elements.
+
+
+ +

Definition at line 23 of file Comparators.hpp.

+

Constructor & Destructor Documentation

+ +

◆ VectorBasedComparator()

+ +
+
+
+template<typename WeightType , typename ComparatorType = std::less<WeightType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::VectorBasedComparator< WeightType, ComparatorType >::VectorBasedComparator (std::vector< WeightType > const & weights,
ComparatorType comparator = std::less<WeightType>() 
)
+ 		+inline
+
+ +

The constructor.

+
Parameters
+ + + +
weightsThe weights.
[in]comparatorThe comparator.
+
+
+ +

Definition at line 31 of file Comparators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator()()

+ +
+
+
+template<typename WeightType , typename ComparatorType = std::less<WeightType>>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool egoa::VectorBasedComparator< WeightType, ComparatorType >::operator() (Types::index lhs,
Types::index rhs 
) const
+ 		+inline
+
+ +

Definition at line 37 of file Comparators.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ comparator_

+ +
+
+
+template<typename WeightType , typename ComparatorType = std::less<WeightType>>
+ + + + + +
+ + + + +
ComparatorType egoa::VectorBasedComparator< WeightType, ComparatorType >::comparator_
+ 		+private
+
+ +

Definition at line 44 of file Comparators.hpp.

+ +
+
+ +

◆ weights_

+ +
+
+
+template<typename WeightType , typename ComparatorType = std::less<WeightType>>
+ + + + + +
+ + + + +
std::vector<WeightType> const& egoa::VectorBasedComparator< WeightType, ComparatorType >::weights_
+ 		+private
+
+ +

Definition at line 43 of file Comparators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vector_view-members.html b/classegoa_1_1_vector_view-members.html new file mode 100644 index 00000000..977775c3 --- /dev/null +++ b/classegoa_1_1_vector_view-members.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::VectorView< ElementType, Const > Member List
+
+
+ +

This is the complete list of members for egoa::VectorView< ElementType, Const >, including all inherited members.

+ + + + + + + + + + + + + + + +
begin() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
empty() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
end() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
operator[](Types::index index) const (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
rbegin() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
rend() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
size() const noexcept (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inline
TElement typedef (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >private
TIterator typedef (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >
TReference typedef (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >
TReverseIterator typedef (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >
TVector typedef (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >private
vector_ (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >private
VectorView(TVector *vector) (defined in egoa::VectorView< ElementType, Const >)egoa::VectorView< ElementType, Const >inlineexplicit
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vector_view.html b/classegoa_1_1_vector_view.html new file mode 100644 index 00000000..d8eff73c --- /dev/null +++ b/classegoa_1_1_vector_view.html @@ -0,0 +1,522 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::VectorView< ElementType, Const > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Types | +Private Attributes | +List of all members
+
egoa::VectorView< ElementType, Const > Class Template Reference
+
+
+ +

Provides a restricted view on a vector. + More...

+ +

#include <VectorView.hpp>

+ + + + + + + + +

+Public Types

using TIterator = typename std::conditional< Const, typename TVector::const_iterator, typename TVector::iterator >::type
 
using TReverseIterator = typename std::conditional< Const, typename TVector::const_reverse_iterator, typename TVector::reverse_iterator >::type
 
using TReference = typename std::conditional< Const, TElement const &, TElement & >::type
 
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 VectorView (TVector *vector)
 
TIterator begin () const noexcept
 
TIterator end () const noexcept
 
TReverseIterator rbegin () const noexcept
 
TReverseIterator rend () const noexcept
 
bool empty () const noexcept
 
Types::count size () const noexcept
 
TReference operator[] (Types::index index) const
 
+ + + + + +

+Private Types

using TElement = ElementType
 
using TVector = typename std::conditional< Const, std::vector< TElement > const, std::vector< TElement > >::type
 
+ + + +

+Private Attributes

TVector * vector_
 
+

Detailed Description

+
template<typename ElementType, bool Const>
+class egoa::VectorView< ElementType, Const >

Provides a restricted view on a vector.

+
Template Parameters
+ + + +
ElementTypeThe types of the vector's elements
ConstWhether the vector shall be treated as const.
+
+
+ +

Definition at line 24 of file VectorView.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::VectorView< ElementType, Const >::TElement = ElementType
+ 		+private
+
+ +

Definition at line 25 of file VectorView.hpp.

+ +
+
+ +

◆ TIterator

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::VectorView< ElementType, Const >::TIterator = typename std::conditional<Const, typename TVector::const_iterator, typename TVector::iterator >::type
+
+ +

Definition at line 31 of file VectorView.hpp.

+ +
+
+ +

◆ TReference

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::VectorView< ElementType, Const >::TReference = typename std::conditional<Const, TElement const &, TElement & >::type
+
+ +

Definition at line 39 of file VectorView.hpp.

+ +
+
+ +

◆ TReverseIterator

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + +
using egoa::VectorView< ElementType, Const >::TReverseIterator = typename std::conditional<Const, typename TVector::const_reverse_iterator, typename TVector::reverse_iterator >::type
+
+ +

Definition at line 35 of file VectorView.hpp.

+ +
+
+ +

◆ TVector

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
using egoa::VectorView< ElementType, Const >::TVector = typename std::conditional<Const, std::vector<TElement> const, std::vector<TElement> >::type
+ 		+private
+
+ +

Definition at line 26 of file VectorView.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ VectorView()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + + +
egoa::VectorView< ElementType, Const >::VectorView (TVector * vector)
+ 		+inlineexplicit
+
+ +

Definition at line 44 of file VectorView.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TIterator egoa::VectorView< ElementType, Const >::begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 46 of file VectorView.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
bool egoa::VectorView< ElementType, Const >::empty () const
+ 		+inlinenoexcept
+
+ +

Definition at line 50 of file VectorView.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TIterator egoa::VectorView< ElementType, Const >::end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 47 of file VectorView.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + + +
TReference egoa::VectorView< ElementType, Const >::operator[] (Types::index index) const
+ 		+inline
+
+ +

Definition at line 52 of file VectorView.hpp.

+ +
+
+ +

◆ rbegin()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TReverseIterator egoa::VectorView< ElementType, Const >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 48 of file VectorView.hpp.

+ +
+
+ +

◆ rend()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
TReverseIterator egoa::VectorView< ElementType, Const >::rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 49 of file VectorView.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + + + + +
Types::count egoa::VectorView< ElementType, Const >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 51 of file VectorView.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ vector_

+ +
+
+
+template<typename ElementType , bool Const>
+ + + + + +
+ + + + +
TVector* egoa::VectorView< ElementType, Const >::vector_
+ 		+private
+
+ +

Definition at line 55 of file VectorView.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_electrical_properties-members.html b/classegoa_1_1_vertices_1_1_electrical_properties-members.html new file mode 100644 index 00000000..b02ec61c --- /dev/null +++ b/classegoa_1_1_vertices_1_1_electrical_properties-members.html @@ -0,0 +1,153 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Vertices::ElectricalProperties< VertexType > Member List
+
+
+ +

This is the complete list of members for egoa::Vertices::ElectricalProperties< VertexType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Area() constegoa::Vertices::ElectricalProperties< VertexType >inline
Area()egoa::Vertices::ElectricalProperties< VertexType >inline
area_egoa::Vertices::ElectricalProperties< VertexType >private
Carrier() constegoa::Vertices::ElectricalProperties< VertexType >inline
Carrier()egoa::Vertices::ElectricalProperties< VertexType >inline
carrier_egoa::Vertices::ElectricalProperties< VertexType >private
Control() constegoa::Vertices::ElectricalProperties< VertexType >inline
Control()egoa::Vertices::ElectricalProperties< VertexType >inline
control_egoa::Vertices::ElectricalProperties< VertexType >private
Country() constegoa::Vertices::ElectricalProperties< VertexType >inline
Country()egoa::Vertices::ElectricalProperties< VertexType >inline
country_ (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >private
ElectricalProperties()egoa::Vertices::ElectricalProperties< VertexType >inline
Header(std::ostream &outputStream)egoa::Vertices::ElectricalProperties< VertexType >inlinestatic
HeaderLong(std::ostream &outputStream)egoa::Vertices::ElectricalProperties< VertexType >inlinestatic
IsActive() constegoa::Vertices::ElectricalProperties< VertexType >inline
Line(std::ostream &outputStream, Types::real baseMva=1) constegoa::Vertices::ElectricalProperties< VertexType >inline
Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) constegoa::Vertices::ElectricalProperties< VertexType >inline
MaximumVoltage() constegoa::Vertices::ElectricalProperties< VertexType >inline
MaximumVoltage()egoa::Vertices::ElectricalProperties< VertexType >inline
MinimumVoltage() constegoa::Vertices::ElectricalProperties< VertexType >inline
MinimumVoltage()egoa::Vertices::ElectricalProperties< VertexType >inline
Name() const (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
Name() (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
name_egoa::Vertices::ElectricalProperties< VertexType >private
NominalVoltage() constegoa::Vertices::ElectricalProperties< VertexType >inline
NominalVoltage()egoa::Vertices::ElectricalProperties< VertexType >inline
nominalVoltage_egoa::Vertices::ElectricalProperties< VertexType >private
operator!=(ElectricalProperties const &rhs) constegoa::Vertices::ElectricalProperties< VertexType >inline
operator<<egoa::Vertices::ElectricalProperties< VertexType >friend
operator==(ElectricalProperties const &rhs) constegoa::Vertices::ElectricalProperties< VertexType >inline
Reset()egoa::Vertices::ElectricalProperties< VertexType >inline
ShuntConductance() constegoa::Vertices::ElectricalProperties< VertexType >inline
ShuntConductance()egoa::Vertices::ElectricalProperties< VertexType >inline
shuntConductance_egoa::Vertices::ElectricalProperties< VertexType >private
ShuntSusceptance() constegoa::Vertices::ElectricalProperties< VertexType >inline
ShuntSusceptance()egoa::Vertices::ElectricalProperties< VertexType >inline
shuntSusceptance_egoa::Vertices::ElectricalProperties< VertexType >private
Status()egoa::Vertices::ElectricalProperties< VertexType >inline
Status() constegoa::Vertices::ElectricalProperties< VertexType >inline
status_egoa::Vertices::ElectricalProperties< VertexType >private
swapegoa::Vertices::ElectricalProperties< VertexType >friend
TBound typedef (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >private
TProperties typedef (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >
TVertexType typedef (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >
Type() const (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
Type() (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
type_egoa::Vertices::ElectricalProperties< VertexType >private
VoltageAngle() constegoa::Vertices::ElectricalProperties< VertexType >inline
VoltageAngle()egoa::Vertices::ElectricalProperties< VertexType >inline
voltageAngle_egoa::Vertices::ElectricalProperties< VertexType >private
voltageBound_egoa::Vertices::ElectricalProperties< VertexType >private
VoltageMagnitude() constegoa::Vertices::ElectricalProperties< VertexType >inline
VoltageMagnitude()egoa::Vertices::ElectricalProperties< VertexType >inline
voltageMagnitude_egoa::Vertices::ElectricalProperties< VertexType >private
voltageMagnitudeSq_egoa::Vertices::ElectricalProperties< VertexType >private
X() const (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
X() (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
xCoordinate_egoa::Vertices::ElectricalProperties< VertexType >private
Y() const (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
Y() (defined in egoa::Vertices::ElectricalProperties< VertexType >)egoa::Vertices::ElectricalProperties< VertexType >inline
yCoordinate_egoa::Vertices::ElectricalProperties< VertexType >private
Zone() constegoa::Vertices::ElectricalProperties< VertexType >inline
Zone()egoa::Vertices::ElectricalProperties< VertexType >inline
zone_egoa::Vertices::ElectricalProperties< VertexType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_electrical_properties.html b/classegoa_1_1_vertices_1_1_electrical_properties.html new file mode 100644 index 00000000..9f77f33c --- /dev/null +++ b/classegoa_1_1_vertices_1_1_electrical_properties.html @@ -0,0 +1,2473 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Vertices::ElectricalProperties< VertexType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Private Types | +List of all members
+
egoa::Vertices::ElectricalProperties< VertexType > Class Template Reference
+
+
+ +

Class for electrical properties. + More...

+ +

#include <ElectricalProperties.hpp>

+ + + + + + +

+Public Types

using TVertexType = VertexType
 
using TProperties = ElectricalProperties< TVertexType >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 ElectricalProperties ()
 Default constructs the object.
 
void Reset ()
 Reset values to default.
 
bool operator!= (ElectricalProperties const &rhs) const
 Inequality comparator.
 
bool operator== (ElectricalProperties const &rhs) const
 Equality comparator.
 
Basic Properties
Types::name Name () const
 
Types::name & Name ()
 
TVertexType Type () const
 
TVertexType & Type ()
 
Types::real X () const
 
Types::real & X ()
 
Types::real Y () const
 
Types::real & Y ()
 
Admittance
Types::real ShuntSusceptance () const
 Getter for the shunt susceptance $\shuntsusceptance(\vertex)$.
 
Types::real & ShuntSusceptance ()
 Getter and setter for the shunt susceptance $\shuntsusceptance(\vertex)$.
 
Types::real ShuntConductance () const
 Getter for the shunt conductance $\shuntconductance(\vertex)$.
 
Types::real & ShuntConductance ()
 Getter and setter for the shunt conductance $\shuntconductance(\vertex)$.
 
Voltage
Types::real NominalVoltage () const
 Getter for the nominal voltage $\voltagenominal$ (also known as base voltage; in kV).
 
Types::real & NominalVoltage ()
 Getter and setter for the nominal voltage $\voltagenominal$ (also known as base voltage; in kV).
 
Types::real VoltageMagnitude () const
 Getter for the voltage magnitude $\vmagnitude$.
 
Types::real & VoltageMagnitude ()
 Getter and setter for the voltage magnitude $\vmagnitude$.
 
Types::real VoltageAngle () const
 Getter for the voltage angle $\vangle(\vertex)$.
 
Types::real & VoltageAngle ()
 Getter for the voltage angle $\vangle(\vertex)$.
 
Types::real MinimumVoltage () const
 Getter for the minimum voltage magnitude $\voltagemin$.
 
Types::real & MinimumVoltage ()
 Getter and setter for the minimum voltage magnitude $\voltagemin$.
 
Types::real MaximumVoltage () const
 Getter for the maximum voltage magnitude $\voltagemax$.
 
Types::real & MaximumVoltage ()
 Getter and setter for the maximum voltage magnitude $\voltagemax$.
 
Type specific information
Types::name Country () const
 Getter for the country.
 
Types::name & Country ()
 Getter and setter for the country.
 
Types::index Area () const
 Getter for the bus area number.
 
Types::index & Area ()
 Getter and setter for the bus area number.
 
Types::index Zone () const
 Getter for the loss zone.
 
Types::index & Zone ()
 Getter and setter for the loss zone.
 
Vertices::ControlType Control () const
 Getter for the bus control type strategy.
 
Vertices::ControlType & Control ()
 Getter and setter for the bus control type strategy.
 
Vertices::EnergyCarrier Carrier () const
 Getter for the energy carrier type.
 
Vertices::EnergyCarrier & Carrier ()
 Getter and setter for the energy carrier type.
 
Status
bool IsActive () const
 Determines if the electrical vertex is active.
 
Vertices::BusStatus & Status ()
 Status of the electrical vertex.
 
Vertices::BusStatus const & Status () const
 Status of the electrical vertex.
 
+ + + +

+Private Types

using TBound = Bound< Types::real >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Basic Property Members
Types::name name_
 
TVertexType type_
 
Types::real xCoordinate_
 
Types::real yCoordinate_
 
Admittance Related Members
Types::real shuntSusceptance_
 
Types::real shuntConductance_
 
Voltage Related Members
Types::real nominalVoltage_
 
Types::real voltageAngle_
 
Types::real voltageMagnitude_
 
Types::real voltageMagnitudeSq_
 
TBound voltageBound_
 
Location Specific Members
Types::name country_
 
Types::index area_
 
Types::index zone_
 
Vertices::ControlType control_
 
Vertices::EnergyCarrier carrier_
 
Status Members
Vertices::BusStatus status_
 
+ + + + + +

+Friends

Copy and swap idiom
void swap (ElectricalProperties &lhs, ElectricalProperties &rhs)
 Swapping the members of two ElectricalVertices.
 
+ + + + + + + + + + + + + + + + +

Output

void Line (std::ostream &outputStream, Types::real baseMva=1) const
 Line out stream.
 
void Line (std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const
 Writes the electrical property as a line.
 
std::ostream & operator<< (std::ostream &outputStream, TProperties const &rhs)
 Write the electrical property to an output stream.
 
static void HeaderLong (std::ostream &outputStream)
 Header out stream.
 
static void Header (std::ostream &outputStream)
 Header out stream.
 
+

Detailed Description

+
template<class VertexType = Vertices::IeeeBusType>
+class egoa::Vertices::ElectricalProperties< VertexType >

Class for electrical properties.

+
Template Parameters
+ + +
VertexTypeThe vertex type, e.g., Vertices::IeeeBusType.
+
+
+ +

Definition at line 28 of file ElectricalProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
using egoa::Vertices::ElectricalProperties< VertexType >::TBound = Bound<Types::real>
+ 		+private
+
+ +

Definition at line 34 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TProperties

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::ElectricalProperties< VertexType >::TProperties = ElectricalProperties<TVertexType>
+
+ +

Definition at line 32 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::ElectricalProperties< VertexType >::TVertexType = VertexType
+
+ +

Definition at line 31 of file ElectricalProperties.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ElectricalProperties()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
egoa::Vertices::ElectricalProperties< VertexType >::ElectricalProperties ()
+ 		+inline
+
+ +

Default constructs the object.

+

The values are set to the default values.

+ +

Definition at line 45 of file ElectricalProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Area() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::index & egoa::Vertices::ElectricalProperties< VertexType >::Area ()
+ 		+inline
+
+ +

Getter and setter for the bus area number.

+

Bus area (1 - 99) indicates in which company/region the station is located. A two digit integer from 0 to 99 indicating the company or region in which the line is located. This area number should be the same as the area of one of the two terminal vertices. Tie line it indicates the ownership or area to which the losses should be assigned. This area is not related to the meter bus location.

+
Note
If the value is 0 this means that there is no data available or there is no area.
+
ElectricalProperties vertex;
+
vertex.Area() = 11;
+
egoa::Vertices::ElectricalProperties
Class for electrical properties.
Definition ElectricalProperties.hpp:28
+
egoa::Vertices::ElectricalProperties::Area
Types::index Area() const
Getter for the bus area number.
Definition ElectricalProperties.hpp:480
+
Returns
The bus area number.
+ +

Definition at line 505 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::area_.

+ +
+
+ +

◆ Area() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::index egoa::Vertices::ElectricalProperties< VertexType >::Area () const
+ 		+inline
+
+ +

Getter for the bus area number.

+

Bus area (1 - 99) indicates in which company/region the station is located. A two digit integer from 0 to 99 indicating the company or region in which the line is located. This area number should be the same as the area of one of the two terminal vertices. Tie line it indicates the ownership or area to which the losses should be assigned. This area is not related to the meter bus location.

+
Note
If the value is 0 this means that there is no data available or there is no area.
+
Returns
The bus area number.
+ +

Definition at line 480 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::area_.

+ +
+
+ +

◆ Carrier() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::EnergyCarrier & egoa::Vertices::ElectricalProperties< VertexType >::Carrier ()
+ 		+inline
+
+ +

Getter and setter for the energy carrier type.

+

The energy carrier type describes if the electrical vertex is connected to $\ac$ or $\dc$. If the vertex is not an electrical bus it might be heat or gas.

+
ElectricalProperties vertex;
+
vertex.Carrier() = Vertices::EnergyCarrier::DC;
+
egoa::Vertices::ElectricalProperties::Carrier
Vertices::EnergyCarrier Carrier() const
Getter for the energy carrier type.
Definition ElectricalProperties.hpp:588
+
See also
Type::Vertices::EnergyCarrier
+
Returns
The energy carrier type.
+ +

Definition at line 609 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::carrier_.

+ +
+
+ +

◆ Carrier() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::EnergyCarrier egoa::Vertices::ElectricalProperties< VertexType >::Carrier () const
+ 		+inline
+
+ +

Getter for the energy carrier type.

+

The energy carrier type describes the vertex is for example connected to $\ac$ or $\dc$.

+
See also
Type::Vertices::EnergyCarrier
+
Returns
The energy carrier type.
+ +

Definition at line 588 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::carrier_.

+ +
+
+ +

◆ Control() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::ControlType & egoa::Vertices::ElectricalProperties< VertexType >::Control ()
+ 		+inline
+
+ +

Getter and setter for the bus control type strategy.

+

The bus control type strategy can be either PQ, PV, or slack. The latter represents the reference bus. The voltage angle of the reference bus is usually set to 0.

+
ElectricalProperties vertex;
+
vertex.Control() = Vertices::ControlType::PQ;
+
egoa::Vertices::ElectricalProperties::Control
Vertices::ControlType Control() const
Getter for the bus control type strategy.
Definition ElectricalProperties.hpp:553
+
See also
Type::Vertices::ControlType
+
Returns
The bus control type strategy.
+ +

Definition at line 574 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::control_.

+ +
+
+ +

◆ Control() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::ControlType egoa::Vertices::ElectricalProperties< VertexType >::Control () const
+ 		+inline
+
+ +

Getter for the bus control type strategy.

+

The bus control type strategy can be either PQ, PV, or slack. The latter represents the reference bus. The voltage angle of the reference bus is usually set to 0.

+
See also
Type::Vertices::ControlType
+
Returns
The bus control type strategy.
+ +

Definition at line 553 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::control_.

+ +
+
+ +

◆ Country() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name & egoa::Vertices::ElectricalProperties< VertexType >::Country ()
+ 		+inline
+
+ +

Getter and setter for the country.

+

Used in PyPSA for example to specify the location of the vertex.

+
Returns
The country of the vertex.
+ +

Definition at line 460 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Country() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name egoa::Vertices::ElectricalProperties< VertexType >::Country () const
+ 		+inline
+
+ +

Getter for the country.

+

Used in PyPSA for example to specify the location of the vertex.

+
Returns
The country of the vertex.
+ +

Definition at line 448 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Header()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
static void egoa::Vertices::ElectricalProperties< VertexType >::Header (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Header out stream.

+

List all IEEE standard input data.

+
Parameters
+ + +
outputStreamThe stream to write data to, e.g., std::cout.
+
+
+ +

Definition at line 690 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ HeaderLong()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
static void egoa::Vertices::ElectricalProperties< VertexType >::HeaderLong (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Header out stream.

+

List all IEEE standard input data.

+
Parameters
+ + +
outputStreamThe stream to write data to, e.g., std::cout.
+
+
+ +

Definition at line 665 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ IsActive()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool egoa::Vertices::ElectricalProperties< VertexType >::IsActive () const
+ 		+inline
+
+ +

Determines if the electrical vertex is active.

+
See also
Status
+
Returns
True if active (on), False otherwise (unknown).
+ +

Definition at line 626 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::Status().

+ +
+
+ +

◆ Line() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::Vertices::ElectricalProperties< VertexType >::Line (std::ostream & outputStream,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Line out stream.

+

List all IEEE standard input data.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]baseMvaThe base MVA.
+
+
+ +

Definition at line 716 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::Area(), egoa::Vertices::ElectricalProperties< VertexType >::MaximumVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::MinimumVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude(), and egoa::Vertices::ElectricalProperties< VertexType >::Zone().

+ +
+
+ +

◆ Line() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::Vertices::ElectricalProperties< VertexType >::Line (std::ostream & outputStream,
Types::vertexId identifier,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Writes the electrical property as a line.

+

List all IEEE standard input data.

+
Parameters
+ + + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]identifierThe identifier.
[in]baseMvaThe base MVA.
+
+
+ +

Definition at line 744 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::Area(), egoa::Vertices::ElectricalProperties< VertexType >::MaximumVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::MinimumVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude(), and egoa::Vertices::ElectricalProperties< VertexType >::Zone().

+ +
+
+ +

◆ MaximumVoltage() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::MaximumVoltage ()
+ 		+inline
+
+ +

Getter and setter for the maximum voltage magnitude $\voltagemax$.

+

The voltage magnitude is in p.u.

+
ElectricalProperties vertex;
+
vertex.MaximumVoltage() = 111;
+
egoa::Vertices::ElectricalProperties::MaximumVoltage
Types::real MaximumVoltage() const
Getter for the maximum voltage magnitude .
Definition ElectricalProperties.hpp:414
+
Returns
The maximum voltage magnitude $\voltagemax$.
+ +

Definition at line 431 of file ElectricalProperties.hpp.

+ +

References egoa::Bound< BoundType >::Maximum(), and egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_.

+ +
+
+ +

◆ MaximumVoltage() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::MaximumVoltage () const
+ 		+inline
+
+ +

Getter for the maximum voltage magnitude $\voltagemax$.

+

The voltage magnitude is in per unit (p.u.) of the nominal voltage $\voltagenominal$.

+
Returns
The maximum voltage magnitude $\voltagemax$.
+ +

Definition at line 414 of file ElectricalProperties.hpp.

+ +

References egoa::Bound< BoundType >::Maximum(), and egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_.

+ +
+
+ +

◆ MinimumVoltage() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::MinimumVoltage ()
+ 		+inline
+
+ +

Getter and setter for the minimum voltage magnitude $\voltagemin$.

+

The voltage magnitude is in per unit (p.u.) of the nominal voltage $\voltagenominal$.

+
ElectricalProperties vertex;
+
vertex.MinimumVoltage() = 0;
+
egoa::Vertices::ElectricalProperties::MinimumVoltage
Types::real MinimumVoltage() const
Getter for the minimum voltage magnitude .
Definition ElectricalProperties.hpp:383
+
Returns
The minimum voltage magnitude $\voltagemin$.
+ +

Definition at line 401 of file ElectricalProperties.hpp.

+ +

References egoa::Bound< BoundType >::Minimum(), and egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_.

+ +
+
+ +

◆ MinimumVoltage() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::MinimumVoltage () const
+ 		+inline
+
+ +

Getter for the minimum voltage magnitude $\voltagemin$.

+

The voltage magnitude is in per unit (p.u.) of the nominal voltage $\voltagenominal$.

+
Returns
The minimum voltage magnitude $\voltagemin$.
+ +

Definition at line 383 of file ElectricalProperties.hpp.

+ +

References egoa::Bound< BoundType >::Minimum(), and egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_.

+ +
+
+ +

◆ Name() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name & egoa::Vertices::ElectricalProperties< VertexType >::Name ()
+ 		+inline
+
+ +

Definition at line 196 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Name() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name egoa::Vertices::ElectricalProperties< VertexType >::Name () const
+ 		+inline
+
+ +

Definition at line 195 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ NominalVoltage() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage ()
+ 		+inline
+
+ +

Getter and setter for the nominal voltage $\voltagenominal$ (also known as base voltage; in kV).

+
Returns
The nominal voltage $\voltagenominal$ in kV.
+ +

Definition at line 304 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::nominalVoltage_.

+ +
+
+ +

◆ NominalVoltage() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage () const
+ 		+inline
+
+ +

Getter for the nominal voltage $\voltagenominal$ (also known as base voltage; in kV).

+
Returns
The nominal voltage $\voltagenominal$ in kV.
+ +

Definition at line 293 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::nominalVoltage_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::ElectricalProperties< VertexType >::operator!= (ElectricalProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Inequality comparator.

+

@Name Comparators

+
Parameters
+ + +
rhsThe right hand side GeneratorProperties.
+
+
+
Returns
True if both vertices are not equal, False otherwise.
+ +

Definition at line 118 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::ElectricalProperties< VertexType >::operator== (ElectricalProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Equality comparator.

+
Parameters
+ + +
rhsThe right hand side GeneratorProperties.
+
+
+
Returns
True if both vertices are equal, False otherwise.
+ +

Definition at line 131 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::Area(), egoa::Vertices::ElectricalProperties< VertexType >::Carrier(), egoa::Vertices::ElectricalProperties< VertexType >::Control(), egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance(), egoa::Vertices::ElectricalProperties< VertexType >::Status(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle(), egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_, egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude(), egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitudeSq_, and egoa::Vertices::ElectricalProperties< VertexType >::Zone().

+ +
+
+ +

◆ Reset()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
void egoa::Vertices::ElectricalProperties< VertexType >::Reset ()
+ 		+inline
+
+ +

Reset values to default.

+ +

Definition at line 74 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::Area(), egoa::Vertices::ElectricalProperties< VertexType >::Carrier(), egoa::Vertices::ElectricalProperties< VertexType >::Control(), egoa::Vertices::ElectricalProperties< VertexType >::Country(), egoa::Vertices::ElectricalProperties< VertexType >::NominalVoltage(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance(), egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance(), egoa::Vertices::ElectricalProperties< VertexType >::Status(), egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle(), egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_, egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude(), egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitudeSq_, and egoa::Vertices::ElectricalProperties< VertexType >::Zone().

+ +
+
+ +

◆ ShuntConductance() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance ()
+ 		+inline
+
+ +

Getter and setter for the shunt conductance $\shuntconductance(\vertex)$.

+

The shunt conductance is a function $\shuntconductance\colon\vertices\to\reals$. It is measured in MW demanded at a voltage of 1.0 p.u.

+
ElectricalProperties vertex;
+
vertex.ShuntConductance() = 0.11;
+
egoa::Vertices::ElectricalProperties::ShuntConductance
Types::real ShuntConductance() const
Getter for the shunt conductance .
Definition ElectricalProperties.hpp:258
+
Returns
The shunt conductance $\shuntconductance(\vertex)$ of $\vertex\in\vertices$.
+ +

Definition at line 278 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::shuntConductance_.

+ +
+
+ +

◆ ShuntConductance() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::ShuntConductance () const
+ 		+inline
+
+ +

Getter for the shunt conductance $\shuntconductance(\vertex)$.

+

The shunt conductance is a function $\shuntconductance\colon\vertices\to\reals$. It is measured in MW demanded at a voltage of 1.0 p.u.

+
Returns
The shunt conductance $\shuntconductance(\vertex)$ of $\vertex\in\vertices$.
+ +

Definition at line 258 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::shuntConductance_.

+ +
+
+ +

◆ ShuntSusceptance() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance ()
+ 		+inline
+
+ +

Getter and setter for the shunt susceptance $\shuntsusceptance(\vertex)$.

+

The shunt susceptance is a function $\shuntsusceptance\colon\vertices\to\reals$. It is measured in MVAr injected at a voltage of 1.0 p.u.

+
ElectricalProperties vertex;
+
vertex.ShuntSusceptance() = 0.11;
+
egoa::Vertices::ElectricalProperties::ShuntSusceptance
Types::real ShuntSusceptance() const
Getter for the shunt susceptance .
Definition ElectricalProperties.hpp:222
+
Returns
The shunt susceptance $\shuntsusceptance(\vertex)$ of $\vertex\in\vertices$.
+ +

Definition at line 243 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::shuntSusceptance_.

+ +
+
+ +

◆ ShuntSusceptance() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::ShuntSusceptance () const
+ 		+inline
+
+ +

Getter for the shunt susceptance $\shuntsusceptance(\vertex)$.

+

The shunt susceptance is a function $\shuntsusceptance\colon\vertices\to\reals$. It is measured in MVAr injected at a voltage of 1.0 p.u.

+
Returns
The shunt susceptance $\shuntsusceptance(\vertex)$ of $\vertex\in\vertices$.
+ +

Definition at line 222 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::shuntSusceptance_.

+ +
+
+ +

◆ Status() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::BusStatus & egoa::Vertices::ElectricalProperties< VertexType >::Status ()
+ 		+inline
+
+ +

Status of the electrical vertex.

+
See also
Type::Vertices::BusStatus
+
Returns
The status can have a different status.
+ +

Definition at line 638 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::status_.

+ +
+
+ +

◆ Status() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::BusStatus const & egoa::Vertices::ElectricalProperties< VertexType >::Status () const
+ 		+inline
+
+ +

Status of the electrical vertex.

+
See also
Type::Vertices::BusStatus
+
Returns
The status can have a different status.
+ +

Definition at line 650 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::status_.

+ +
+
+ +

◆ Type() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType & egoa::Vertices::ElectricalProperties< VertexType >::Type ()
+ 		+inline
+
+ +

Definition at line 199 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Type() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType egoa::Vertices::ElectricalProperties< VertexType >::Type () const
+ 		+inline
+
+ +

Definition at line 198 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ VoltageAngle() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle ()
+ 		+inline
+
+ +

Getter for the voltage angle $\vangle(\vertex)$.

+

The voltage angle is a function $\vangle\colon\vertices\to\reals$. It is measured in degree.

+
ElectricalProperties vertex;
+
vertex.ShuntConductance() = 0.11;
+
Note
It is used for the data's snapshot and/or optimization's result.
+
Returns
The voltage angle $\vangle(\vertex)$ at vertex $\vertex\in\vertices$.
+ +

Definition at line 370 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::voltageAngle_.

+ +
+
+ +

◆ VoltageAngle() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::VoltageAngle () const
+ 		+inline
+
+ +

Getter for the voltage angle $\vangle(\vertex)$.

+

The voltage angle is a function $\vangle\colon\vertices\to\reals$. It is measured in degree.

+
Note
It is used for the data's snapshot and/or optimization's result.
+
Returns
The voltage angle $\vangle(\vertex)$ at vertex $\vertex\in\vertices$.
+ +

Definition at line 348 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::voltageAngle_.

+ +
+
+ +

◆ VoltageMagnitude() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude ()
+ 		+inline
+
+ +

Getter and setter for the voltage magnitude $\vmagnitude$.

+

The voltage magnitude $\vmagnitude$ is in per unit (p.u.) of the nominal voltage $\voltagenominal$. It represents a set point.

+
Returns
The voltage magnitude $\vmagnitude$.
+ +

Definition at line 331 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitude_.

+ +
+
+ +

◆ VoltageMagnitude() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::VoltageMagnitude () const
+ 		+inline
+
+ +

Getter for the voltage magnitude $\vmagnitude$.

+

The voltage magnitude $\voltagenominal$ is in per unit (p.u.) of the nominal voltage $\voltagenominal$. It represents a set point.

+
Returns
The voltage magnitude $\voltagenominal$.
+ +

Definition at line 317 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitude_.

+ +
+
+ +

◆ X() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::X ()
+ 		+inline
+
+ +

Definition at line 202 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ X() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::X () const
+ 		+inline
+
+ +

Definition at line 201 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Y() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::ElectricalProperties< VertexType >::Y ()
+ 		+inline
+
+ +

Definition at line 205 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Y() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::Y () const
+ 		+inline
+
+ +

Definition at line 204 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ Zone() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::index & egoa::Vertices::ElectricalProperties< VertexType >::Zone ()
+ 		+inline
+
+ +

Getter and setter for the loss zone.

+

A three digit integer from 0 to 999 for defining zones of loss calculation.

+
Note
If the value is 0 this means that there is no zone.
+
ElectricalProperties vertex;
+
vertex.Zone() = 11;
+
egoa::Vertices::ElectricalProperties::Zone
Types::index Zone() const
Getter for the loss zone.
Definition ElectricalProperties.hpp:519
+
Returns
The loss zone.
+ +

Definition at line 538 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::zone_.

+ +
+
+ +

◆ Zone() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::index egoa::Vertices::ElectricalProperties< VertexType >::Zone () const
+ 		+inline
+
+ +

Getter for the loss zone.

+

A three digit integer from 0 to 999 for defining zones of loss calculation.

+
Note
If the value is 0 this means that there is no zone.
+
Returns
The loss zone.
+ +

Definition at line 519 of file ElectricalProperties.hpp.

+ +

References egoa::Vertices::ElectricalProperties< VertexType >::zone_.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
TProperties const & rhs 
)
+ 		+friend
+
+ +

Write the electrical property to an output stream.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
rhsThe right hand side electrical property.
+
+
+
Returns
The output stream.
+ +

Definition at line 776 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ swap

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (ElectricalProperties< VertexType > & lhs,
ElectricalProperties< VertexType > & rhs 
)
+ 		+friend
+
+ +

Swapping the members of two ElectricalVertices.

+
Parameters
+ + + +
lhsLeft ElectricalProperties
rhsRight ElectricalProperties
+
+
+ +

Definition at line 161 of file ElectricalProperties.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ area_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::index egoa::Vertices::ElectricalProperties< VertexType >::area_
+ 		+private
+
+

Country Bus area (1 - 99) indicates in which company/region the station is located, 0 means data unavailable. A two digit integer from 0 to 99 indicating the company or region in which the line is located. This area number should be the same as the area of one of the two terminal vertices. Tie line it indicates the ownership or area to which the losses should be assigned. This area is not related to the meter bus location.

+ +

Definition at line 841 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ carrier_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Vertices::EnergyCarrier egoa::Vertices::ElectricalProperties< VertexType >::carrier_
+ 		+private
+
+

The energy carrier used at this bus such as AC.

+ +

Definition at line 855 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ control_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Vertices::ControlType egoa::Vertices::ElectricalProperties< VertexType >::control_
+ 		+private
+
+

The control type such as PV.

+ +

Definition at line 854 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ country_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::name egoa::Vertices::ElectricalProperties< VertexType >::country_
+ 		+private
+
+ +

Definition at line 840 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ name_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::name egoa::Vertices::ElectricalProperties< VertexType >::name_
+ 		+private
+
+

name of the vertex

+ +

Definition at line 805 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ nominalVoltage_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::nominalVoltage_
+ 		+private
+
+

The nominal voltage also known as base voltage measured in kV.

+ +

Definition at line 819 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ shuntConductance_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::shuntConductance_
+ 		+private
+
+

The shunt conductance $\shuntconductance(\vertex)$.

+ +

Definition at line 814 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ shuntSusceptance_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::shuntSusceptance_
+ 		+private
+
+

The shunt susceptance $\shuntsusceptance(\vertex)$.

+ +

Definition at line 813 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ status_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Vertices::BusStatus egoa::Vertices::ElectricalProperties< VertexType >::status_
+ 		+private
+
+

Station status: active - true, inactive - false

+ +

Definition at line 860 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ type_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TVertexType egoa::Vertices::ElectricalProperties< VertexType >::type_
+ 		+private
+
+

vertex type representing either source, sink or intermediate

+ +

Definition at line 806 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ voltageAngle_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::voltageAngle_
+ 		+private
+
+

The voltage angle $\vangle(\vertex)$ that represents a snapshot of the voltage angle, i.e., final voltage angle from data.

+ +

Definition at line 822 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ voltageBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::ElectricalProperties< VertexType >::voltageBound_
+ 		+private
+
+

The voltage limits $\voltage := [\voltagemin,\voltagemax]$ in per unit (p.u.) of the nominal voltage $\voltagenominal$.

+ +

Definition at line 833 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ voltageMagnitude_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitude_
+ 		+private
+
+

Voltage magnitude $\vmagnitude(\vertex)$ including a snapshot (p.u. set point), i.e., final voltage from data.

+ +

Definition at line 826 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ voltageMagnitudeSq_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::voltageMagnitudeSq_
+ 		+private
+
+

Voltage magnitude squared variable

+ +

Definition at line 830 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ xCoordinate_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::xCoordinate_
+ 		+private
+
+

x-coordinate of the point if available

+ +

Definition at line 807 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ yCoordinate_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::ElectricalProperties< VertexType >::yCoordinate_
+ 		+private
+
+

y-coordinate of the point if available

+ +

Definition at line 808 of file ElectricalProperties.hpp.

+ +
+
+ +

◆ zone_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::index egoa::Vertices::ElectricalProperties< VertexType >::zone_
+ 		+private
+
+

Three digit integer from 0 to 999 for defining zones of loss calculation. A 0 means no zone.

+ +

Definition at line 851 of file ElectricalProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_generator_properties-members.html b/classegoa_1_1_vertices_1_1_generator_properties-members.html new file mode 100644 index 00000000..12d1f877 --- /dev/null +++ b/classegoa_1_1_vertices_1_1_generator_properties-members.html @@ -0,0 +1,217 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Vertices::GeneratorProperties< VertexType > Member List
+
+
+ +

This is the complete list of members for egoa::Vertices::GeneratorProperties< VertexType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Apf() constegoa::Vertices::GeneratorProperties< VertexType >inline
Apf()egoa::Vertices::GeneratorProperties< VertexType >inline
apf_egoa::Vertices::GeneratorProperties< VertexType >private
CapitalCost() constegoa::Vertices::GeneratorProperties< VertexType >inline
CapitalCost()egoa::Vertices::GeneratorProperties< VertexType >inline
capitalCost_egoa::Vertices::GeneratorProperties< VertexType >private
Committable() constegoa::Vertices::GeneratorProperties< VertexType >inline
Committable()egoa::Vertices::GeneratorProperties< VertexType >inline
committable_egoa::Vertices::GeneratorProperties< VertexType >private
Control() constegoa::Vertices::GeneratorProperties< VertexType >inline
Control()egoa::Vertices::GeneratorProperties< VertexType >inline
control_egoa::Vertices::GeneratorProperties< VertexType >private
Efficiency() constegoa::Vertices::GeneratorProperties< VertexType >inline
Efficiency()egoa::Vertices::GeneratorProperties< VertexType >inline
efficiency_egoa::Vertices::GeneratorProperties< VertexType >private
GeneratorProperties() (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
GeneratorType() constegoa::Vertices::GeneratorProperties< VertexType >inline
GeneratorType()egoa::Vertices::GeneratorProperties< VertexType >inline
generatorType_egoa::Vertices::GeneratorProperties< VertexType >private
Header(std::ostream &outputStream)egoa::Vertices::GeneratorProperties< VertexType >inlinestatic
HeaderBusGeneratorName(std::ostream &outputStream) (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inlinestatic
IsActive() constegoa::Vertices::GeneratorProperties< VertexType >inline
IsExtendable() constegoa::Vertices::GeneratorProperties< VertexType >inline
IsExtendable()egoa::Vertices::GeneratorProperties< VertexType >inline
Line(std::ostream &outputStream, Types::real baseMva=1) constegoa::Vertices::GeneratorProperties< VertexType >inline
Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) constegoa::Vertices::GeneratorProperties< VertexType >inline
Line(std::ostream &outputStream, Types::name busName, Types::real baseMva=1) constegoa::Vertices::GeneratorProperties< VertexType >inline
MarginalCost() constegoa::Vertices::GeneratorProperties< VertexType >inline
MarginalCost()egoa::Vertices::GeneratorProperties< VertexType >inline
marginalCost_egoa::Vertices::GeneratorProperties< VertexType >private
minDownTime_egoa::Vertices::GeneratorProperties< VertexType >private
MinimumDownTime() constegoa::Vertices::GeneratorProperties< VertexType >inline
MinimumDownTime()egoa::Vertices::GeneratorProperties< VertexType >inline
MinimumUpTime() constegoa::Vertices::GeneratorProperties< VertexType >inline
MinimumUpTime()egoa::Vertices::GeneratorProperties< VertexType >inline
minUpTime_egoa::Vertices::GeneratorProperties< VertexType >private
Name() const (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
Name() (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
name_egoa::Vertices::GeneratorProperties< VertexType >private
NominalPower() constegoa::Vertices::GeneratorProperties< VertexType >inline
NominalPower()egoa::Vertices::GeneratorProperties< VertexType >inline
nominalPower_egoa::Vertices::GeneratorProperties< VertexType >private
NominalRealPowerBound() constegoa::Vertices::GeneratorProperties< VertexType >inline
NominalRealPowerBound()egoa::Vertices::GeneratorProperties< VertexType >inline
nominalRealPowerBound_egoa::Vertices::GeneratorProperties< VertexType >private
operator!=(GeneratorProperties const &rhs) constegoa::Vertices::GeneratorProperties< VertexType >inline
operator<<egoa::Vertices::GeneratorProperties< VertexType >friend
operator==(GeneratorProperties const &rhs) constegoa::Vertices::GeneratorProperties< VertexType >inline
Pc1() constegoa::Vertices::GeneratorProperties< VertexType >inline
Pc1()egoa::Vertices::GeneratorProperties< VertexType >inline
pc1_egoa::Vertices::GeneratorProperties< VertexType >private
Pc2() constegoa::Vertices::GeneratorProperties< VertexType >inline
Pc2()egoa::Vertices::GeneratorProperties< VertexType >inline
pc2_egoa::Vertices::GeneratorProperties< VertexType >private
pNomExtendable_egoa::Vertices::GeneratorProperties< VertexType >private
PowerSign() constegoa::Vertices::GeneratorProperties< VertexType >inline
PowerSign()egoa::Vertices::GeneratorProperties< VertexType >inline
Qc1Bound() constegoa::Vertices::GeneratorProperties< VertexType >inline
Qc1Bound()egoa::Vertices::GeneratorProperties< VertexType >inline
qc1Bound_egoa::Vertices::GeneratorProperties< VertexType >private
Qc2Bound() constegoa::Vertices::GeneratorProperties< VertexType >inline
Qc2Bound()egoa::Vertices::GeneratorProperties< VertexType >inline
qc2Bound_egoa::Vertices::GeneratorProperties< VertexType >private
Ramp10() constegoa::Vertices::GeneratorProperties< VertexType >inline
Ramp10()egoa::Vertices::GeneratorProperties< VertexType >inline
ramp10_egoa::Vertices::GeneratorProperties< VertexType >private
Ramp30() constegoa::Vertices::GeneratorProperties< VertexType >inline
Ramp30()egoa::Vertices::GeneratorProperties< VertexType >inline
ramp30_egoa::Vertices::GeneratorProperties< VertexType >private
RampAgc() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampAgc()egoa::Vertices::GeneratorProperties< VertexType >inline
rampAgc_egoa::Vertices::GeneratorProperties< VertexType >private
RampLimitDown() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampLimitDown()egoa::Vertices::GeneratorProperties< VertexType >inline
rampLimitDown_egoa::Vertices::GeneratorProperties< VertexType >private
RampLimitShutDown() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampLimitShutDown()egoa::Vertices::GeneratorProperties< VertexType >inline
rampLimitShutDown_egoa::Vertices::GeneratorProperties< VertexType >private
RampLimitStartUp() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampLimitStartUp()egoa::Vertices::GeneratorProperties< VertexType >inline
rampLimitStartUp_egoa::Vertices::GeneratorProperties< VertexType >private
RampLimitUp() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampLimitUp()egoa::Vertices::GeneratorProperties< VertexType >inline
rampLimitUp_egoa::Vertices::GeneratorProperties< VertexType >private
RampQ() constegoa::Vertices::GeneratorProperties< VertexType >inline
RampQ()egoa::Vertices::GeneratorProperties< VertexType >inline
rampQ_egoa::Vertices::GeneratorProperties< VertexType >private
ReactivePower() constegoa::Vertices::GeneratorProperties< VertexType >inline
ReactivePower()egoa::Vertices::GeneratorProperties< VertexType >inline
reactivePower_egoa::Vertices::GeneratorProperties< VertexType >private
ReactivePowerBound() constegoa::Vertices::GeneratorProperties< VertexType >inline
ReactivePowerBound()egoa::Vertices::GeneratorProperties< VertexType >inline
reactivePowerBound_egoa::Vertices::GeneratorProperties< VertexType >private
RealPower() constegoa::Vertices::GeneratorProperties< VertexType >inline
RealPower()egoa::Vertices::GeneratorProperties< VertexType >inline
realPower_egoa::Vertices::GeneratorProperties< VertexType >private
RealPowerBound() constegoa::Vertices::GeneratorProperties< VertexType >inline
RealPowerBound()egoa::Vertices::GeneratorProperties< VertexType >inline
realPowerBound_egoa::Vertices::GeneratorProperties< VertexType >private
Reset()egoa::Vertices::GeneratorProperties< VertexType >inline
ShutDownCost() constegoa::Vertices::GeneratorProperties< VertexType >inline
ShutDownCost()egoa::Vertices::GeneratorProperties< VertexType >inline
shutDownCost_egoa::Vertices::GeneratorProperties< VertexType >private
sign_egoa::Vertices::GeneratorProperties< VertexType >private
StartUpCost() constegoa::Vertices::GeneratorProperties< VertexType >inline
StartUpCost()egoa::Vertices::GeneratorProperties< VertexType >inline
startUpCost_egoa::Vertices::GeneratorProperties< VertexType >private
Status() constegoa::Vertices::GeneratorProperties< VertexType >inline
Status()egoa::Vertices::GeneratorProperties< VertexType >inline
status_egoa::Vertices::GeneratorProperties< VertexType >private
swapegoa::Vertices::GeneratorProperties< VertexType >friend
TBound typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
TBusStatus typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
TControlType typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
TGeneratorType typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
TPowerSign typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
TVertexType typedef (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >
Type() const (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
Type() (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
type_egoa::Vertices::GeneratorProperties< VertexType >private
VoltageMagnitude() constegoa::Vertices::GeneratorProperties< VertexType >inline
VoltageMagnitude()egoa::Vertices::GeneratorProperties< VertexType >inline
voltageMagnitudeSnapshot_egoa::Vertices::GeneratorProperties< VertexType >private
X() const (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
X() (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
xCoordinate_egoa::Vertices::GeneratorProperties< VertexType >private
Y() const (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
Y() (defined in egoa::Vertices::GeneratorProperties< VertexType >)egoa::Vertices::GeneratorProperties< VertexType >inline
yCoordinate_egoa::Vertices::GeneratorProperties< VertexType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_generator_properties.html b/classegoa_1_1_vertices_1_1_generator_properties.html new file mode 100644 index 00000000..247af728 --- /dev/null +++ b/classegoa_1_1_vertices_1_1_generator_properties.html @@ -0,0 +1,4729 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Vertices::GeneratorProperties< VertexType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Friends | +List of all members
+
egoa::Vertices::GeneratorProperties< VertexType > Class Template Reference
+
+
+ +

Class having all generator properties. + More...

+ +

#include <GeneratorProperties.hpp>

+ + + + + + + + + + + + + + + + +

+Public Types

Bound Specific Types
using TBound = Bound< Types::real >
 
Type Specific Types
using TVertexType = VertexType
 
using TControlType = Vertices::ControlType
 
using TGeneratorType = Vertices::GeneratorType
 
using TBusStatus = Vertices::BusStatus
 
using TPowerSign = Vertices::PowerSign
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
void Reset ()
 Reset to default values.
 
bool operator!= (GeneratorProperties const &rhs) const
 Inequality comparator of two generator properties.
 
bool operator== (GeneratorProperties const &rhs) const
 Comparison of two generator properties.
 
Basic Properties
Types::name Name () const
 
Types::name & Name ()
 
TVertexType Type () const
 
TVertexType & Type ()
 
Types::real X () const
 
Types::real & X ()
 
Types::real Y () const
 
Types::real & Y ()
 
Voltage
Types::real VoltageMagnitude () const
 Getter for the voltage magnitude setpoint $\vmagnitude$ in per unit (p.u.) of the nominal voltage.
 
Types::real & VoltageMagnitude ()
 Getter and setter for the voltage magnitude setpoint $\vmagnitude$ in per unit (p.u.) of the nominal voltage.
 
Nominal Power Information
bool IsExtendable () const
 Determines if the generator is extendable (used for production expansion).
 
bool & IsExtendable ()
 Setter and determines if the generator is extendable (used for production expansion).
 
Types::real NominalPower () const
 Getter for the nominal power base.
 
Types::real & NominalPower ()
 Getter and setter for the nominal power base.
 
TBound NominalRealPowerBound () const
 Getter for the nominal real power bound with $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ while the generator $\vertex\in\generators$ is extendable.
 
TBound & NominalRealPowerBound ()
 Getter and setter for the nominal real power bound with $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ while the generator $\vertex\in\generators$ is extendable.
 
TPowerSign PowerSign () const
 Getter for the power sign.
 
TPowerSign & PowerSign ()
 Getter for the power sign.
 
Real Power Information
Types::real RealPower () const
 Getter for the real power $\realpowergeneration$.
 
Types::real & RealPower ()
 Getter and setter for the real power set point $\realpowergeneration$.
 
TBound RealPowerBound () const
 Getter for the real power bound $[\realpowergenerationmin, \realpowergenerationmax]$.
 
TBound & RealPowerBound ()
 Getter and setter for the real power bound $[\realpowergenerationmin, \realpowergenerationmax]$.
 
Types::real Pc1 () const
 Getter for the lower real power output of PQ capability curve (MW) at PC1.
 
Types::real & Pc1 ()
 Getter and setter for the lower real power output of PQ capability curve (MW) at PC1.
 
Types::real Pc2 () const
 Getter for the upper real power output of PQ capability curve (MW) at PC2.
 
Types::real & Pc2 ()
 Getter and setter for the upper real power output of PQ capability curve (MW) at PC2.
 
Reactive Power Information
Types::real ReactivePower () const
 Getter for the reactive power $\reactivepowergeneration$.
 
Types::real & ReactivePower ()
 Getter and setter for the reactive power $\reactivepowergeneration$.
 
TBound ReactivePowerBound () const
 Getter for the reactive power bound $[\reactivepowergenerationmin, \reactivepowergenerationmax]$.
 
TBound & ReactivePowerBound ()
 Getter and setter for the reactive power bound $[\reactivepowergenerationmin, \reactivepowergenerationmax]$.
 
TBound Qc1Bound () const
 Getter for the reactive power output bound at PC1.
 
TBound & Qc1Bound ()
 Getter and setter for the reactive power output bound at PC1.
 
TBound Qc2Bound () const
 Getter for the reactive power output bound at PC2.
 
TBound & Qc2Bound ()
 Getter and setter for the reactive power output bound at PC2.
 
Status Specific Information
bool IsActive () const
 Determines if the electrical vertex is active.
 
TBusStatus Status () const
 Status of the electrical vertex.
 
TBusStatus & Status ()
 Status of the electrical vertex.
 
bool Committable () const
 Getter for the unit commitment.
 
bool & Committable ()
 Getter and setter for the unit commitment.
 
Type Specific Information
Vertices::ControlType Control () const
 Getter for the control strategy.
 
Vertices::ControlType & Control ()
 Getter and setter for the control strategy.
 
Vertices::GeneratorType GeneratorType () const
 Getter for the generator type.
 
Vertices::GeneratorType & GeneratorType ()
 Getter and setter for the generator type.
 
Types::real Efficiency () const
 Getter for the efficiency of the generator.
 
Types::real & Efficiency ()
 Getter and setter for the efficiency of the generator.
 
Cost Specific Information
Types::real MarginalCost () const
 Getter for the marginal cost.
 
Types::real & MarginalCost ()
 Getter and setter for the marginal cost.
 
Types::real CapitalCost () const
 Getter for the capital cost.
 
Types::real & CapitalCost ()
 Getter and setter for the capital cost.
 
Types::real StartUpCost () const
 Getter for the startup costs for the generator.
 
Types::real & StartUpCost ()
 Getter and setter for the startup costs for the generator.
 
Types::real ShutDownCost () const
 Getter for the shutdown costs for the generator.
 
Types::real & ShutDownCost ()
 Getter and setter for the shutdown costs for the generator.
 
Ramp Specific Information

Ramp Limits: The inner dynamic of generators does not always allow to change the production level, i.e., a maximum possible change is set by ramp limits.

+

Ramp rate: Describes how fast generator outputs can be changed. There are usually ramping up (increasing) and down (decreasing), i.e., the unit is in units of power over time (here MW/min).

+
Types::real MinimumUpTime () const
 Getter for the minimum availability (active) time.
 
Types::real & MinimumUpTime ()
 Getter and setter for the minimum availability (active) time.
 
Types::real MinimumDownTime () const
 Getter for the minimum time to be inactive.
 
Types::real & MinimumDownTime ()
 Getter and setter for the minimum time to be inactive.
 
Types::real RampAgc () const
 Getter for the ramp rate for load following AGC.
 
Types::real & RampAgc ()
 Getter and setter for the ramp rate for load following AGC.
 
Types::real Ramp10 () const
 Getter for the ramp rate for a 10 minute reserve.
 
Types::real & Ramp10 ()
 Getter and setter for the ramp rate for a 10 minute reserve.
 
Types::real Ramp30 () const
 Getter for the ramp rate for a 30 minute reserve.
 
Types::real & Ramp30 ()
 Getter and setter for the ramp rate for a 30 minute reserve.
 
Types::real RampQ () const
 Getter for the ramp rate for the reactive power (2 sec timescale).
 
Types::real & RampQ ()
 Getter and setter for the ramp rate for the reactive power (2 sec timescale).
 
Types::real Apf () const
 Getter for the area participation factor (APF).
 
Types::real & Apf ()
 Getter and setter for the area participation factor (APF).
 
Types::real RampLimitUp () const
 Getter for the maximum increase in power.
 
Types::real & RampLimitUp ()
 Getter and setter for the maximum increase in power.
 
Types::real RampLimitDown () const
 Getter for the maximum decrease in power.
 
Types::real & RampLimitDown ()
 Getter and setter for the maximum decrease in power.
 
Types::real RampLimitStartUp () const
 Getter for the maximum increase in power at startup.
 
Types::real & RampLimitStartUp ()
 Getter and setter for the maximum increase in power at start-up.
 
Types::real RampLimitShutDown () const
 Getter for the maximum decrease in power at shut-down.
 
Types::real & RampLimitShutDown ()
 Getter and setter for the maximum decrease in power at shut-down.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Attributes

Basic Property Members
Types::name name_
 
TVertexType type_
 
Types::real xCoordinate_
 
Types::real yCoordinate_
 
Voltage Related Members
Types::real voltageMagnitudeSnapshot_
 
Nominal Power Members
Types::real nominalPower_
 
bool pNomExtendable_
 
TBound nominalRealPowerBound_
 
TPowerSign sign_
 
Real Power Members
Types::real realPower_
 
TBound realPowerBound_
 
Types::real pc1_
 
Types::real pc2_
 
Types::real reactivePower_
 
TBound reactivePowerBound_
 
TBound qc1Bound_
 
TBound qc2Bound_
 
Status Members
TBusStatus status_
 
bool committable_
 
Type Members
TControlType control_
 
TGeneratorType generatorType_
 
Types::real efficiency_
 
Cost Specific Members
Types::real marginalCost_
 
Types::real capitalCost_
 
Types::real startUpCost_
 
Types::real shutDownCost_
 
Ramp Members

Ramp Limits: The inner dynamic of generators does not always allow to change the production level, i.e., a maximum possible change is set by ramp limits.

+

Ramp rate: Describes how fast generator outputs can be changed. There are usually ramping up (increasing) and down (decreasing), i.e., the unit is in units of power over time (here MW/min).

+
Types::real minUpTime_
 
Types::real minDownTime_
 
Types::real rampAgc_
 
Types::real ramp10_
 
Types::real ramp30_
 
Types::real rampQ_
 
Types::real apf_
 
Types::real rampLimitUp_
 
Types::real rampLimitDown_
 
Types::real rampLimitStartUp_
 
Types::real rampLimitShutDown_
 
+ + + + +

+Friends

void swap (GeneratorProperties &lhs, GeneratorProperties &rhs)
 Swapping the members of two generator properties.
 
+ + + + + + + + + + + + + + + + + + +

Output

void Line (std::ostream &outputStream, Types::real baseMva=1) const
 Write the values of the generator property.
 
void Line (std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const
 Writes the values including the identifier of the generator property.
 
void Line (std::ostream &outputStream, Types::name busName, Types::real baseMva=1) const
 Writes the values including the name of the generator property.
 
std::ostream & operator<< (std::ostream &outputStream, GeneratorProperties const &rhs)
 Writes the generator property to an output stream.
 
static void Header (std::ostream &outputStream)
 Write the header to the output stream.
 
static void HeaderBusGeneratorName (std::ostream &outputStream)
 
+

Detailed Description

+
template<class VertexType = Vertices::IeeeBusType>
+class egoa::Vertices::GeneratorProperties< VertexType >

Class having all generator properties.

+
Template Parameters
+ + +
VertexTypeThe vertex type is used to categorize the vertex, e.g., as slack bus.
+
+
+ +

Definition at line 28 of file GeneratorProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TBound = Bound<Types::real>
+
+ +

Definition at line 32 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ TBusStatus

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TBusStatus = Vertices::BusStatus
+
+ +

Definition at line 40 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ TControlType

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TControlType = Vertices::ControlType
+
+ +

Definition at line 38 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ TGeneratorType

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TGeneratorType = Vertices::GeneratorType
+
+ +

Definition at line 39 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ TPowerSign

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TPowerSign = Vertices::PowerSign
+
+ +

Definition at line 41 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + +
using egoa::Vertices::GeneratorProperties< VertexType >::TVertexType = VertexType
+
+ +

Definition at line 37 of file GeneratorProperties.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ GeneratorProperties()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
egoa::Vertices::GeneratorProperties< VertexType >::GeneratorProperties ()
+ 		+inline
+
+ +

Definition at line 49 of file GeneratorProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Apf() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Apf ()
+ 		+inline
+
+ +

Getter and setter for the area participation factor (APF).

+
Returns
The area participation factor (APF).
+ +

Definition at line 1245 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::apf_.

+ +
+
+ +

◆ Apf() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Apf () const
+ 		+inline
+
+ +

Getter for the area participation factor (APF).

+
Returns
The area participation factor (APF).
+ +

Definition at line 1234 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::apf_.

+ +
+
+ +

◆ CapitalCost() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::CapitalCost ()
+ 		+inline
+
+ +

Getter and setter for the capital cost.

+

The capital cost by extending the generator's nominal power $\realpowernominal$ by 1 MW.

+
Returns
The capital cost.
+ +

Definition at line 987 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::capitalCost_.

+ +
+
+ +

◆ CapitalCost() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::CapitalCost () const
+ 		+inline
+
+ +

Getter for the capital cost.

+

The capital cost by extending the generator's nominal power $\realpowernominal$ by 1 MW.

+
Returns
The capital cost.
+ +

Definition at line 975 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::capitalCost_.

+ +
+
+ +

◆ Committable() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool & egoa::Vertices::GeneratorProperties< VertexType >::Committable ()
+ 		+inline
+
+ +

Getter and setter for the unit commitment.

+
Precondition
This can only be true if the generator is not extendable.
+
Returns
true if unit commitment, false otherwise.
+ +

Definition at line 846 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::committable_.

+ +
+
+ +

◆ Committable() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::Committable () const
+ 		+inline
+
+ +

Getter for the unit commitment.

+
Precondition
This can only be true if the generator is not extendable.
+
Returns
true if unit commitment, false otherwise.
+ +

Definition at line 833 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::committable_.

+ +
+
+ +

◆ Control() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::ControlType & egoa::Vertices::GeneratorProperties< VertexType >::Control ()
+ 		+inline
+
+ +

Getter and setter for the control strategy.

+

The control strategy must be either PQ, PV, or Slack. The slack vertex represents a reference vertex used to set a voltage angle for example to 0 and thus, determine the other voltage angle.

+
See also
Vertices::ControlType
+
Returns
The control strategy.
+ +

Definition at line 883 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::control_.

+ +
+
+ +

◆ Control() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::ControlType egoa::Vertices::GeneratorProperties< VertexType >::Control () const
+ 		+inline
+
+ +

Getter for the control strategy.

+

The control strategy must be either PQ, PV, or Slack. The slack vertex represents a reference vertex used to set a voltage angle for example to 0 and thus, determine the other voltage angle.

+
See also
Vertices::ControlType
+
Returns
The control strategy.
+ +

Definition at line 867 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::control_.

+ +
+
+ +

◆ Efficiency() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Efficiency ()
+ 		+inline
+
+ +

Getter and setter for the efficiency of the generator.

+

The efficiency of a generator is calculated by the ratio between primary and electrical energy.

+
Returns
The efficiency of the generator.
+ +

Definition at line 936 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::efficiency_.

+ +
+
+ +

◆ Efficiency() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Efficiency () const
+ 		+inline
+
+ +

Getter for the efficiency of the generator.

+

The efficiency of a generator is calculated by the ratio between primary and electrical energy.

+
Returns
The efficiency of the generator.
+ +

Definition at line 923 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::efficiency_.

+ +
+
+ +

◆ GeneratorType() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::GeneratorType & egoa::Vertices::GeneratorProperties< VertexType >::GeneratorType ()
+ 		+inline
+
+ +

Getter and setter for the generator type.

+

The generator type determines if it is a conventional or renewable generator.

+
See also
Vertices::GeneratorType
+
Returns
The generator type.
+ +

Definition at line 911 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::generatorType_.

+ +
+
+ +

◆ GeneratorType() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Vertices::GeneratorType egoa::Vertices::GeneratorProperties< VertexType >::GeneratorType () const
+ 		+inline
+
+ +

Getter for the generator type.

+

The generator type determines if it is a conventional or renewable generator.

+
See also
Vertices::GeneratorType
+
Returns
The generator type.
+ +

Definition at line 897 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::generatorType_.

+ +
+
+ +

◆ Header()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
static void egoa::Vertices::GeneratorProperties< VertexType >::Header (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Write the header to the output stream.

+

List all IEEE standard input data.

+
Parameters
+ + +
outputStreamThe stream to write data to, e.g., std::cout.
+
+
+ +

Definition at line 1402 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ HeaderBusGeneratorName()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
static void egoa::Vertices::GeneratorProperties< VertexType >::HeaderBusGeneratorName (std::ostream & outputStream)
+ 		+inlinestatic
+
+ +

Definition at line 1428 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ IsActive()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::IsActive () const
+ 		+inline
+
+ +

Determines if the electrical vertex is active.

+
See also
Status
+
Returns
true if active (on), false otherwise (unknown).
+ +

Definition at line 787 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Status().

+ +
+
+ +

◆ IsExtendable() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool & egoa::Vertices::GeneratorProperties< VertexType >::IsExtendable ()
+ 		+inline
+
+ +

Setter and determines if the generator is extendable (used for production expansion).

+

This is mainly used for renewable energy sources to determine how much the new energy source is expanded. For already existing energy sources this is usually set to False. However, in some cases it makes sense to extend already existing energy sources, too, and the flag might be True, too.

+
generator.IsExtendable() = true;
+
Precondition
Default is false.
+
Note
If it is true the extendable generator then the generator's nominal real power $\realpowernominal$ lies between $\realpowernominalmin$ and $\realpowernominalmax$ meaning

+\[ + \realpowernominal := [\realpowernominalmin,\realpowernominalmax]. + \] +

+ Otherwise, the generator's nominal real power $\realpowernominal$ is defined by a fixed value. Thus, use $\realpowernominal$ by using Mbase when IsExtendable is false, and $\realpowernominalmin$ and $\realpowernominalmax$ by using NominalRealPower if IsExtendable is true.
+
See also
NominalPower
+
+IsExtendable
+
+NominalRealPowerBound
+
Returns
true if the generator $\vertex\in\generators$ is extendable, false otherwise.
+ +

Definition at line 433 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pNomExtendable_.

+ +
+
+ +

◆ IsExtendable() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::IsExtendable () const
+ 		+inline
+
+ +

Determines if the generator is extendable (used for production expansion).

+

This is mainly used for renewable energy sources to determine how much the new energy source is expanded. For already existing energy sources this is usually set to False. However, in some cases it makes sense to extend already existing energy sources, too, and the flag might be True, too.

+
Precondition
Default is false.
+
Note
If it is true the extendable generator then the generator's nominal real power $\realpowernominal$ lies between $\realpowernominalmin$ and $\realpowernominalmax$ meaning

+\[ + \realpowernominal := [\realpowernominalmin,\realpowernominalmax]. + \] +

+ Otherwise, the generator's nominal real power $\realpowernominal$ is defined by a fixed value. Thus, use $\realpowernominal$ by using Mbase when IsExtendable is false, and $\realpowernominalmin$ and $\realpowernominalmax$ by using NominalRealPower if IsExtendable is true.
+
See also
NominalPower
+
+NominalRealPowerBound
+
Returns
True if the generator $\vertex\in\generators$ is extendable, false otherwise.
+ +

Definition at line 391 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pNomExtendable_.

+ +
+
+ +

◆ Line() [1/3]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::Vertices::GeneratorProperties< VertexType >::Line (std::ostream & outputStream,
Types::name busName,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Writes the values including the name of the generator property.

+

List all IEEE standard input data.

+
Parameters
+ + + + +
outputStreamThe stream to write data to
[in]busNameThe bus name
[in]baseMvaThe base mva
+
+
+ +

Definition at line 1537 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Apf(), egoa::Vertices::GeneratorProperties< VertexType >::IsActive(), egoa::Bound< BoundType >::Maximum(), egoa::Bound< BoundType >::Minimum(), egoa::Vertices::GeneratorProperties< VertexType >::NominalPower(), egoa::Vertices::GeneratorProperties< VertexType >::Pc1(), egoa::Vertices::GeneratorProperties< VertexType >::Pc2(), egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp10(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp30(), egoa::Vertices::GeneratorProperties< VertexType >::RampAgc(), egoa::Vertices::GeneratorProperties< VertexType >::RampQ(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::RealPower(), egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound(), and egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude().

+ +
+
+ +

◆ Line() [2/3]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void egoa::Vertices::GeneratorProperties< VertexType >::Line (std::ostream & outputStream,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Write the values of the generator property.

+

List all IEEE standard input data.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]baseMvaThe base MVA.
+
+
+ +

Definition at line 1462 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Apf(), egoa::Vertices::GeneratorProperties< VertexType >::IsActive(), egoa::Bound< BoundType >::Maximum(), egoa::Bound< BoundType >::Minimum(), egoa::Vertices::GeneratorProperties< VertexType >::NominalPower(), egoa::Vertices::GeneratorProperties< VertexType >::Pc1(), egoa::Vertices::GeneratorProperties< VertexType >::Pc2(), egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp10(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp30(), egoa::Vertices::GeneratorProperties< VertexType >::RampAgc(), egoa::Vertices::GeneratorProperties< VertexType >::RampQ(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::RealPower(), egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound(), and egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude().

+ +
+
+ +

◆ Line() [3/3]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void egoa::Vertices::GeneratorProperties< VertexType >::Line (std::ostream & outputStream,
Types::vertexId identifier,
Types::real baseMva = 1 
) const
+ 		+inline
+
+ +

Writes the values including the identifier of the generator property.

+

List all IEEE standard input data.

+
Parameters
+ + + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]identifierThe identifier.
[in]baseMvaThe base MVA.
+
+
+ +

Definition at line 1499 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Apf(), egoa::Vertices::GeneratorProperties< VertexType >::IsActive(), egoa::Bound< BoundType >::Maximum(), egoa::Bound< BoundType >::Minimum(), egoa::Vertices::GeneratorProperties< VertexType >::NominalPower(), egoa::Vertices::GeneratorProperties< VertexType >::Pc1(), egoa::Vertices::GeneratorProperties< VertexType >::Pc2(), egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp10(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp30(), egoa::Vertices::GeneratorProperties< VertexType >::RampAgc(), egoa::Vertices::GeneratorProperties< VertexType >::RampQ(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::RealPower(), egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound(), and egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude().

+ +
+
+ +

◆ MarginalCost() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::MarginalCost ()
+ 		+inline
+
+ +

Getter and setter for the marginal cost.

+

The marginal cost for the production of 1 MW.

+
Returns
The marginal cost.
+ +

Definition at line 963 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::marginalCost_.

+ +
+
+ +

◆ MarginalCost() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::MarginalCost () const
+ 		+inline
+
+ +

Getter for the marginal cost.

+

The marginal cost for the production of 1 MW.

+
Returns
The marginal cost.
+ +

Definition at line 952 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::marginalCost_.

+ +
+
+ +

◆ MinimumDownTime() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::MinimumDownTime ()
+ 		+inline
+
+ +

Getter and setter for the minimum time to be inactive.

+

This is measured in number of snapshots. This represents the minimum number of snapshots to be in inactive status until a startup is possible again, i.e., being in active status.

+
Precondition
Only if Committable() is true.
+
Returns
The minimum time to be inactive of the generator.
+ +

Definition at line 1119 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::minDownTime_.

+ +
+
+ +

◆ MinimumDownTime() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::MinimumDownTime () const
+ 		+inline
+
+ +

Getter for the minimum time to be inactive.

+

This is measured in number of snapshots. This represents the minimum number of snapshots to be in inactive status until a startup is possible again, i.e., being in active status.

+
Precondition
Only if Committable() is true.
+
Returns
The minimum time to be inactive of the generator.
+ +

Definition at line 1102 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::minDownTime_.

+ +
+
+ +

◆ MinimumUpTime() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::MinimumUpTime ()
+ 		+inline
+
+ +

Getter and setter for the minimum availability (active) time.

+

This is measured in number of snapshots. This represents the minimum number of snapshots to be in active status until a shutdown is possible, i.e., being in inactive status.

+
Precondition
Only if Committable() is true.
+
Returns
The minimum active time of the generator.
+ +

Definition at line 1086 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::minUpTime_.

+ +
+
+ +

◆ MinimumUpTime() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::MinimumUpTime () const
+ 		+inline
+
+ +

Getter for the minimum availability (active) time.

+

This is measured in number of snapshots. This represents the minimum number of snapshots to be in active status until a shutdown is possible, i.e., being in inactive status.

+
Precondition
Only if Committable() is true.
+
Returns
The minimum active time of the generator.
+ +

Definition at line 1069 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::minUpTime_.

+ +
+
+ +

◆ Name() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name & egoa::Vertices::GeneratorProperties< VertexType >::Name ()
+ 		+inline
+
+ +

Definition at line 313 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ Name() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name egoa::Vertices::GeneratorProperties< VertexType >::Name () const
+ 		+inline
+
+ +

Definition at line 312 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ NominalPower() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::NominalPower ()
+ 		+inline
+
+ +

Getter and setter for the nominal power base.

+

If the generator $\vertex\in\generators$ is NOT extendable—meaning IsExtendable is False---and thus, fixed the nominal power is used to normalize or to denormalize into/from the p.u. units.

+
if ( !generator.IsExtendable() )
+
{ // nominal real power is a value and thus, is fixed.
+
generator.Mbase() = 11.11;
+
}
+
See also
NominalPower
+
+IsExtendable
+
+NominalRealPowerBound
+
Returns
The nominal power base.
+ +

Definition at line 485 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::nominalPower_.

+ +
+
+ +

◆ NominalPower() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::NominalPower () const
+ 		+inline
+
+ +

Getter for the nominal power base.

+

If the generator $\vertex\in\generators$ is NOT extendable—meaning IsExtendable is false---and thus, fixed the nominal power is used to normalize or to denormalize into/from the p.u. units.

+
GeneratorProperties const & generator;
+
...
+
if ( !generator.IsExtendable() )
+
{ // nominal real power is a value and thus, is fixed.
+
std::cout << "p_nom = " << generator.Mbase() << std::endl;
+
}
+
egoa::Vertices::GeneratorProperties
Class having all generator properties.
Definition GeneratorProperties.hpp:28
+
See also
NominalPower
+
+IsExtendable
+
+NominalRealPowerBound
+
Returns
The nominal power base.
+ +

Definition at line 460 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::nominalPower_.

+ +
+
+ +

◆ NominalRealPowerBound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::GeneratorProperties< VertexType >::NominalRealPowerBound ()
+ 		+inline
+
+ +

Getter and setter for the nominal real power bound with $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ while the generator $\vertex\in\generators$ is extendable.

+
Precondition
Check if the $\vertex\in\generators$ is extendable meaning IsExtendable is true.
+
if ( generator.IsExtendable() )
+
{ // nominal real power lies in between a bound and thus, is flexible.
+
generator.NominalRealPower().Minimum() = 0.0;
+
generator.NominalRealPower().Maximum() = 11.11;
+
}
+
See also
NominalPower
+
+IsExtendable
+
+NominalRealPowerBound
+
Returns
The nominal real power bound $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$.
+ +

Definition at line 547 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::nominalRealPowerBound_.

+ +
+
+ +

◆ NominalRealPowerBound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::NominalRealPowerBound () const
+ 		+inline
+
+ +

Getter for the nominal real power bound with $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$ while the generator $\vertex\in\generators$ is extendable.

+
Precondition
Check if the $\vertex\in\generators$ is extendable meaning IsExtendable is true.
+
if ( generator.IsExtendable() )
+
{ // nominal real power lies in between a bound and thus, is flexible.
+
std::cout << "p_nom_min = " << generator.NominalRealPower().Minimum()
+
<< "p_nom_max = " << generator.NominalRealPower().Maximum() << std::endl;
+
} else
+
{ // nominal real power is a value and thus, is fixed.
+
std::cout << "p_nom = " << generator.Mbase() << std::endl;
+
}
+
See also
NominalPower
+
+IsExtendable
+
+NominalRealPowerBound
+
Returns
The nominal real power bound $\realpowernominal:=[\realpowernominalmin,\realpowernominalmax]$.
+ +

Definition at line 517 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::nominalRealPowerBound_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::operator!= (GeneratorProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Inequality comparator of two generator properties.

+

@Name Comparators

+
Parameters
+ + +
rhsThe right hand side generator properties.
+
+
+
Returns
true if both vertices are not equal, false otherwise.
+ +

Definition at line 163 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::operator== (GeneratorProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Comparison of two generator properties.

+
Parameters
+ + +
rhsThe right hand side generator properties.
+
+
+
Returns
true if both vertices are equal, false otherwise.
+ +

Definition at line 176 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Apf(), egoa::Vertices::GeneratorProperties< VertexType >::CapitalCost(), egoa::Vertices::GeneratorProperties< VertexType >::Committable(), egoa::Vertices::GeneratorProperties< VertexType >::Control(), egoa::Vertices::GeneratorProperties< VertexType >::Efficiency(), egoa::Vertices::GeneratorProperties< VertexType >::GeneratorType(), egoa::Vertices::GeneratorProperties< VertexType >::IsExtendable(), egoa::Vertices::GeneratorProperties< VertexType >::MarginalCost(), egoa::Bound< BoundType >::Maximum(), egoa::Bound< BoundType >::Minimum(), egoa::Vertices::GeneratorProperties< VertexType >::MinimumDownTime(), egoa::Vertices::GeneratorProperties< VertexType >::MinimumUpTime(), egoa::Vertices::GeneratorProperties< VertexType >::NominalPower(), egoa::Vertices::GeneratorProperties< VertexType >::NominalRealPowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::Pc1(), egoa::Vertices::GeneratorProperties< VertexType >::Pc2(), egoa::Vertices::GeneratorProperties< VertexType >::PowerSign(), egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp10(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp30(), egoa::Vertices::GeneratorProperties< VertexType >::RampAgc(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitDown(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitShutDown(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitStartUp(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitUp(), egoa::Vertices::GeneratorProperties< VertexType >::RampQ(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::RealPower(), egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::ShutDownCost(), egoa::Vertices::GeneratorProperties< VertexType >::StartUpCost(), egoa::Vertices::GeneratorProperties< VertexType >::Status(), and egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude().

+ +
+
+ +

◆ Pc1() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Pc1 ()
+ 		+inline
+
+ +

Getter and setter for the lower real power output of PQ capability curve (MW) at PC1.

+
Returns
The lower real power output of PQ capability curve (MW).
+ +

Definition at line 647 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pc1_.

+ +
+
+ +

◆ Pc1() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Pc1 () const
+ 		+inline
+
+ +

Getter for the lower real power output of PQ capability curve (MW) at PC1.

+
Returns
The lower real power output of PQ capability curve (MW).
+ +

Definition at line 635 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pc1_.

+ +
+
+ +

◆ Pc2() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Pc2 ()
+ 		+inline
+
+ +

Getter and setter for the upper real power output of PQ capability curve (MW) at PC2.

+
Returns
The upper real power output of PQ capability curve (MW).
+ +

Definition at line 671 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pc2_.

+ +
+
+ +

◆ Pc2() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Pc2 () const
+ 		+inline
+
+ +

Getter for the upper real power output of PQ capability curve (MW) at PC2.

+
Returns
The upper real power output of PQ capability curve (MW).
+ +

Definition at line 659 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::pc2_.

+ +
+
+ +

◆ PowerSign() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TPowerSign & egoa::Vertices::GeneratorProperties< VertexType >::PowerSign ()
+ 		+inline
+
+ +

Getter for the power sign.

+
Returns
The power sign, if 1 the generator produces energy, otherwise if -1 it consumes energy.
+
Todo:
make enum
+ +

Definition at line 573 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::sign_.

+ +
+
+ +

◆ PowerSign() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TPowerSign egoa::Vertices::GeneratorProperties< VertexType >::PowerSign () const
+ 		+inline
+
+ +

Getter for the power sign.

+
Returns
The power sign, if 1 the generator produces energy, otherwise if -1 it consumes energy.
+
Todo:
make enum
+ +

Definition at line 560 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::sign_.

+ +
+
+ +

◆ Qc1Bound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound ()
+ 		+inline
+
+ +

Getter and setter for the reactive power output bound at PC1.

+

This is measured in MVAr.

+
Returns
The reactive power output bound at PC1.
+ +

Definition at line 746 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::qc1Bound_.

+ +
+
+ +

◆ Qc1Bound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound () const
+ 		+inline
+
+ +

Getter for the reactive power output bound at PC1.

+

This is measured in MVAr.

+
Returns
The reactive power output bound at PC1.
+ +

Definition at line 734 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::qc1Bound_.

+ +
+
+ +

◆ Qc2Bound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound ()
+ 		+inline
+
+ +

Getter and setter for the reactive power output bound at PC2.

+

This is measured in MVAr.

+
Returns
The reactive power output bound at PC2.
+ +

Definition at line 770 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::qc2Bound_.

+ +
+
+ +

◆ Qc2Bound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound () const
+ 		+inline
+
+ +

Getter for the reactive power output bound at PC2.

+

This is measured in MVAr.

+
Returns
The reactive power output bound at PC2.
+ +

Definition at line 758 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::qc2Bound_.

+ +
+
+ +

◆ Ramp10() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Ramp10 ()
+ 		+inline
+
+ +

Getter and setter for the ramp rate for a 10 minute reserve.

+

The ramp rate is measured in MW and is part of the IEEE data.

+
Returns
The ramp rate for a 10 minute reserve.
+ +

Definition at line 1173 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::ramp10_.

+ +
+
+ +

◆ Ramp10() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Ramp10 () const
+ 		+inline
+
+ +

Getter for the ramp rate for a 10 minute reserve.

+

The ramp rate is measured in MW and is part of the IEEE data.

+
Returns
The ramp rate for a 10 minute reserve.
+ +

Definition at line 1160 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::ramp10_.

+ +
+
+ +

◆ Ramp30() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Ramp30 ()
+ 		+inline
+
+ +

Getter and setter for the ramp rate for a 30 minute reserve.

+

The ramp rate is measured in MW and is part of the IEEE data.

+
Returns
The ramp rate for a 30 minute reserve.
+ +

Definition at line 1198 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::ramp30_.

+ +
+
+ +

◆ Ramp30() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Ramp30 () const
+ 		+inline
+
+ +

Getter for the ramp rate for a 30 minute reserve.

+

The ramp rate is measured in MW and is part of the IEEE data.

+
Returns
The ramp rate for a 30 minute reserve.
+ +

Definition at line 1185 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::ramp30_.

+ +
+
+ +

◆ RampAgc() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampAgc ()
+ 		+inline
+
+ +

Getter and setter for the ramp rate for load following AGC.

+

The ramp rate is measured in MW/min and is part of the IEEE data.

+
Note
AGC stands for Automatic Generation Control.
+
Returns
The ramp rate for load following AGC.
+ +

Definition at line 1148 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampAgc_.

+ +
+
+ +

◆ RampAgc() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampAgc () const
+ 		+inline
+
+ +

Getter for the ramp rate for load following AGC.

+

The ramp rate is measured in MW/min and is part of the IEEE data.

+
Note
AGC stands for Automatic Generation Control.
+
Returns
The ramp rate for load following AGC.
+ +

Definition at line 1133 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampAgc_.

+ +
+
+ +

◆ RampLimitDown() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampLimitDown ()
+ 		+inline
+
+ +

Getter and setter for the maximum decrease in power.

+

The maximum decrease in power is measured in per snapshot.

+
Note
Ignore if infinity.
+
Returns
The maximum decrease in power.
+ +

Definition at line 1301 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitDown_.

+ +
+
+ +

◆ RampLimitDown() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampLimitDown () const
+ 		+inline
+
+ +

Getter for the maximum decrease in power.

+

The maximum decrease in power is measured in per snapshot.

+
Note
Ignore if infinity.
+
Returns
The maximum decrease in power.
+ +

Definition at line 1287 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitDown_.

+ +
+
+ +

◆ RampLimitShutDown() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampLimitShutDown ()
+ 		+inline
+
+ +

Getter and setter for the maximum decrease in power at shut-down.

+

The maximum decrease in power at shutdown is measured in per unit of nominal power $\realpowernominal$.

+
Precondition
Only if Committable() is true.
+
Returns
The maximum decrease in power at shutdown.
+ +

Definition at line 1359 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitShutDown_.

+ +
+
+ +

◆ RampLimitShutDown() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampLimitShutDown () const
+ 		+inline
+
+ +

Getter for the maximum decrease in power at shut-down.

+

The maximum decrease in power at shutdown is measured in per unit of nominal power $\realpowernominal$.

+
Precondition
Only if Committable() is true.
+
Returns
The maximum decrease in power at shutdown.
+ +

Definition at line 1344 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitShutDown_.

+ +
+
+ +

◆ RampLimitStartUp() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampLimitStartUp ()
+ 		+inline
+
+ +

Getter and setter for the maximum increase in power at start-up.

+

The maximum increase in power at startup is measured in per unit of nominal power $\realpowernominal$.

+
Precondition
Only if Committable() is true.
+
Returns
The maximum increase in power at startup.
+ +

Definition at line 1330 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitStartUp_.

+ +
+
+ +

◆ RampLimitStartUp() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampLimitStartUp () const
+ 		+inline
+
+ +

Getter for the maximum increase in power at startup.

+

The maximum increase in power at startup is measured in per unit of nominal power $\realpowernominal$.

+
Precondition
Only if Committable() is true.
+
Returns
The maximum increase in power at startup.
+ +

Definition at line 1315 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitStartUp_.

+ +
+
+ +

◆ RampLimitUp() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampLimitUp ()
+ 		+inline
+
+ +

Getter and setter for the maximum increase in power.

+

The maximum increase in power is measured in per snapshot.

+
Note
Ignore if infinity.
+
Returns
The maximum increase in power.
+ +

Definition at line 1273 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitUp_.

+ +
+
+ +

◆ RampLimitUp() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampLimitUp () const
+ 		+inline
+
+ +

Getter for the maximum increase in power.

+

The maximum increase in power is measured in per snapshot.

+
Note
Ignore if infinity.
+
Returns
The maximum increase in power.
+ +

Definition at line 1259 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampLimitUp_.

+ +
+
+ +

◆ RampQ() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RampQ ()
+ 		+inline
+
+ +

Getter and setter for the ramp rate for the reactive power (2 sec timescale).

+

The ramp rate is measured in MVAr/min and is part of the IEEE data.

+
Returns
The ramp rate for the reactive power.
+ +

Definition at line 1224 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampQ_.

+ +
+
+ +

◆ RampQ() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RampQ () const
+ 		+inline
+
+ +

Getter for the ramp rate for the reactive power (2 sec timescale).

+

The ramp rate is measured in MVAr/min and is part of the IEEE data.

+
Returns
The ramp rate for the reactive power.
+ +

Definition at line 1211 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::rampQ_.

+ +
+
+ +

◆ ReactivePower() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower ()
+ 		+inline
+
+ +

Getter and setter for the reactive power $\reactivepowergeneration$.

+
Returns
The real power $\reactivepowergeneration$.
+ +

Definition at line 698 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::reactivePower_.

+ +
+
+ +

◆ ReactivePower() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower () const
+ 		+inline
+
+ +

Getter for the reactive power $\reactivepowergeneration$.

+
Returns
The real power $\reactivepowergeneration$.
+ +

Definition at line 687 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::reactivePower_.

+ +
+
+ +

◆ ReactivePowerBound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound ()
+ 		+inline
+
+ +

Getter and setter for the reactive power bound $[\reactivepowergenerationmin, \reactivepowergenerationmax]$.

+
Returns
The reactive power bound $[\reactivepowergenerationmin,\reactivepowergenerationmax]$.
+ +

Definition at line 722 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::reactivePowerBound_.

+ +
+
+ +

◆ ReactivePowerBound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound () const
+ 		+inline
+
+ +

Getter for the reactive power bound $[\reactivepowergenerationmin, \reactivepowergenerationmax]$.

+
Returns
The reactive power bound $[\reactivepowergenerationmin,\reactivepowergenerationmax]$.
+ +

Definition at line 710 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::reactivePowerBound_.

+ +
+
+ +

◆ RealPower() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::RealPower ()
+ 		+inline
+
+ +

Getter and setter for the real power set point $\realpowergeneration$.

+
Returns
The real power set point $\realpowergeneration$.
+ +

Definition at line 599 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::realPower_.

+ +
+
+ +

◆ RealPower() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::RealPower () const
+ 		+inline
+
+ +

Getter for the real power $\realpowergeneration$.

+
Returns
The real power $\realpowergeneration$.
+ +

Definition at line 588 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::realPower_.

+ +
+
+ +

◆ RealPowerBound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound ()
+ 		+inline
+
+ +

Getter and setter for the real power bound $[\realpowergenerationmin, \realpowergenerationmax]$.

+
Returns
The real power bound $[\realpowergenerationmin, + \realpowergenerationmax]$.
+ +

Definition at line 623 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::realPowerBound_.

+ +
+
+ +

◆ RealPowerBound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound () const
+ 		+inline
+
+ +

Getter for the real power bound $[\realpowergenerationmin, \realpowergenerationmax]$.

+
Returns
The real power bound $[\realpowergenerationmin, + \realpowergenerationmax]$.
+ +

Definition at line 611 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::realPowerBound_.

+ +
+
+ +

◆ Reset()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
void egoa::Vertices::GeneratorProperties< VertexType >::Reset ()
+ 		+inline
+
+ +

Reset to default values.

+ +

Definition at line 100 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::Apf(), egoa::Vertices::GeneratorProperties< VertexType >::CapitalCost(), egoa::Vertices::GeneratorProperties< VertexType >::Committable(), egoa::Vertices::GeneratorProperties< VertexType >::Control(), egoa::Vertices::GeneratorProperties< VertexType >::Efficiency(), egoa::Vertices::GeneratorProperties< VertexType >::GeneratorType(), egoa::Vertices::GeneratorProperties< VertexType >::IsExtendable(), egoa::Vertices::GeneratorProperties< VertexType >::MarginalCost(), egoa::Vertices::GeneratorProperties< VertexType >::MinimumDownTime(), egoa::Vertices::GeneratorProperties< VertexType >::MinimumUpTime(), egoa::Vertices::GeneratorProperties< VertexType >::NominalPower(), egoa::Vertices::GeneratorProperties< VertexType >::NominalRealPowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::Pc1(), egoa::Vertices::GeneratorProperties< VertexType >::Pc2(), egoa::Vertices::GeneratorProperties< VertexType >::PowerSign(), egoa::Vertices::GeneratorProperties< VertexType >::Qc1Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Qc2Bound(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp10(), egoa::Vertices::GeneratorProperties< VertexType >::Ramp30(), egoa::Vertices::GeneratorProperties< VertexType >::RampAgc(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitDown(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitShutDown(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitStartUp(), egoa::Vertices::GeneratorProperties< VertexType >::RampLimitUp(), egoa::Vertices::GeneratorProperties< VertexType >::RampQ(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePower(), egoa::Vertices::GeneratorProperties< VertexType >::ReactivePowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::RealPower(), egoa::Vertices::GeneratorProperties< VertexType >::RealPowerBound(), egoa::Vertices::GeneratorProperties< VertexType >::ShutDownCost(), egoa::Vertices::GeneratorProperties< VertexType >::StartUpCost(), egoa::Vertices::GeneratorProperties< VertexType >::Status(), and egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude().

+ +
+
+ +

◆ ShutDownCost() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::ShutDownCost ()
+ 		+inline
+
+ +

Getter and setter for the shutdown costs for the generator.

+
Precondition
Only if Committable() is true.
+
Returns
The shut-down cost for the generator.
+ +

Definition at line 1037 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::shutDownCost_.

+ +
+
+ +

◆ ShutDownCost() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::ShutDownCost () const
+ 		+inline
+
+ +

Getter for the shutdown costs for the generator.

+
Precondition
Only if Committable() is true.
+
Returns
The shut-down cost for the generator.
+ +

Definition at line 1024 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::shutDownCost_.

+ +
+
+ +

◆ StartUpCost() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::StartUpCost ()
+ 		+inline
+
+ +

Getter and setter for the startup costs for the generator.

+
Precondition
Only if Committable() is true.
+
Returns
The startup cost for the generator.
+ +

Definition at line 1012 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::startUpCost_.

+ +
+
+ +

◆ StartUpCost() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::StartUpCost () const
+ 		+inline
+
+ +

Getter for the startup costs for the generator.

+
Precondition
Only if Committable() is true.
+
Returns
The startup cost for the generator.
+ +

Definition at line 999 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::startUpCost_.

+ +
+
+ +

◆ Status() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBusStatus & egoa::Vertices::GeneratorProperties< VertexType >::Status ()
+ 		+inline
+
+ +

Status of the electrical vertex.

+

The status of the generator/machine is described by active (in-service) or inactive (out-of-service).

+
See also
Type::Vertex::BusStatus
+
Returns
The status can have a different status.
+
Todo:
USE DIFFERENT TYPE see bus
+ +

Definition at line 820 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::status_.

+ +
+
+ +

◆ Status() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBusStatus egoa::Vertices::GeneratorProperties< VertexType >::Status () const
+ 		+inline
+
+ +

Status of the electrical vertex.

+

The status of the generator/machine is described by active (in-service) or inactive (out-of-service).

+
See also
Type::Vertex::BusStatus
+
Returns
The status can have a different status.
+
Todo:
USE DIFFERENT TYPE see bus
+ +

Definition at line 805 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::status_.

+ +
+
+ +

◆ Type() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType & egoa::Vertices::GeneratorProperties< VertexType >::Type ()
+ 		+inline
+
+ +

Definition at line 316 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ Type() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType egoa::Vertices::GeneratorProperties< VertexType >::Type () const
+ 		+inline
+
+ +

Definition at line 315 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ VoltageMagnitude() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude ()
+ 		+inline
+
+ +

Getter and setter for the voltage magnitude setpoint $\vmagnitude$ in per unit (p.u.) of the nominal voltage.

+
Returns
The voltage magnitude $\vmagnitude$.
+ +

Definition at line 348 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::voltageMagnitudeSnapshot_.

+ +
+
+ +

◆ VoltageMagnitude() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::VoltageMagnitude () const
+ 		+inline
+
+ +

Getter for the voltage magnitude setpoint $\vmagnitude$ in per unit (p.u.) of the nominal voltage.

+
Returns
The voltage magnitude $\vmagnitude$.
+ +

Definition at line 336 of file GeneratorProperties.hpp.

+ +

References egoa::Vertices::GeneratorProperties< VertexType >::voltageMagnitudeSnapshot_.

+ +
+
+ +

◆ X() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::X ()
+ 		+inline
+
+ +

Definition at line 319 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ X() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::X () const
+ 		+inline
+
+ +

Definition at line 318 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ Y() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::GeneratorProperties< VertexType >::Y ()
+ 		+inline
+
+ +

Definition at line 322 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ Y() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::Y () const
+ 		+inline
+
+ +

Definition at line 321 of file GeneratorProperties.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator<<

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & outputStream,
GeneratorProperties< VertexType > const & rhs 
)
+ 		+friend
+
+ +

Writes the generator property to an output stream.

+
Parameters
+ + + +
outputStreamThe stream to write data to, e.g., std::cout.
[in]rhsThe right hand side of the generator property.
+
+
+
Returns
The output stream.
+ +

Definition at line 1376 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ swap

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (GeneratorProperties< VertexType > & lhs,
GeneratorProperties< VertexType > & rhs 
)
+ 		+friend
+
+ +

Swapping the members of two generator properties.

+
Parameters
+ + + +
lhsThe left hand side generator property.
rhsThe right hand side generator property.
+
+
+ +

Definition at line 248 of file GeneratorProperties.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ apf_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::apf_
+ 		+private
+
+

The area participation factor (APF).

+ +

Definition at line 1683 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ capitalCost_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::capitalCost_
+ 		+private
+
+

The Capital cost of extending p_nom by 1 MW.

+ +

Definition at line 1658 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ committable_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::committable_
+ 		+private
+
+

Decides whether unit commitment is active (while not being extendable) or inactive.

+ +

Definition at line 1639 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ control_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TControlType egoa::Vertices::GeneratorProperties< VertexType >::control_
+ 		+private
+
+

The control strategy, must be either PQ, PV or Slack.

+ +

Definition at line 1646 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ efficiency_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::efficiency_
+ 		+private
+
+

The efficiency representing the ratio between primary and electrical energy.

+ +

Definition at line 1650 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ generatorType_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TGeneratorType egoa::Vertices::GeneratorProperties< VertexType >::generatorType_
+ 		+private
+
+

The generator type, i.e., solar.

+ +

Definition at line 1649 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ marginalCost_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::marginalCost_
+ 		+private
+
+

The marginal cost for production of 1 MW.

+ +

Definition at line 1657 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ minDownTime_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::minDownTime_
+ 		+private
+
+

The minimum number of snapshots to be inactive.

+ +

Definition at line 1677 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ minUpTime_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::minUpTime_
+ 		+private
+
+

The minimum number of snapshots to be active.

+ +

Definition at line 1676 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ name_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::name egoa::Vertices::GeneratorProperties< VertexType >::name_
+ 		+private
+
+

name of the vertex

+ +

Definition at line 1573 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ nominalPower_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::nominalPower_
+ 		+private
+
+

The total nominal power of machine (also known as MVA base or mBase), defaults set to baseMVA.

+ +

Definition at line 1588 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ nominalRealPowerBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::nominalRealPowerBound_
+ 		+private
+
+

If the generator is extendable the nominal real power $\realpowernominal$ can be in the interval $\realpowernominal\coloneqq[\realpowernominalmin, + \realpowernominalmax]$.

+ +

Definition at line 1600 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ pc1_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::pc1_
+ 		+private
+
+

The lower real power output of PQ capability curve at PC1 in MW.

+ +

Definition at line 1616 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ pc2_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::pc2_
+ 		+private
+
+

The upper real power output of PQ capability curve at PC2 in MW.

+ +

Definition at line 1619 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ pNomExtendable_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
bool egoa::Vertices::GeneratorProperties< VertexType >::pNomExtendable_
+ 		+private
+
+

Determines if the generator is extendable and thus, uses nominalRealPowerBound_ bounds. If the generator is not extendable mBase_ is used. Thus, the extension/upgrade level is unknown and can be decided by, e.g., a MILP. However, generators that are not build are not interesting for standard problems such as MTSF or MFF. Note that for PyPsa this are often renewable energies.

+ +

Definition at line 1591 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ qc1Bound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::qc1Bound_
+ 		+private
+
+

The reactive power output bound at PC1 in MVAr.

+ +

Definition at line 1632 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ qc2Bound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::qc2Bound_
+ 		+private
+
+

The reactive power output bound at PC2 in MVAr.

+ +

Definition at line 1633 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ ramp10_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::ramp10_
+ 		+private
+
+

The ramp rate for 10 minute reserves (in MW).

+ +

Definition at line 1680 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ ramp30_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::ramp30_
+ 		+private
+
+

The ramp rate for 30 minute reserves (in MW).

+ +

Definition at line 1681 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampAgc_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampAgc_
+ 		+private
+
+

The ramp rate for load following AGC, where AGC stands for automatic generation control (in MW/min).

+ +

Definition at line 1679 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampLimitDown_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampLimitDown_
+ 		+private
+
+

The maximum decrease in power per snapshot.

+ +

Definition at line 1686 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampLimitShutDown_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampLimitShutDown_
+ 		+private
+
+

The maximum decrease at shutdown in per unit of nominal power.

+ +

Definition at line 1688 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampLimitStartUp_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampLimitStartUp_
+ 		+private
+
+

The maximum increase at startup in per unit of nominal power.

+ +

Definition at line 1687 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampLimitUp_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampLimitUp_
+ 		+private
+
+

The maximum increase in power per snapshot.

+ +

Definition at line 1685 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ rampQ_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::rampQ_
+ 		+private
+
+

The ramp rate for reactive power (2 sec timescale) (in MVAr/min).

+ +

Definition at line 1682 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ reactivePower_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::reactivePower_
+ 		+private
+
+

The reactive power generation $\reactivepowergeneration$ in MVAr.

+ +

Definition at line 1626 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ reactivePowerBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::reactivePowerBound_
+ 		+private
+
+

The reactive power output bound $[\reactivepowergenerationmin, + \reactivepowergenerationmax]$ in MVAr.

+ +

Definition at line 1629 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ realPower_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::realPower_
+ 		+private
+
+

The real power generation $\realpowergeneration$ in MW.

+ +

Definition at line 1610 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ realPowerBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::GeneratorProperties< VertexType >::realPowerBound_
+ 		+private
+
+

The real power output bound $[\realpowergenerationmin, + \realpowergenerationmax]$ in MW.

+ +

Definition at line 1613 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ shutDownCost_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::shutDownCost_
+ 		+private
+
+

The shutdown cost of the generator.

+ +

Definition at line 1661 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ sign_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TPowerSign egoa::Vertices::GeneratorProperties< VertexType >::sign_
+ 		+private
+
+

The power sign (1 means generation, -1 means load)

+ +

Definition at line 1605 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ startUpCost_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::startUpCost_
+ 		+private
+
+

The startup cost of the generator.

+ +

Definition at line 1660 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ status_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBusStatus egoa::Vertices::GeneratorProperties< VertexType >::status_
+ 		+private
+
+

Describes the status of the generator.

+ +

Definition at line 1638 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ type_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TVertexType egoa::Vertices::GeneratorProperties< VertexType >::type_
+ 		+private
+
+

vertex type representing either source, sink or intermediate

+ +

Definition at line 1574 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ voltageMagnitudeSnapshot_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::voltageMagnitudeSnapshot_
+ 		+private
+
+

The voltage magnitude set point in per unit (p.u.) of the nominal voltage $\voltagenominal$.

+ +

Definition at line 1581 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ xCoordinate_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::xCoordinate_
+ 		+private
+
+

x-coordinate of the point if available

+ +

Definition at line 1575 of file GeneratorProperties.hpp.

+ +
+
+ +

◆ yCoordinate_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::GeneratorProperties< VertexType >::yCoordinate_
+ 		+private
+
+

y-coordinate of the point if available

+ +

Definition at line 1576 of file GeneratorProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_load_properties-members.html b/classegoa_1_1_vertices_1_1_load_properties-members.html new file mode 100644 index 00000000..b9b6c3cc --- /dev/null +++ b/classegoa_1_1_vertices_1_1_load_properties-members.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Vertices::LoadProperties< VertexType > Member List
+
+
+ +

This is the complete list of members for egoa::Vertices::LoadProperties< VertexType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
LoadProperties()egoa::Vertices::LoadProperties< VertexType >inline
LoadProperties(Types::name name)egoa::Vertices::LoadProperties< VertexType >inline
Name()egoa::Vertices::LoadProperties< VertexType >inline
Name() constegoa::Vertices::LoadProperties< VertexType >inline
name_egoa::Vertices::LoadProperties< VertexType >private
operator!=(LoadProperties const &rhs) constegoa::Vertices::LoadProperties< VertexType >inline
operator==(LoadProperties const &rhs) constegoa::Vertices::LoadProperties< VertexType >inline
ReactivePowerLoad() constegoa::Vertices::LoadProperties< VertexType >inline
ReactivePowerLoad()egoa::Vertices::LoadProperties< VertexType >inline
reactivePowerLoad_egoa::Vertices::LoadProperties< VertexType >private
ReactivePowerLoadBound() constegoa::Vertices::LoadProperties< VertexType >inline
ReactivePowerLoadBound()egoa::Vertices::LoadProperties< VertexType >inline
reactivePowerLoadBound_egoa::Vertices::LoadProperties< VertexType >private
RealPowerLoad() constegoa::Vertices::LoadProperties< VertexType >inline
RealPowerLoad()egoa::Vertices::LoadProperties< VertexType >inline
realPowerLoad_egoa::Vertices::LoadProperties< VertexType >private
RealPowerLoadBound() constegoa::Vertices::LoadProperties< VertexType >inline
RealPowerLoadBound()egoa::Vertices::LoadProperties< VertexType >inline
realPowerLoadBound_egoa::Vertices::LoadProperties< VertexType >private
TBound typedef (defined in egoa::Vertices::LoadProperties< VertexType >)egoa::Vertices::LoadProperties< VertexType >private
TVertexType typedef (defined in egoa::Vertices::LoadProperties< VertexType >)egoa::Vertices::LoadProperties< VertexType >private
Type()egoa::Vertices::LoadProperties< VertexType >inline
Type() constegoa::Vertices::LoadProperties< VertexType >inline
type_egoa::Vertices::LoadProperties< VertexType >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_load_properties.html b/classegoa_1_1_vertices_1_1_load_properties.html new file mode 100644 index 00000000..288475e5 --- /dev/null +++ b/classegoa_1_1_vertices_1_1_load_properties.html @@ -0,0 +1,966 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Vertices::LoadProperties< VertexType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::Vertices::LoadProperties< VertexType > Class Template Reference
+
+
+ +

Class having all load properties. + More...

+ +

#include <LoadProperties.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 LoadProperties ()
 Constructs the object.
 
 LoadProperties (Types::name name)
 Constructs the object.
 
Real power
Types::name & Name ()
 Getter for the name of the vertex.
 
Types::name Name () const
 Getter and setter for the name of the vertex.
 
TVertexType & Type ()
 Getter for the type of the vertex.
 
TVertexType const & Type () const
 Getter and setter for the type of the vertex.
 
Types::real RealPowerLoad () const
 Getter for the real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).
 
Types::real & RealPowerLoad ()
 Getter and setter for the real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).
 
TBound RealPowerLoadBound () const
 Getter for the real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).
 
TBound & RealPowerLoadBound ()
 Getter and setter for the real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).
 
Reactive Power Demand
Types::real ReactivePowerLoad () const
 Getter for the reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).
 
Types::real & ReactivePowerLoad ()
 Getter for the reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).
 
TBound ReactivePowerLoadBound () const
 Getter for the reactive power demand bound $[\reactivepowerdemandmin, \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).
 
TBound & ReactivePowerLoadBound ()
 Getter and setter for the reactive power demand bound $[\reactivepowerdemandmin, + \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).
 
Comparators
bool operator!= (LoadProperties const &rhs) const
 Inequality comparator.
 
bool operator== (LoadProperties const &rhs) const
 Equality comparator.
 
+ + + + + +

+Private Types

using TVertexType = VertexType
 
using TBound = Bound< Types::real >
 
+ + + + + + + + + + + + + + + + +

+Private Attributes

General Information Members
Types::name name_
 
TVertexType type_
 
Real Power Members
Types::real realPowerLoad_
 
TBound realPowerLoadBound_
 
Reactive Power Members
Types::real reactivePowerLoad_
 
TBound reactivePowerLoadBound_
 
+

Detailed Description

+
template<class VertexType = Vertices::IeeeBusType>
+class egoa::Vertices::LoadProperties< VertexType >

Class having all load properties.

+
Template Parameters
+ + +
VertexTypeRepresents the type specification, e.g., IeeeBusType.
+
+
+
Precondition
The vertex type should provide the option load.
+ +

Definition at line 24 of file LoadProperties.hpp.

+

Member Typedef Documentation

+ +

◆ TBound

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
using egoa::Vertices::LoadProperties< VertexType >::TBound = Bound<Types::real>
+ 		+private
+
+ +

Definition at line 28 of file LoadProperties.hpp.

+ +
+
+ +

◆ TVertexType

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
using egoa::Vertices::LoadProperties< VertexType >::TVertexType = VertexType
+ 		+private
+
+ +

Definition at line 27 of file LoadProperties.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ LoadProperties() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
egoa::Vertices::LoadProperties< VertexType >::LoadProperties ()
+ 		+inline
+
+ +

Constructs the object.

+ +

Definition at line 38 of file LoadProperties.hpp.

+ +
+
+ +

◆ LoadProperties() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
egoa::Vertices::LoadProperties< VertexType >::LoadProperties (Types::name name)
+ 		+inline
+
+ +

Constructs the object.

+
Parameters
+ + +
[in]nameThe name of the vertex.
+
+
+ +

Definition at line 52 of file LoadProperties.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Name() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name & egoa::Vertices::LoadProperties< VertexType >::Name ()
+ 		+inline
+
+ +

Getter for the name of the vertex.

+
Returns
The name of the vertex.
+ +

Definition at line 71 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::name_.

+ +
+
+ +

◆ Name() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::name egoa::Vertices::LoadProperties< VertexType >::Name () const
+ 		+inline
+
+ +

Getter and setter for the name of the vertex.

+
Returns
The name of the vertex.
+ +

Definition at line 81 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::name_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::LoadProperties< VertexType >::operator!= (LoadProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Inequality comparator.

+
Parameters
+ + +
rhsThe right hand side LoadProperties.
+
+
+
Returns
true if both vertices are not equal, false otherwise.
+ +

Definition at line 240 of file LoadProperties.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + + +
bool egoa::Vertices::LoadProperties< VertexType >::operator== (LoadProperties< VertexType > const & rhs) const
+ 		+inline
+
+ +

Equality comparator.

+
Parameters
+ + +
rhsThe right hand side LoadProperties.
+
+
+
Returns
true if both vertices are equal, false otherwise.
+ +

Definition at line 253 of file LoadProperties.hpp.

+ +

References egoa::Bound< BoundType >::Maximum(), egoa::Bound< BoundType >::Minimum(), egoa::Vertices::LoadProperties< VertexType >::Name(), egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoad(), egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoadBound(), egoa::Vertices::LoadProperties< VertexType >::RealPowerLoad(), egoa::Vertices::LoadProperties< VertexType >::RealPowerLoadBound(), and egoa::Vertices::LoadProperties< VertexType >::Type().

+ +
+
+ +

◆ ReactivePowerLoad() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoad ()
+ 		+inline
+
+ +

Getter for the reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).

+
Returns
The reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).
+ +

Definition at line 193 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoad_.

+ +
+
+ +

◆ ReactivePowerLoad() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoad () const
+ 		+inline
+
+ +

Getter for the reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).

+
Returns
The reactive power demand $\reactivepowerdemand$ in per unit (p.u.) nominal power (MVAr).
+ +

Definition at line 179 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoad_.

+ +
+
+ +

◆ ReactivePowerLoadBound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoadBound ()
+ 		+inline
+
+ +

Getter and setter for the reactive power demand bound $[\reactivepowerdemandmin, + \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).

+
Returns
The reactive power demand demand bound $[\reactivepowerdemandmin, \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).
+ +

Definition at line 222 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoadBound_.

+ +
+
+ +

◆ ReactivePowerLoadBound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::LoadProperties< VertexType >::ReactivePowerLoadBound () const
+ 		+inline
+
+ +

Getter for the reactive power demand bound $[\reactivepowerdemandmin, \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).

+
Returns
The reactive power demand bound $[\reactivepowerdemandmin, \reactivepowerdemandmax]$ in per unit (p.u.) nominal power (MVAr).
+ +

Definition at line 207 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoadBound_.

+ +
+
+ +

◆ RealPowerLoad() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real & egoa::Vertices::LoadProperties< VertexType >::RealPowerLoad ()
+ 		+inline
+
+ +

Getter and setter for the real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).

+
Returns
The real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).
+ +

Definition at line 132 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::realPowerLoad_.

+ +
+
+ +

◆ RealPowerLoad() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
Types::real egoa::Vertices::LoadProperties< VertexType >::RealPowerLoad () const
+ 		+inline
+
+ +

Getter for the real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).

+
Returns
The real power demand $\realpowerdemand$ set point in per unit (p.u.) nominal power (MW).
+ +

Definition at line 119 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::realPowerLoad_.

+ +
+
+ +

◆ RealPowerLoadBound() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound & egoa::Vertices::LoadProperties< VertexType >::RealPowerLoadBound ()
+ 		+inline
+
+ +

Getter and setter for the real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).

+
Returns
The real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).
+ +

Definition at line 160 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::realPowerLoadBound_.

+ +
+
+ +

◆ RealPowerLoadBound() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TBound egoa::Vertices::LoadProperties< VertexType >::RealPowerLoadBound () const
+ 		+inline
+
+ +

Getter for the real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).

+
Returns
The real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$ in per unit (p.u.) nominal power (MW).
+ +

Definition at line 146 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::realPowerLoadBound_.

+ +
+
+ +

◆ Type() [1/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType & egoa::Vertices::LoadProperties< VertexType >::Type ()
+ 		+inline
+
+ +

Getter for the type of the vertex.

+
Returns
The type of the vertex.
+ +

Definition at line 91 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::type_.

+ +
+
+ +

◆ Type() [2/2]

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + + + + +
TVertexType const & egoa::Vertices::LoadProperties< VertexType >::Type () const
+ 		+inline
+
+ +

Getter and setter for the type of the vertex.

+
Returns
The type of the vertex.
+ +

Definition at line 101 of file LoadProperties.hpp.

+ +

References egoa::Vertices::LoadProperties< VertexType >::type_.

+ +
+
+

Member Data Documentation

+ +

◆ name_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::name egoa::Vertices::LoadProperties< VertexType >::name_
+ 		+private
+
+

The name of the vertex.

+ +

Definition at line 274 of file LoadProperties.hpp.

+ +
+
+ +

◆ reactivePowerLoad_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoad_
+ 		+private
+
+

The reactive power demand $\reactivepowerdemand$.

+ +

Definition at line 288 of file LoadProperties.hpp.

+ +
+
+ +

◆ reactivePowerLoadBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::LoadProperties< VertexType >::reactivePowerLoadBound_
+ 		+private
+
+

The real power demand bound $[\reactivepowerdemandmin, \reactivepowerdemandmax]$.

+ +

Definition at line 291 of file LoadProperties.hpp.

+ +
+
+ +

◆ realPowerLoad_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
Types::real egoa::Vertices::LoadProperties< VertexType >::realPowerLoad_
+ 		+private
+
+

The real power demand $\realpowerdemand$.

+ +

Definition at line 280 of file LoadProperties.hpp.

+ +
+
+ +

◆ realPowerLoadBound_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TBound egoa::Vertices::LoadProperties< VertexType >::realPowerLoadBound_
+ 		+private
+
+

The real power demand bound $[\realpowerdemandmin, \realpowerdemandmax]$.

+ +

Definition at line 281 of file LoadProperties.hpp.

+ +
+
+ +

◆ type_

+ +
+
+
+template<class VertexType = Vertices::IeeeBusType>
+ + + + + +
+ + + + +
TVertexType egoa::Vertices::LoadProperties< VertexType >::type_
+ 		+private
+
+

The type of the vertex.

+ +

Definition at line 275 of file LoadProperties.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_vertex-members.html b/classegoa_1_1_vertices_1_1_vertex-members.html new file mode 100644 index 00000000..99bc3931 --- /dev/null +++ b/classegoa_1_1_vertices_1_1_vertex-members.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::Vertices::Vertex< PropertyType > Member List
+
+
+ +

This is the complete list of members for egoa::Vertices::Vertex< PropertyType >, including all inherited members.

+ + + + + + + + + + + + +
egoa::DynamicGraphegoa::Vertices::Vertex< PropertyType >friend
Identifier() const (defined in egoa::Vertices::Vertex< PropertyType >)egoa::Vertices::Vertex< PropertyType >inline
identifier_egoa::Vertices::Vertex< PropertyType >private
operator!=egoa::Vertices::Vertex< PropertyType >friend
operator==egoa::Vertices::Vertex< PropertyType >friend
Properties() (defined in egoa::Vertices::Vertex< PropertyType >)egoa::Vertices::Vertex< PropertyType >inline
Properties() const (defined in egoa::Vertices::Vertex< PropertyType >)egoa::Vertices::Vertex< PropertyType >inline
properties_egoa::Vertices::Vertex< PropertyType >private
swapegoa::Vertices::Vertex< PropertyType >friend
TProperties typedefegoa::Vertices::Vertex< PropertyType >
Vertex(Types::vertexId identifier, TProperties properties)egoa::Vertices::Vertex< PropertyType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_vertices_1_1_vertex.html b/classegoa_1_1_vertices_1_1_vertex.html new file mode 100644 index 00000000..433d70b6 --- /dev/null +++ b/classegoa_1_1_vertices_1_1_vertex.html @@ -0,0 +1,543 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Vertices::Vertex< PropertyType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Friends | +List of all members
+
egoa::Vertices::Vertex< PropertyType > Class Template Reference
+
+
+ +

Class for a vertex. + More...

+ +

#include <Vertex.hpp>

+ + + + +

+Public Types

using TProperties = PropertyType
 
+ + + + + +

+Public Member Functions

Constructors and Destructor
 Vertex (Types::vertexId identifier, TProperties properties)
 Constructs the vertex object.
 
+ + + + + + + + + + + +

+Friends

void swap (Vertex &lhs, Vertex &rhs)
 Swapping the members of two Vertex.
 
Comparators
bool operator== (Vertex const &lhs, Vertex const &rhs)
 Compares two vertices for equality.
 
bool operator!= (Vertex const &lhs, Vertex const &rhs)
 Compares two vertices for inequality.
 
+ + + + + + + + + + + + + + +

Getter and setter

template<typename , typename >
class egoa::DynamicGraph
 
Types::vertexId identifier_
 
TProperties properties_
 
Types::vertexId Identifier () const
 
TProperties & Properties ()
 
TProperties const & Properties () const
 
+

Detailed Description

+
template<class PropertyType>
+class egoa::Vertices::Vertex< PropertyType >

Class for a vertex.

+
Template Parameters
+ + +
PropertyTypeThe property of a vertex, e.g., ElectricalProperties, specialize the vertex.
+
+
+
See also
egoa::Vertices::ElectricalProperties
+ +

Definition at line 29 of file Vertex.hpp.

+

Member Typedef Documentation

+ +

◆ TProperties

+ +
+
+
+template<class PropertyType >
+ + + + +
using egoa::Vertices::Vertex< PropertyType >::TProperties = PropertyType
+
+

The type of the properties.

+ +

Definition at line 33 of file Vertex.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Vertex()

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
egoa::Vertices::Vertex< PropertyType >::Vertex (Types::vertexId identifier,
TProperties properties 
)
+ 		+inline
+
+ +

Constructs the vertex object.

+
Parameters
+ + + +
[in]identifierThe identifier of the vertex.
[in]propertiesThe properties object of the vertex.
+
+
+ +

Definition at line 46 of file Vertex.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Identifier()

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::Vertices::Vertex< PropertyType >::Identifier () const
+ 		+inline
+
+ +

Definition at line 100 of file Vertex.hpp.

+ +
+
+ +

◆ Properties() [1/2]

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + +
TProperties & egoa::Vertices::Vertex< PropertyType >::Properties ()
+ 		+inline
+
+ +

Definition at line 102 of file Vertex.hpp.

+ +
+
+ +

◆ Properties() [2/2]

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + +
TProperties const & egoa::Vertices::Vertex< PropertyType >::Properties () const
+ 		+inline
+
+ +

Definition at line 103 of file Vertex.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ egoa::DynamicGraph

+ +
+
+
+template<class PropertyType >
+
+template<typename , typename >
+ + + + + +
+ + + + +
friend class egoa::DynamicGraph
+ 		+friend
+
+

The DynamicGraph class can access private members.

+ +

Definition at line 107 of file Vertex.hpp.

+ +
+
+ +

◆ operator!=

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (Vertex< PropertyType > const & lhs,
Vertex< PropertyType > const & rhs 
)
+ 		+friend
+
+ +

Compares two vertices for inequality.

+
Parameters
+ + + +
lhsThe left vertex.
rhsThe right vertex.
+
+
+
Returns
false if the vertices are the same, true otherwise.
+ +

Definition at line 91 of file Vertex.hpp.

+ +
+
+ +

◆ operator==

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (Vertex< PropertyType > const & lhs,
Vertex< PropertyType > const & rhs 
)
+ 		+friend
+
+ +

Compares two vertices for equality.

+
Parameters
+ + + +
lhsThe left vertex.
rhsThe right vertex.
+
+
+
Returns
true if the vertex are the same, false otherwise.
+ +

Definition at line 77 of file Vertex.hpp.

+ +
+
+ +

◆ swap

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void swap (Vertex< PropertyType > & lhs,
Vertex< PropertyType > & rhs 
)
+ 		+friend
+
+ +

Swapping the members of two Vertex.

+
Parameters
+ + + +
lhsThe left vertex.
rhsThe right vertex.
+
+
+ +

Definition at line 58 of file Vertex.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ identifier_

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + +
Types::vertexId egoa::Vertices::Vertex< PropertyType >::identifier_
+ 		+private
+
+

Unique identifier of the vertex.

+ +

Definition at line 110 of file Vertex.hpp.

+ +
+
+ +

◆ properties_

+ +
+
+
+template<class PropertyType >
+ + + + + +
+ + + + +
TProperties egoa::Vertices::Vertex< PropertyType >::properties_
+ 		+private
+
+

Property of the vertex.
+

+ +

Definition at line 111 of file Vertex.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Graphs/Vertices/Vertex.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_voltage_angle_difference_label-members.html b/classegoa_1_1_voltage_angle_difference_label-members.html new file mode 100644 index 00000000..0a17cc02 --- /dev/null +++ b/classegoa_1_1_voltage_angle_difference_label-members.html @@ -0,0 +1,152 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > Member List
+
+
+ +

This is the complete list of members for egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Index() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Index()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
index_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Label(Types::vertexId vertexId)egoa::Label< ElementType, VertexSetContainer, PointerType >inline
Label(Label const &label)=defaultegoa::Label< ElementType, VertexSetContainer, PointerType >
MinimumCapacity() constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
MinimumCapacity()egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
minimumCapacity_egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >private
operator!=(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator!=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator+egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >friend
operator+egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >friend
operator+=(TElement const &rhs)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
operator<(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator<(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator<<egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >friend
operator<=(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator<=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator==(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator==(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator>(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator>(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
operator>=(VoltageAngleDifferenceLabel const &rhs) constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
egoa::SusceptanceNormLabel::operator>=(SusceptanceNormLabel const &rhs) constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
PreviousLabel() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousLabel()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousLabelId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
PreviousVertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
PreviousVertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
previousVertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
SourceLabel(Types::vertexId vertexId)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inlinestatic
SusceptanceNorm() constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNorm()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
susceptanceNorm_egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >private
SusceptanceNormLabel()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
SusceptanceNormLabel(SusceptanceNormLabel const &label)=defaultegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
TElement typedefegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >
TLabel typedef (defined in egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >
TPointer typedef (defined in egoa::Label< ElementType, VertexSetContainer, PointerType >)egoa::Label< ElementType, VertexSetContainer, PointerType >
TVertexId typedefegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >
TVertexSet typedefegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >
Valid() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Valid()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
valid_egoa::Label< ElementType, VertexSetContainer, PointerType >private
Value() constegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
Vertex() constegoa::Label< ElementType, VertexSetContainer, PointerType >inline
Vertex()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
vertexId_egoa::Label< ElementType, VertexSetContainer, PointerType >private
VertexSet() constegoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
VertexSet()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
vertexSet_egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >private
VoltageAngleDifferenceLabel()egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
VoltageAngleDifferenceLabel(Types::vertexId vertexId)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity, TVertexSet vertexSet)egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
VoltageAngleDifferenceLabel(VoltageAngleDifferenceLabel const &label)=defaultegoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >
~Label()egoa::Label< ElementType, VertexSetContainer, PointerType >inline
~SusceptanceNormLabel()egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >inline
~VoltageAngleDifferenceLabel()egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >inline
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_voltage_angle_difference_label.html b/classegoa_1_1_voltage_angle_difference_label.html new file mode 100644 index 00000000..8d13114f --- /dev/null +++ b/classegoa_1_1_voltage_angle_difference_label.html @@ -0,0 +1,1407 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Static Public Member Functions | +Private Attributes | +Friends | +List of all members
+
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > Class Template Reference
+
+
+ +

Class for Voltage Angle Difference label. + More...

+ +

#include <VoltageAngleDifferenceLabel.hpp>

+
+Inheritance diagram for egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >:
+
+
+ + +egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType > +egoa::Label< ElementType, VertexSetContainer, PointerType > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using TLabel = SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
 
using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
- Public Types inherited from egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
- Public Types inherited from egoa::Label< ElementType, VertexSetContainer, PointerType >
using TVertexId = Types::vertexId
 
using TElement = ElementType
 
using TVertexSet = VertexSetContainer
 
using TPointer = PointerType
 
using TLabel = Label< TElement, TVertexSet, TPointer >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors and Destructor
 VoltageAngleDifferenceLabel ()
 Constructs the voltage angle difference label object.
 
 VoltageAngleDifferenceLabel (Types::vertexId vertexId)
 Constructs the voltage angle difference label object.
 
 VoltageAngleDifferenceLabel (Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity)
 Constructs the voltage angle difference label object.
 
 VoltageAngleDifferenceLabel (Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity, TVertexSet vertexSet)
 Constructs the voltage angle difference label object.
 
 VoltageAngleDifferenceLabel (VoltageAngleDifferenceLabel const &label)=default
 Copy constructor.
 
 ~VoltageAngleDifferenceLabel ()
 Destroys the object.
 
Domination Operators
bool operator< (VoltageAngleDifferenceLabel const &rhs) const
 Strict domination using less than.
 
bool operator<= (VoltageAngleDifferenceLabel const &rhs) const
 Weak domination using less or equal than.
 
bool operator> (VoltageAngleDifferenceLabel const &rhs) const
 Strict domination using greater than.
 
bool operator>= (VoltageAngleDifferenceLabel const &rhs) const
 Weak domination using greater or equal than.
 
Comparison Operators
bool operator== (VoltageAngleDifferenceLabel const &rhs) const
 Equality check.
 
bool operator!= (VoltageAngleDifferenceLabel const &rhs) const
 Inequality check.
 
Getter and Setter
Types::real MinimumCapacity () const
 Getter for the minimum capacity.
 
Types::real & MinimumCapacity ()
 Setter for the minimum capacity.
 
Types::real Value () const
 Voltage angle difference value.
 
- Public Member Functions inherited from egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
 SusceptanceNormLabel ()
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId, Types::real susceptanceNorm)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)
 Constructs the Susceptance Norm label object.
 
 SusceptanceNormLabel (SusceptanceNormLabel const &label)=default
 Copy constructor.
 
 ~SusceptanceNormLabel ()
 Destroys the susceptance norm label object.
 
TVertexSet const & VertexSet () const
 Getter of the set of all visited vertices from the source.
 
TVertexSet & VertexSet ()
 Getter of the set of all visited vertices from the source.
 
Types::real SusceptanceNorm () const
 Getter and setter for the susceptance norm.
 
Types::real & SusceptanceNorm ()
 Getter and setter for the susceptance norm.
 
Types::real Value () const
 Susceptance norm label value.
 
bool operator< (SusceptanceNormLabel const &rhs) const
 Strict domination using less than.
 
bool operator<= (SusceptanceNormLabel const &rhs) const
 Weak domination using less or equal than.
 
bool operator> (SusceptanceNormLabel const &rhs) const
 Strict domination using greater than.
 
bool operator>= (SusceptanceNormLabel const &rhs) const
 Weak domination using greater or equal than.
 
bool operator== (SusceptanceNormLabel const &rhs) const
 Equality check.
 
bool operator!= (SusceptanceNormLabel const &rhs) const
 Inequality check.
 
SusceptanceNormLabel & operator+= (TElement const &rhs)
 In place addition.
 
- Public Member Functions inherited from egoa::Label< ElementType, VertexSetContainer, PointerType >
 Label (Types::vertexId vertexId)
 Constructs the label object.
 
 Label (Label const &label)=default
 Copy constructor.
 
 ~Label ()
 Destroys the label object.
 
Types::labelId Index () const
 Getter for the label identifier.
 
Types::labelId & Index ()
 Setter for the label identifier.
 
bool Valid () const
 Getter for the valid flag.
 
bool & Valid ()
 Setter for the valid flag.
 
Types::vertexId Vertex () const
 Getter for the value of the label.
 
Types::vertexId & Vertex ()
 Setter for the vertex identifier.
 
TPointer PreviousVertex () const
 Getter for the previous vertex.
 
TPointer & PreviousVertex ()
 Setter for the previous vertex.
 
TPointer PreviousLabel () const
 Getter and setter for the previous label.
 
TPointer & PreviousLabel ()
 Setter for the previous label.
 
+ + + + + + + + +

+Static Public Member Functions

static VoltageAngleDifferenceLabel SourceLabel (Types::vertexId vertexId)
 Generate source label.
 
- Static Public Member Functions inherited from egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
static SusceptanceNormLabel SourceLabel (Types::vertexId vertexId)
 Generate source label.
 
+ + + +

+Private Attributes

Types::real minimumCapacity_
 
+ + + + +

+Friends

std::ostream & operator<< (std::ostream &os, VoltageAngleDifferenceLabel const &rhs)
 Output stream.
 
+ + + + + + + + + + + + + + + + +

Concatenation Operators

VoltageAngleDifferenceLabel & operator+= (TElement const &rhs)
 In place addition.
 
bool operator+ (VoltageAngleDifferenceLabel const &lhs, TVertexId const &vertexId)
 Addition operators testing for cycles.
 
std::pair< TVertexSet, bool > operator+ (TVertexId const &vertexId, VoltageAngleDifferenceLabel const &rhs)
 Addition operators testing for cycles.
 
std::pair< VoltageAngleDifferenceLabel, bool > operator+ (TElement const &edge, VoltageAngleDifferenceLabel const &rhs)
 Addition operators testing for cycles.
 
std::pair< VoltageAngleDifferenceLabel, bool > operator+ (VoltageAngleDifferenceLabel const &lhs, TElement const &edge)
 Addition operators testing for cycles.
 
+

Detailed Description

+
template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+class egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >

Class for Voltage Angle Difference label.

+

The voltage angle difference label consists of the susceptance norm and the minimum capacity of a path. The value is defined by

+\[ + \deltavangle(\vertexa,\vertexb) = \bnorm{\fpath{}{\vertexa}{\vertexb}} \cdot \fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}, + \] +

+

where $\bnorm{\fpath{}{\vertexa}{\vertexb}} := \sum_{\edge\in\fpath{}{\vertexa}{\vertexb}}\susceptance(\edge)^{-1}$ is the susceptance norm with $\susceptance(\vertexa,\vertexb)\in\reals$, and $\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }:= \min_{ (\vertexa,\vertexb)\in\pathu}\fcapacity{}{\vertexa}{\vertexb}$ with the thermal limit $\capacity\colon\edges\to\reals$. For more information see Section 3 in the paper The Maximum Transmission Switching Flow Problem.

+
Template Parameters
+ + +
ElementTypeAn edge providing access to the susceptance, e.g., an electrical edge.
+
+
+
See also
Edge::ElectricalEdge representing an ElementType interface.
+
+BucketElement representing an minimum interface requirement for a bucket.
+
+Label representing the base's base class.
+
+SusceptanceNormLabel representing the base class.
+ +

Definition at line 42 of file VoltageAngleDifferenceLabel.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TElement = ElementType
+
+

Some element to cover such as an edge.

+ +

Definition at line 49 of file Label.hpp.

+ +
+
+ +

◆ TLabel

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::TLabel = SusceptanceNormLabel<ElementType, VertexSetContainer, PointerType>
+
+ +

Definition at line 45 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexId = Types::vertexId
+
+

The vertex identifier type used in LabelStruct.

+ +

Definition at line 48 of file Label.hpp.

+ +
+
+ +

◆ TVertexSet

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + +
using egoa::Label< ElementType, VertexSetContainer, PointerType >::TVertexSet = VertexSetContainer
+
+

A hash map of TVertex.

+ +

Definition at line 50 of file Label.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ VoltageAngleDifferenceLabel() [1/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel ()
+ 		+inline
+
+ +

Constructs the voltage angle difference label object.

+

The label and vertex identifier and previous label and vertex identifiers are set to Const::NONE. The valid flag is set to true. Note that the susceptance norm is set to $\bnorm{\fpath{}{\vertexa}{\vertexb}} = 0.0$ and the minimum capacity to infinity representing the initial label $(0,\infty)$.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 67 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ VoltageAngleDifferenceLabel() [2/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel (Types::vertexId vertexId)
+ 		+inline
+
+ +

Constructs the voltage angle difference label object.

+

The label identifier and previous label/vertex identifiers are set to Const::NONE. The valid flag is set to true. Note that the susceptance norm is set to $\bnorm{\fpath{}{\vertexa}{\vertexb}} = 0.0$ and the minimum capacity to infinity representing the initial label $(0,\infty)$.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+ +

Definition at line 82 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ VoltageAngleDifferenceLabel() [3/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel (Types::vertexId vertexId,
Types::real susceptanceNorm,
Types::real minimumCapacity 
)
+ 		+inline
+
+ +

Constructs the voltage angle difference label object.

+

The label identifier and previous label/vertex identifiers are set to Const::NONE. The valid flag is set to true.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
[in]susceptanceNormThe susceptance norm $\bnorm{\fpath{}{\vertexa}{\vertexb}}$.
[in]minimumCapacityThe minimum capacity $\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }$.
+
+
+ +

Definition at line 96 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ VoltageAngleDifferenceLabel() [4/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel (Types::vertexId vertexId,
Types::real susceptanceNorm,
Types::real minimumCapacity,
TVertexSet vertexSet 
)
+ 		+inline
+
+ +

Constructs the voltage angle difference label object.

+

The label identifier and previous label/vertex identifiers are set to Const::NONE. The valid flag is set to true.

+
Parameters
+ + + + + +
[in]vertexIdThe vertex identifier.
[in]susceptanceNormThe susceptance norm $\bnorm{\fpath{}{\vertexa}{\vertexb}}$.
[in]minimumCapacityThe minimum capacity $\fmincapacity{}{ \fpath{}{\vertexa}{\vertexb} }$.
[in]vertexSetThe vertex set of visited vertices.
+
+
+ +

Definition at line 114 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ VoltageAngleDifferenceLabel() [5/5]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & label)
+ 		+default
+
+ +

Copy constructor.

+
Parameters
+ + +
labelThe voltage angle difference label.
+
+
+ +
+
+ +

◆ ~VoltageAngleDifferenceLabel()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::~VoltageAngleDifferenceLabel ()
+ 		+inline
+
+ +

Destroys the object.

+ +

Definition at line 132 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ MinimumCapacity() [1/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real & egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity ()
+ 		+inline
+
+ +

Setter for the minimum capacity.

+
Returns
The minimum capacity $\fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}$.
+ +

Definition at line 396 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::minimumCapacity_.

+ +
+
+ +

◆ MinimumCapacity() [2/2]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity () const
+ 		+inline
+
+ +

Getter for the minimum capacity.

+
Returns
The minimum capacity $\fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}$.
+ +

Definition at line 386 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::minimumCapacity_.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator!= (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Inequality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs != rhs, false otherwise.
+ +

Definition at line 246 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
VoltageAngleDifferenceLabel & egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator+= (TElement const & rhs)
+ 		+inline
+
+ +

In place addition.

+
Parameters
+ + +
rhsThe right hand side representing a TElement.
+
+
+
Returns
The voltage angle difference label with added TElement.
+ +

Definition at line 364 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm(), and egoa::Label< ElementType, VertexSetContainer, PointerType >::Vertex().

+ +
+
+ +

◆ operator<()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator< (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using less than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs < rhs, false otherwise.
+ +

Definition at line 161 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator<=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator<= (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using less or equal than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs <= rhs, false otherwise.
+ +

Definition at line 177 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator== (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Equality check.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs == rhs, false otherwise.
+ +

Definition at line 230 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator>()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator> (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Strict domination using greater than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs > rhs, false otherwise.
+ +

Definition at line 193 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ operator>=()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
bool egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::operator>= (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs) const
+ 		+inline
+
+ +

Weak domination using greater or equal than.

+
Parameters
+ + +
rhsThe right hand side.
+
+
+
Returns
true if lhs >= rhs, false otherwise.
+ +

Definition at line 209 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+ +

◆ SourceLabel()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + +
static VoltageAngleDifferenceLabel egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::SourceLabel (Types::vertexId vertexId)
+ 		+inlinestatic
+
+ +

Generate source label.

+
Parameters
+ + +
[in]vertexIdThe vertex identifier.
+
+
+
Returns
The voltage angle difference source label.
+ +

Definition at line 142 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::VoltageAngleDifferenceLabel().

+ +
+
+ +

◆ Value()

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + +
Types::real egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::Value () const
+ 		+inline
+
+ +

Voltage angle difference value.

+

Represents the total voltage angle difference (also known as delta theta or theta difference) $\bnorm{\fpath{}{\vertexa}{\vertexb}}$ on a path $\fpath{}{\vertexa}{\vertexb}$. It is calculated by

+\[ + \deltavangle(\vertexa,\vertexb) = \bnorm{\fpath{}{\vertexa}{\vertexb}} \cdot \fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}, + \] +

+

where $\vertexa\in\vertices$ is the label's vertex.

+
Returns
The voltage angle difference value $\deltavangle(\vertexa,\vertexb)$.
+ +

Definition at line 416 of file VoltageAngleDifferenceLabel.hpp.

+ +

References egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::MinimumCapacity(), and egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >::SusceptanceNorm().

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ operator+ [1/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< VoltageAngleDifferenceLabel, bool > operator+ (TElement const & edge,
VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
edgeThe edge.
rhsThe susceptance norm label VoltageAngleDifferenceLabel.
+
+
+
Returns
A pair of a VoltageAngleDifferenceLabel and boolean. The boolean is true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 317 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ operator+ [2/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< TVertexSet, bool > operator+ (TVertexId const & vertexId,
VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
vertexIdThe vertex identifier.
rhsThe right hand side representing a VoltageAngleDifferenceLabel.
+
+
+
Returns
A pair of a hash map and boolean. The boolean is true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 292 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ operator+ [3/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::pair< VoltageAngleDifferenceLabel, bool > operator+ (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & lhs,
TElement const & edge 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+
Parameters
+ + + +
lhsThe susceptance norm label VoltageAngleDifferenceLabel.
edgeThe edge.
+
+
+
Returns
A pair of a LabelStruct and boolean. The boolean is true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 347 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ operator+ [4/4]

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator+ (VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & lhs,
TVertexId const & vertexId 
)
+ 		+friend
+
+ +

Addition operators testing for cycles.

+

A cycle is created if and only if the vertex is already in the set of visited vertices vertexSet.

+
Parameters
+ + + +
lhsThe left hand side representing a VoltageAngleDifferenceLabel.
vertexIdThe vertex identifier.
+
+
+
Returns
true if the element could be added without creating a cycle, false otherwise.
+ +

Definition at line 270 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+ +

◆ operator<<

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
std::ostream & operator<< (std::ostream & os,
VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType > const & rhs 
)
+ 		+friend
+
+ +

Output stream.

+
Parameters
+ + + +
osThe output stream such as std::cout.
rhsThe right hand side voltage angle difference label.
+
+
+
Returns
The output stream.
+ +

Definition at line 431 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ minimumCapacity_

+ +
+
+
+template<typename ElementType = Edges::Edge<Edges::ElectricalProperties>, typename VertexSetContainer = std::unordered_set<Types::vertexId>, typename PointerType = Types::vertexId>
+ + + + + +
+ + + + +
Types::real egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >::minimumCapacity_
+ 		+private
+
+

The minimum capacity $\fmincapacity{}{\fpath{}{\vertexa}{\vertexb}}$ on a path $\fpath{}{\vertexa}{\vertexb}$.

+ +

Definition at line 439 of file VoltageAngleDifferenceLabel.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1_voltage_angle_difference_label.png b/classegoa_1_1_voltage_angle_difference_label.png new file mode 100644 index 00000000..73734e32 Binary files /dev/null and b/classegoa_1_1_voltage_angle_difference_label.png differ diff --git a/classegoa_1_1internal_1_1_binary_heap_check.html b/classegoa_1_1internal_1_1_binary_heap_check.html new file mode 100644 index 00000000..7449b956 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_check.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapCheck< Type, inOrder > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapCheck< Type, inOrder > Class Template Reference
+
+
+ +

Class for binary heap check. + More...

+

Detailed Description

+
template<typename Type, bool inOrder>
+class egoa::internal::BinaryHeapCheck< Type, inOrder >

Class for binary heap check.

+

If inOrder is TRUE the heaps are checked for structural equality (meaning that they are identical), otherwise it checks if both heaps have the same elements.

+
if ( BinaryHeapCheck<TElement, true>::IsEqualTo(lhs, rhs) ) {
+
std::cout << "Both heaps are (structurally) identical" << std::endl;
+
} else if ( BinaryHeapCheck<TElement, false>::IsEqualTo(lhs, rhs) ) {
+
std::cout << "Both heaps have the same elements, but differ in the structure" << std::endl;
+
} else {
+
std::cout << "Both heaps are different." << std::endl;
+
}
+
egoa::internal::BinaryHeapCheck
Class for binary heap check.
Definition BinaryHeap.hpp:44
+
Template Parameters
+ + + +
TypeType of the elements contained by the heap.
inOrderTRUE checks if identical (order-wise), FALSE checks for same elements.
+
+
+ +

Definition at line 44 of file BinaryHeap.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4-members.html b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4-members.html new file mode 100644 index 00000000..ab3192c8 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapCheck< Type, false > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapCheck< Type, false >, including all inherited members.

+ + + + +
IsEqualTo(THeap const &lhs, THeap const &rhs)egoa::internal::BinaryHeapCheck< Type, false >inlinestatic
TElement typedef (defined in egoa::internal::BinaryHeapCheck< Type, false >)egoa::internal::BinaryHeapCheck< Type, false >private
THeap typedef (defined in egoa::internal::BinaryHeapCheck< Type, false >)egoa::internal::BinaryHeapCheck< Type, false >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html new file mode 100644 index 00000000..904bafdb --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html @@ -0,0 +1,215 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapCheck< Type, false > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapCheck< Type, false > Class Template Reference
+
+
+ + + + + +

+Static Public Member Functions

static bool IsEqualTo (THeap const &lhs, THeap const &rhs)
 Determines if it has same elements as the other binary heap.
 
+ + + + + +

+Private Types

using TElement = Type
 
using THeap = BinaryHeap< TElement >
 
+

Detailed Description

+
template<typename Type>
+class egoa::internal::BinaryHeapCheck< Type, false >
+

Definition at line 950 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapCheck< Type, false >::TElement = Type
+ 		+private
+
+ +

Definition at line 953 of file BinaryHeap.hpp.

+ +
+
+ +

◆ THeap

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapCheck< Type, false >::THeap = BinaryHeap<TElement>
+ 		+private
+
+ +

Definition at line 954 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ IsEqualTo()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::internal::BinaryHeapCheck< Type, false >::IsEqualTo (THeap const & lhs,
THeap const & rhs 
)
+ 		+inlinestatic
+
+ +

Determines if it has same elements as the other binary heap.

+
Parameters
+ + +
rhsThe right hand side binary heap object.
+
+
+
Returns
TRUE if it has the same elements as rhs, FALSE otherwise.
+ +

Definition at line 964 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Size().

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4-members.html b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4-members.html new file mode 100644 index 00000000..ba328955 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4-members.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapCheck< Type, true > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapCheck< Type, true >, including all inherited members.

+ + + + +
IsEqualTo(THeap const &lhs, THeap const &rhs)egoa::internal::BinaryHeapCheck< Type, true >inlinestatic
TElement typedef (defined in egoa::internal::BinaryHeapCheck< Type, true >)egoa::internal::BinaryHeapCheck< Type, true >private
THeap typedef (defined in egoa::internal::BinaryHeapCheck< Type, true >)egoa::internal::BinaryHeapCheck< Type, true >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html new file mode 100644 index 00000000..0ace18d2 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html @@ -0,0 +1,215 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapCheck< Type, true > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapCheck< Type, true > Class Template Reference
+
+
+ + + + + +

+Static Public Member Functions

static bool IsEqualTo (THeap const &lhs, THeap const &rhs)
 Determines if equal—in sense of order—to the \rhs binary heap.
 
+ + + + + +

+Private Types

using TElement = Type
 
using THeap = BinaryHeap< TElement >
 
+

Detailed Description

+
template<typename Type>
+class egoa::internal::BinaryHeapCheck< Type, true >
+

Definition at line 920 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapCheck< Type, true >::TElement = Type
+ 		+private
+
+ +

Definition at line 923 of file BinaryHeap.hpp.

+ +
+
+ +

◆ THeap

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapCheck< Type, true >::THeap = BinaryHeap<TElement>
+ 		+private
+
+ +

Definition at line 924 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ IsEqualTo()

+ +
+
+
+template<typename Type >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool egoa::internal::BinaryHeapCheck< Type, true >::IsEqualTo (THeap const & lhs,
THeap const & rhs 
)
+ 		+inlinestatic
+
+ +

Determines if equal—in sense of order—to the \rhs binary heap.

+
Parameters
+ + +
rhsThe right hand side binary heap object.
+
+
+
Returns
TRUE if the order of the elements are the same to the rhs, FALSE otherwise.
+ +

Definition at line 934 of file BinaryHeap.hpp.

+ +

References egoa::BinaryHeap< ElementType >::Size().

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation.html new file mode 100644 index 00000000..e251d4e4 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation.html @@ -0,0 +1,105 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, Policy > Class Template Reference
+
+
+ +

The for loops for BinaryHeap. + More...

+

Detailed Description

+
template<typename HeapType, ExecutionPolicy Policy>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType, Policy >

The for loops for BinaryHeap.

+

The usage of templates is faster instead of ordinary function pointers such as std::function ( see https://stackoverflow.com/questions/14677997/stdfunction-vs-template for more information). This is the reason why the following code is not used inline void for_all_<SOME_FUNCTION>(std::function<void(TVertex & vertex)> function) {}

+
Template Parameters
+ + + +
HeapTypeThe type of the heap. If the heap type is const, const references to the elements are passed to the function objects.
PolicyThe execution policy.
+
+
+
See also
BinaryHeap
+ +

Definition at line 62 of file BinaryHeap.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4-members.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..9022b74f --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >, including all inherited members.

+ + + +
for_all_elements(THeap &heap, FUNCTION function)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >inlinestatic
THeap typedef (defined in egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..e1f1c31a --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,195 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable > Class Template Reference
+
+
+ + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (THeap &heap, FUNCTION function)
 Iterate over all elements in the heap.
 
+ + + +

+Private Types

using THeap = HeapType
 
+

Detailed Description

+
template<typename HeapType>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >
+

Definition at line 1058 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ THeap

+ +
+
+
+template<typename HeapType >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >::THeap = HeapType
+ 		+private
+
+ +

Definition at line 1060 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename HeapType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >::for_all_elements (THeap & heap,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Iterate over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a TElement object as input and a boolean as return type. If the boolean is true the loop will be continued, if false this emulates a break.
+
+
+
[](TElement element) -> bool { Do something with the element object }
+
Note
Heap property might be violated in the none const variant
+
Template Parameters
+ + +
FUNCTIONFunction
+
+
+ +

Definition at line 1081 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4-members.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..980e042b --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel >, including all inherited members.

+ + + +
for_all_elements(THeap &heap, FUNCTION function)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >inlinestatic
THeap typedef (defined in egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..1648fa80 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,112 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+List of all members
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel > Class Template Reference
+
+
+
+Inheritance diagram for egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential > + +
+ + + + + + + +

+Additional Inherited Members

- Static Public Member Functions inherited from egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_elements (THeap &heap, FUNCTION function)
 Iterates over all elements in the heap.
 
+

Detailed Description

+
template<typename HeapType>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel >
+

Definition at line 1213 of file BinaryHeap.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..6008ca57 Binary files /dev/null and b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4-members.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4-members.html new file mode 100644 index 00000000..a444ebd2 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >, including all inherited members.

+ + + +
for_all_elements(THeap &heap, FUNCTION function)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >inlinestatic
THeap typedef (defined in egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >)egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..f0f50fa4 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,215 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential > Class Template Reference
+
+
+ +

Sequential loops for BinaryHeap. + More...

+ +

#include <BinaryHeap.hpp>

+
+Inheritance diagram for egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >:
+
+
+ + +egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel > + +
+ + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (THeap &heap, FUNCTION function)
 Iterates over all elements in the heap.
 
+ + + +

+Private Types

using THeap = HeapType
 
+

Detailed Description

+
template<typename HeapType>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >

Sequential loops for BinaryHeap.

+
Template Parameters
+ + +
HeapTypeThe type of the heap.
+
+
+ +

Definition at line 987 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ THeap

+ +
+
+
+template<typename HeapType >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >::THeap = HeapType
+ 		+private
+
+ +

Definition at line 989 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename HeapType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >::for_all_elements (THeap & heap,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Iterates over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a TElement object as input
+
+
+
[](TElement element) { Do something with the element object }
+
Template Parameters
+ + +
FUNCTIONFunction
+
+
+ +

Definition at line 1006 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.png b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..63848356 Binary files /dev/null and b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.png differ diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioa805e6eca88fafba78d00b0f22af97f1.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioa805e6eca88fafba78d00b0f22af97f1.html new file mode 100644 index 00000000..0598a97b --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioa805e6eca88fafba78d00b0f22af97f1.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >, including all inherited members.

+ + + +
for_all_elements(THeap &heap, FUNCTION function)egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >inlinestatic
THeap typedef (defined in egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >)egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioe30a8cc220ec6926e51fb9c4fe12532a.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioe30a8cc220ec6926e51fb9c4fe12532a.html new file mode 100644 index 00000000..2afddfd1 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_executioe30a8cc220ec6926e51fb9c4fe12532a.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >, including all inherited members.

+ + + +
for_all_elements(THeap &heap, FUNCTION function)egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >inlinestatic
THeap typedef (defined in egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >)egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..de03b1f1 --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,195 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable > Class Template Reference
+
+
+ + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (THeap &heap, FUNCTION function)
 Iterate over all elements in the heap.
 
+ + + +

+Private Types

using THeap = HeapType const
 
+

Detailed Description

+
template<typename HeapType>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >
+

Definition at line 1097 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ THeap

+ +
+
+
+template<typename HeapType >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >::THeap = HeapType const
+ 		+private
+
+ +

Definition at line 1099 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename HeapType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >::for_all_elements (THeap & heap,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Iterate over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a TElement object as input and a boolean as return type. If the boolean is true the loop will be continued, if false this emulates a break.
+
+
+
[](TElement element) -> bool { Do something with the element object }
+
Note
Heap property might be violated in the none const variant
+
Template Parameters
+ + +
FUNCTIONFunction
+
+
+ +

Definition at line 1120 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..6709c8ba --- /dev/null +++ b/classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,206 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential > Class Template Reference
+
+
+ +

Sequential loops for const BinaryHeap. + More...

+ +

#include <BinaryHeap.hpp>

+ + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (THeap &heap, FUNCTION function)
 Iterates over all elements in the heap.
 
+ + + +

+Private Types

using THeap = HeapType const
 
+

Detailed Description

+
template<typename HeapType>
+class egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >

Sequential loops for const BinaryHeap.

+
Template Parameters
+ + +
HeapTypeThe type of the heap.
+
+
+ +

Definition at line 1026 of file BinaryHeap.hpp.

+

Member Typedef Documentation

+ +

◆ THeap

+ +
+
+
+template<typename HeapType >
+ + + + + +
+ + + + +
using egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >::THeap = HeapType const
+ 		+private
+
+ +

Definition at line 1028 of file BinaryHeap.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename HeapType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >::for_all_elements (THeap & heap,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Iterates over all elements in the heap.

+
Parameters
+ + +
[in]functionThe function pointer, e.g., lambda function that has a TElement object as input
+
+
+
[](TElement element) { Do something with the element object }
+
Template Parameters
+ + +
FUNCTIONFunction
+
+
+ +

Definition at line 1045 of file BinaryHeap.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_block_cut_tree_builder-members.html b/classegoa_1_1internal_1_1_block_cut_tree_builder-members.html new file mode 100644 index 00000000..2ab78fde --- /dev/null +++ b/classegoa_1_1internal_1_1_block_cut_tree_builder-members.html @@ -0,0 +1,147 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BlockCutTreeBuilder< GraphType > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BlockCutTreeBuilder< GraphType >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AddCutVertexToBlock(TVertexId vertex) (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
AddEdgeToCurrentBlock(TEdgeId edge)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
AddVertexToCurrentBlock(TVertexId vertex)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
bcTree_ (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
BlockCutTreeBuilder(TGraph const &graph)egoa::internal::BlockCutTreeBuilder< GraphType >inline
blockStack_ (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
breakable_for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprivate
Build()egoa::internal::BlockCutTreeBuilder< GraphType >inline
Clear()egoa::Traversal< GraphType, IsDirected >inlineprivate
CurrentBlock() (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
CurrentBlockId() constegoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
DepthFirstSearch(TGraph const &graph, TVertexId source)egoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
entryTime_egoa::DepthFirstSearch< GraphType, IsDirected >private
EntryTimeAt(TVertexId vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
exitTime_egoa::DepthFirstSearch< GraphType, IsDirected >private
ExitTimeAt(TVertexId const vertexId) constegoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
for_all_edges_at(TVertexId const &vertexId, FUNCTION function) constegoa::Traversal< GraphType, IsDirected >inlineprivate
graph_ (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
isArticulationVertex_egoa::ArticulationVertexDetection< GraphType, false >private
IsArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
IsBridgeArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
IsParentArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
IsRoot(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
IsRootArticulationVertexAt(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
nextBlockId_ (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
parent_egoa::Traversal< GraphType, IsDirected >private
ParentOf(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
PopBlock()egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
PostprocessingEdgeWith(TVertexId source, TVertexId target, TEdgeId edgeId) override (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprotectedvirtual
ArticulationVertexDetection< GraphType, false >::PostprocessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) overrideegoa::ArticulationVertexDetection< GraphType, false >inlineprivatevirtual
PostprocessingVertexWith(Types::vertexId vertex) override (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprotectedvirtual
ArticulationVertexDetection< GraphType, false >::PostprocessingVertexWith(TVertexId vertexId) overrideegoa::ArticulationVertexDetection< GraphType, false >inlineprivatevirtual
PreprocessingVertexWith(TVertexId const vertex) overrideegoa::ArticulationVertexDetection< GraphType, false >inlineprivatevirtual
processed_egoa::Traversal< GraphType, IsDirected >private
ProcessedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprivate
ProcessingEdgeWith(TVertexId source, TVertexId target, Types::edgeId edgeId) overrideegoa::ArticulationVertexDetection< GraphType, false >inlineprivatevirtual
PushNextBlock(TTime time)egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
SetVertexProcessedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
SetVertexVisitedAt(TVertexId vertexId)egoa::Traversal< GraphType, IsDirected >inlineprivate
SortBlocks()egoa::internal::BlockCutTreeBuilder< GraphType >inlineprivate
Source() constegoa::Traversal< GraphType, IsDirected >inlineprivate
source_egoa::Traversal< GraphType, IsDirected >private
TDetection typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
TEdgeId typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
Terminate() constegoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
terminate_egoa::DepthFirstSearch< GraphType, IsDirected >private
TGraph typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
Time() constegoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
time_egoa::DepthFirstSearch< GraphType, IsDirected >private
timeOfOldestReachableAncestor_egoa::ArticulationVertexDetection< GraphType, false >private
Traversal(TGraph const &graph, TVertexId source)egoa::Traversal< GraphType, IsDirected >inlineprivate
TreeOutDegree(TVertexId const vertex) constegoa::ArticulationVertexDetection< GraphType, false >inlineprivate
treeOutDegree_egoa::ArticulationVertexDetection< GraphType, false >private
TTime typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
TVertexId typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
TypifyEdge(TVertexId source, TVertexId target)egoa::DepthFirstSearch< GraphType, IsDirected >inlineprivate
VectorStack typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >)egoa::internal::BlockCutTreeBuilder< GraphType >private
visited_egoa::Traversal< GraphType, IsDirected >private
VisitedVertexAt(TVertexId vertexId) constegoa::Traversal< GraphType, IsDirected >inlineprivate
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_block_cut_tree_builder.html b/classegoa_1_1internal_1_1_block_cut_tree_builder.html new file mode 100644 index 00000000..23b0ec44 --- /dev/null +++ b/classegoa_1_1internal_1_1_block_cut_tree_builder.html @@ -0,0 +1,992 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BlockCutTreeBuilder< GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Member Functions | +Private Types | +Private Attributes | +List of all members
+
egoa::internal::BlockCutTreeBuilder< GraphType > Class Template Reference
Block-cut tree related classes and functions
+
+
+ +

A class to build BlockCutTree objects for a graph. + More...

+
+Inheritance diagram for egoa::internal::BlockCutTreeBuilder< GraphType >:
+
+
+ + +egoa::ArticulationVertexDetection< GraphType, false > + +
+ + + + +

+Classes

struct  BlockUnderConstruction
 
+ + + + + + + +

+Public Member Functions

 BlockCutTreeBuilder (TGraph const &graph)
 The constructor.
 
BlockCutTree< TGraph > && Build ()
 Builds the block-cut tree.
 
+ + + + + + +

+Protected Member Functions

Traversal
virtual void PostprocessingEdgeWith (TVertexId source, TVertexId target, TEdgeId edgeId) override
 
virtual void PostprocessingVertexWith (Types::vertexId vertex) override
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TVertexId = typename TGraph::TVertexId
 
using TEdgeId = typename TGraph::TEdgeId
 
using TDetection = ::egoa::ArticulationVertexDetection< TGraph, false >
 
using TTime = typename DepthFirstSearch< GraphType, false >::TTime
 
template<typename T >
using VectorStack = std::stack< T, std::vector< T > >
 
- Private Types inherited from egoa::ArticulationVertexDetection< GraphType, false >
using TGraph = GraphType
 
using TVertexId = typename TGraph::TVertexId
 
- Private Types inherited from egoa::DepthFirstSearch< GraphType, IsDirected >
 
 
 
- Private Types inherited from egoa::Traversal< GraphType, IsDirected >
using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Private Member Functions

Steps of the Algorithm
void SortBlocks ()
 Sort all blocks in bcTree_.blocks_.
 
Adding Blocks
void PushNextBlock (TTime time)
 Initializes the next block.
 
void PopBlock ()
 Pops a block and adds it to the block-cut tree.
 
void AddEdgeToCurrentBlock (TEdgeId edge)
 Adds an edge to the current block.
 
void AddVertexToCurrentBlock (TVertexId vertex)
 Adds a vertex to the current block.
 
void AddCutVertexToBlock (TVertexId vertex)
 
Types::index CurrentBlockId () const
 The identifier of the current block.
 
BlockUnderConstruction & CurrentBlock ()
 
- Private Member Functions inherited from egoa::ArticulationVertexDetection< GraphType, false >
 ArticulationVertexDetection (TGraph const &graph, TVertexId source)
 
bool IsRootArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex is a root articulation vertex .
 
bool IsParentArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex is a parent articulation vertex .
 
std::pair< bool, bool > IsBridgeArticulationVertexAt (TVertexId const vertex) const
 Determines if vertex and thus, its parent is a bridge articulation vertex .
 
bool IsArticulationVertexAt (TVertexId const vertex) const
 Whether the vertex is an articulation vertex.
 
bool IsRoot (TVertexId const vertex) const
 Determines if vertex is a root.
 
TTime & TimeOfOldestReachableAncestor (TVertexId vertex)
 
virtual void PreprocessingVertexWith (TVertexId const vertex) override
 Preprocessing vertex with vertexId.
 
virtual void ProcessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId) override
 Update the oldest reachable ancestor.
 
virtual void PostprocessingEdgeWith (TVertexId source, TVertexId target, Types::edgeId edgeId) override
 Post processing the edge with edgeId.
 
virtual void PostprocessingVertexWith (TVertexId vertexId) override
 Decide which vertices are articulation vertices.
 
Types::count TreeOutDegree (TVertexId const vertex) const
 Accessors for the tree out degree.
 
Types::count & TreeOutDegree (TVertexId const vertex)
 
- Private Member Functions inherited from egoa::DepthFirstSearch< GraphType, IsDirected >
 
 Determine DFS edge type.
 
 Terminate the DFS.
 
 
 { function_description }
 
 Returns the exit time of a vertex.
 
 Constructs a new DFS instance.
 
- Private Member Functions inherited from egoa::Traversal< GraphType, IsDirected >
virtual void Result (std::vector< TVertexId > parent)
 
 Traversal (TGraph const &graph, TVertexId source)
 Constructs a new instance.
 
TVertexId Source () const
 Getter and setter for the source vertex.
 
TVertexId & Source ()
 
TVertexId & ParentOf (TVertexId vertexId)
 Getter and setter for the parent relation.
 
TVertexId ParentOf (TVertexId vertexId) const
 
void Clear ()
 Clear and resize all vectors.
 
bool VertexExists (TVertexId vertexId)
 
bool NumberOfVertices ()
 
void SetVertexVisitedAt (TVertexId vertexId)
 Sets the vertex at vertexId to visited.
 
bool VisitedVertexAt (TVertexId vertexId) const
 Getter and setter to access the visited field.
 
void SetVertexProcessedAt (TVertexId vertexId)
 Sets the vertex at vertexId to processed.
 
bool ProcessedVertexAt (TVertexId vertexId) const
 Getter and setter to access the process field.
 
void breakable_for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges that is breakable.
 
void for_all_edges_at (TVertexId const &vertexId, FUNCTION function) const
 The for loop over all (outgoing) edges.
 
+ + + + + + + + + +

+Private Attributes

TGraph const & graph_
 
egoa::BlockCutTree< TGraph > bcTree_
 
Types::index nextBlockId_ = 0
 
VectorStack< BlockUnderConstruction > blockStack_
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::BlockCutTreeBuilder< GraphType >

A class to build BlockCutTree objects for a graph.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 377 of file BlockCutTree.hpp.

+

Member Typedef Documentation

+ +

◆ TDetection

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::TDetection = ::egoa::ArticulationVertexDetection<TGraph, false>
+ 		+private
+
+ +

Definition at line 383 of file BlockCutTree.hpp.

+ +
+
+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::TEdgeId = typename TGraph::TEdgeId
+ 		+private
+
+ +

Definition at line 382 of file BlockCutTree.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 380 of file BlockCutTree.hpp.

+ +
+
+ +

◆ TTime

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::TTime = typename DepthFirstSearch<GraphType, false>::TTime
+ 		+private
+
+ +

Definition at line 384 of file BlockCutTree.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::TVertexId = typename TGraph::TVertexId
+ 		+private
+
+ +

Definition at line 381 of file BlockCutTree.hpp.

+ +
+
+ +

◆ VectorStack

+ +
+
+
+template<typename GraphType >
+
+template<typename T >
+ + + + + +
+ + + + +
using egoa::internal::BlockCutTreeBuilder< GraphType >::VectorStack = std::stack<T, std::vector<T> >
+ 		+private
+
+ +

Definition at line 387 of file BlockCutTree.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ BlockCutTreeBuilder()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
egoa::internal::BlockCutTreeBuilder< GraphType >::BlockCutTreeBuilder (TGraph const & graph)
+ 		+inline
+
+ +

The constructor.

+
Parameters
+ + +
graphThe graph for which a block-cut tree shall be built.
+
+
+ +

Definition at line 396 of file BlockCutTree.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddCutVertexToBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::AddCutVertexToBlock (TVertexId vertex)
+ 		+inlineprivate
+
+ +

Definition at line 541 of file BlockCutTree.hpp.

+ +
+
+ +

◆ AddEdgeToCurrentBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::AddEdgeToCurrentBlock (TEdgeId edge)
+ 		+inlineprivate
+
+ +

Adds an edge to the current block.

+
Parameters
+ + +
[in]edgeThe identifier of the edge to add.
+
+
+ +

Definition at line 526 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blockOfEdge_, and egoa::internal::BlockCutTreeBuilder< GraphType >::CurrentBlockId().

+ +
+
+ +

◆ AddVertexToCurrentBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::AddVertexToCurrentBlock (TVertexId vertex)
+ 		+inlineprivate
+
+ +

Adds a vertex to the current block.

+
Parameters
+ + +
[in]vertexThe identifier of the vertex to add.
+
+
+ +

Definition at line 536 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocksOfVertex_, and egoa::internal::BlockCutTreeBuilder< GraphType >::CurrentBlockId().

+ +
+
+ +

◆ Build()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
BlockCutTree< TGraph > && egoa::internal::BlockCutTreeBuilder< GraphType >::Build ()
+ 		+inline
+
+ +

Builds the block-cut tree.

+
Returns
The BlockCutTree-object.
+ +

Definition at line 407 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocks_, egoa::BlockCutTree< GraphType >::cutVertices_, and egoa::internal::BlockCutTreeBuilder< GraphType >::SortBlocks().

+ +
+
+ +

◆ CurrentBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
BlockUnderConstruction & egoa::internal::BlockCutTreeBuilder< GraphType >::CurrentBlock ()
+ 		+inlineprivate
+
+ +

Definition at line 558 of file BlockCutTree.hpp.

+ +
+
+ +

◆ CurrentBlockId()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
Types::index egoa::internal::BlockCutTreeBuilder< GraphType >::CurrentBlockId () const
+ 		+inlineprivate
+
+ +

The identifier of the current block.

+
Returns
The identifier of the current block.
+ +

Definition at line 553 of file BlockCutTree.hpp.

+ +
+
+ +

◆ PopBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::PopBlock ()
+ 		+inlineprivate
+
+ +

Pops a block and adds it to the block-cut tree.

+ +

Definition at line 516 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocks_.

+ +
+
+ +

◆ PostprocessingEdgeWith()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void egoa::internal::BlockCutTreeBuilder< GraphType >::PostprocessingEdgeWith (TVertexId source,
TVertexId target,
TEdgeId edgeId 
)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Definition at line 439 of file BlockCutTree.hpp.

+ +
+
+ +

◆ PostprocessingVertexWith()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
virtual void egoa::internal::BlockCutTreeBuilder< GraphType >::PostprocessingVertexWith (Types::vertexId vertex)
+ 		+inlineoverrideprotectedvirtual
+
+ +

Definition at line 493 of file BlockCutTree.hpp.

+ +
+
+ +

◆ PushNextBlock()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::PushNextBlock (TTime time)
+ 		+inlineprivate
+
+ +

Initializes the next block.

+ +

Definition at line 509 of file BlockCutTree.hpp.

+ +
+
+ +

◆ SortBlocks()

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + + + + +
void egoa::internal::BlockCutTreeBuilder< GraphType >::SortBlocks ()
+ 		+inlineprivate
+
+ +

Sort all blocks in bcTree_.blocks_.

+ +

Definition at line 426 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::blocks_.

+ +
+
+

Member Data Documentation

+ +

◆ bcTree_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
egoa::BlockCutTree<TGraph> egoa::internal::BlockCutTreeBuilder< GraphType >::bcTree_
+ 		+private
+
+ +

Definition at line 588 of file BlockCutTree.hpp.

+ +
+
+ +

◆ blockStack_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
VectorStack<BlockUnderConstruction> egoa::internal::BlockCutTreeBuilder< GraphType >::blockStack_
+ 		+private
+
+ +

Definition at line 590 of file BlockCutTree.hpp.

+ +
+
+ +

◆ graph_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
TGraph const& egoa::internal::BlockCutTreeBuilder< GraphType >::graph_
+ 		+private
+
+ +

Definition at line 587 of file BlockCutTree.hpp.

+ +
+
+ +

◆ nextBlockId_

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
Types::index egoa::internal::BlockCutTreeBuilder< GraphType >::nextBlockId_ = 0
+ 		+private
+
+ +

Definition at line 589 of file BlockCutTree.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_block_cut_tree_builder.png b/classegoa_1_1internal_1_1_block_cut_tree_builder.png new file mode 100644 index 00000000..0ff36b35 Binary files /dev/null and b/classegoa_1_1internal_1_1_block_cut_tree_builder.png differ diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation.html new file mode 100644 index 00000000..b0aaa978 --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BucketLoopDifferentiation< BucketType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BucketLoopDifferentiation< BucketType, Policy > Class Template Reference
+
+
+ +

Class for bucket loop differentiation. + More...

+

Detailed Description

+
template<typename BucketType, ExecutionPolicy Policy>
+class egoa::internal::BucketLoopDifferentiation< BucketType, Policy >

Class for bucket loop differentiation.

+
Template Parameters
+ + + +
BucketTypeType of the bucket.
PolicyThe execution policy.
+
+
+ +

Definition at line 33 of file Bucket.hpp.

+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Bucket.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4-members.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..5440921a --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >, including all inherited members.

+ + + + + + +
for_all_elements(BucketType &bucket, FUNCTION function) (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >inlinestatic
for_all_optima(BucketType &bucket, FUNCTION function) (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >inlinestatic
for_all_processed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >inlinestatic
for_all_unprocessed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >inlinestatic
TElement typedef (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..80dbbed4 --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,351 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (BucketType &bucket, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_processed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all processed elements in the bucket.
 
template<typename FUNCTION >
static void for_all_unprocessed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all unprocessed elements in the bucket.
 
template<typename FUNCTION >
static Types::real for_all_optima (BucketType &bucket, FUNCTION function)
 
+ + + +

+Private Types

using TElement = typename BucketType::TElement
 
+

Detailed Description

+
template<typename BucketType>
+class egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >
+

Definition at line 935 of file Bucket.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename BucketType >
+ + + + + +
+ + + + +
using egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::TElement = typename BucketType::TElement
+ 		+private
+
+ +

Definition at line 936 of file Bucket.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 941 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_optima()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::real egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_optima (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1014 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_processed_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_processed_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all processed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function that return a boolean. If the boolean is true the loop will be continued, if false this emulates a break.
+
+
+
[]( TElement & element ) -> bool
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 971 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_unprocessed_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_unprocessed_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all unprocessed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function that return a boolean. If the boolean is true the loop will be continued, if false this emulates a break.
+
+
+
[]( TElement & element ) -> bool
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 1000 of file Bucket.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Bucket.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4-members.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..d9262723 --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel >, including all inherited members.

+ + + + + + + +
for_all_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_optima(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_processed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_unprocessed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
TBucket typedef (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >private
TElement typedef (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..8b5f223b --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,134 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+List of all members
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel > Class Template Reference
+
+
+ +

If OpenMP is not available, fall back to sequential execution of the loops. + More...

+
+Inheritance diagram for egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential > + +
+ + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Member Functions inherited from egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_elements (BucketType &bucket, FUNCTION function)
 The for loop over all elements in the bucket.
 
template<typename FUNCTION >
static void for_all_processed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all processed elements in the bucket.
 
template<typename FUNCTION >
static void for_all_unprocessed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all unprocessed elements in the bucket.
 
template<typename FUNCTION >
static Types::real for_all_optima (BucketType &bucket, FUNCTION function)
 The for loop over all elements with optimal value.
 
+

Detailed Description

+
template<typename BucketType>
+class egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel >

If OpenMP is not available, fall back to sequential execution of the loops.

+
Template Parameters
+ + +
BucketTypeThe type of the bucket.
+
+
+ +

Definition at line 1168 of file Bucket.hpp.

+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Bucket.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..73563f97 Binary files /dev/null and b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4-members.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4-members.html new file mode 100644 index 00000000..569f1a84 --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4-members.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >, including all inherited members.

+ + + + + + + +
for_all_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_optima(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_processed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
for_all_unprocessed_elements(BucketType &bucket, FUNCTION function)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >inlinestatic
TBucket typedef (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >private
TElement typedef (defined in egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >)egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..006ec213 --- /dev/null +++ b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,429 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential > Class Template Reference
+
+
+
+Inheritance diagram for egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >:
+
+
+ + +egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel > + +
+ + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_elements (BucketType &bucket, FUNCTION function)
 The for loop over all elements in the bucket.
 
template<typename FUNCTION >
static void for_all_processed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all processed elements in the bucket.
 
template<typename FUNCTION >
static void for_all_unprocessed_elements (BucketType &bucket, FUNCTION function)
 The for loop over all unprocessed elements in the bucket.
 
template<typename FUNCTION >
static Types::real for_all_optima (BucketType &bucket, FUNCTION function)
 The for loop over all elements with optimal value.
 
+ + + + + +

+Private Types

using TBucket = BucketType
 
using TElement = typename TBucket::TElement
 
+

Detailed Description

+
template<typename BucketType>
+class egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >
+

Definition at line 814 of file Bucket.hpp.

+

Member Typedef Documentation

+ +

◆ TBucket

+ +
+
+
+template<typename BucketType >
+ + + + + +
+ + + + +
using egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::TBucket = BucketType
+ 		+private
+
+ +

Definition at line 817 of file Bucket.hpp.

+ +
+
+ +

◆ TElement

+ +
+
+
+template<typename BucketType >
+ + + + + +
+ + + + +
using egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::TElement = typename TBucket::TElement
+ 		+private
+
+ +

Definition at line 818 of file Bucket.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all elements in the bucket.

+

Loop over all processed and unprocessed elements.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 838 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_optima()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::real egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_optima (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all elements with optimal value.

+

Loop over all unprocessed elements having an optimal value.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + + +
Policytrue if the loop is run in parallel using OpenMP, false otherwise.
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 918 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_processed_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_processed_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all processed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function.
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 861 of file Bucket.hpp.

+ +
+
+ +

◆ for_all_unprocessed_elements()

+ +
+
+
+template<typename BucketType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_unprocessed_elements (BucketType & bucket,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all unprocessed elements in the bucket.

+
Parameters
+ + +
[in]functionThe function, e.g., lambda function
+
+
+
[]( TElement & element )
+
{
+
// Do something with the element object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function pointer.
+
+
+ +

Definition at line 886 of file Bucket.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • include/DataStructures/Container/Queues/Bucket.hpp
    • +
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.png b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..eebd36de Binary files /dev/null and b/classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.png differ diff --git a/classegoa_1_1internal_1_1_domination_differentiation.html b/classegoa_1_1internal_1_1_domination_differentiation.html new file mode 100644 index 00000000..9a04e5b7 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation.html @@ -0,0 +1,116 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DominationDifferentiation< ElementType, Domination > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DominationDifferentiation< ElementType, Domination > Class Template Reference
+
+
+ +

Class for domination differentiation. + More...

+

Detailed Description

+
template<typename ElementType, DominationCriterion Domination>
+class egoa::internal::DominationDifferentiation< ElementType, Domination >

Class for domination differentiation.

+
int lhs = 3;
+
int rhs = 3;
+
if ( DominationDifferentiation<int, DominationCriterion::weak>::Dominates(lhs, rhs, [](TElement a, TElement b) { return a < b; }) ) {
+
std::cout << "The variable lhs dominates rhs in a weak sense." << std::endl;
+
} else {
+
std::cout << "The variable lhs does not dominate rhs in any sense." << std::endl;
+
}
+
if ( DominationDifferentiation<int, DominationCriterion::strict>::Dominates(lhs, rhs, [](TElement a, TElement b) { return a < b; }) ) {
+
std::cout << "The variable lhs dominates rhs in a strong sense." << std::endl;
+
} else {
+
std::cout << "The variable lhs might dominate rhs in a weak sense." << std::endl;
+
}
+
egoa::internal::DominationDifferentiation
Class for domination differentiation.
Definition DominationCriterion.hpp:54
+
Template Parameters
+ + + +
ElementTypeType of the elements contained in the bucket.
DominationClassification of domination, e.g., weak, strict, or none.
+
+
+ +

Definition at line 54 of file DominationCriterion.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4-members.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4-members.html new file mode 100644 index 00000000..d99710d9 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none > Member List
+
+
+ +

This is the complete list of members for egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >, including all inherited members.

+ + + +
Dominates(TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator) (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >inlinestatic
TElement typedef (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4.html new file mode 100644 index 00000000..84fd31b8 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4.html @@ -0,0 +1,181 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none > Class Template Reference
+
+
+ + + + +

+Static Public Member Functions

static bool Dominates (TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator)
 
+ + + +

+Private Types

using TElement = ElementType
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >
+

Definition at line 88 of file DominationCriterion.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
using egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >::TElement = ElementType
+ 		+private
+
+ +

Definition at line 90 of file DominationCriterion.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Dominates()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >::Dominates (TElement const & lhs,
TElement const & rhs,
std::function< bool(TElement, TElement)> const & comparator 
)
+ 		+inlinestatic
+
+ +

Definition at line 93 of file DominationCriterion.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4-members.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4-members.html new file mode 100644 index 00000000..726696a7 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict > Member List
+
+
+ +

This is the complete list of members for egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >, including all inherited members.

+ + + +
Dominates(TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator) (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >inlinestatic
TElement typedef (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4.html new file mode 100644 index 00000000..dfe2f440 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4.html @@ -0,0 +1,181 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict > Class Template Reference
+
+
+ + + + +

+Static Public Member Functions

static bool Dominates (TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator)
 
+ + + +

+Private Types

using TElement = ElementType
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >
+

Definition at line 73 of file DominationCriterion.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
using egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >::TElement = ElementType
+ 		+private
+
+ +

Definition at line 75 of file DominationCriterion.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Dominates()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >::Dominates (TElement const & lhs,
TElement const & rhs,
std::function< bool(TElement, TElement)> const & comparator 
)
+ 		+inlinestatic
+
+ +

Definition at line 78 of file DominationCriterion.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4-members.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4-members.html new file mode 100644 index 00000000..28102ae6 --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4-members.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak > Member List
+
+
+ +

This is the complete list of members for egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >, including all inherited members.

+ + + +
Dominates(TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator) (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >inlinestatic
TElement typedef (defined in egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >)egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4.html b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4.html new file mode 100644 index 00000000..fcfde7ac --- /dev/null +++ b/classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4.html @@ -0,0 +1,181 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak > Class Template Reference
+
+
+ + + + +

+Static Public Member Functions

static bool Dominates (TElement const &lhs, TElement const &rhs, std::function< bool(TElement, TElement)> const &comparator)
 
+ + + +

+Private Types

using TElement = ElementType
 
+

Detailed Description

+
template<typename ElementType>
+class egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >
+

Definition at line 58 of file DominationCriterion.hpp.

+

Member Typedef Documentation

+ +

◆ TElement

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + +
using egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >::TElement = ElementType
+ 		+private
+
+ +

Definition at line 60 of file DominationCriterion.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Dominates()

+ +
+
+
+template<typename ElementType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static bool egoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >::Dominates (TElement const & lhs,
TElement const & rhs,
std::function< bool(TElement, TElement)> const & comparator 
)
+ 		+inlinestatic
+
+ +

Definition at line 63 of file DominationCriterion.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html new file mode 100644 index 00000000..ba5844a9 --- /dev/null +++ b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html @@ -0,0 +1,117 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DynamicGraphLoopDifferentiation< GraphType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DynamicGraphLoopDifferentiation< GraphType, Policy > Class Template Reference
+
+
+ +

The for loops for DynamicGraph. + More...

+ +

#include <DynamicGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::DynamicGraphLoopDifferentiation< GraphType, Policy >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, Policy > + +
+

Detailed Description

+
template<typename GraphType, ExecutionPolicy Policy>
+class egoa::internal::DynamicGraphLoopDifferentiation< GraphType, Policy >

The for loops for DynamicGraph.

+
Template Parameters
+ + + +
GraphTypeThe type of the graph, e.g., DynamicGraph<VertexType, EdgeType>. If the graph type is const, const references to the vertices and edges are passed to the function objects.
PolicyThe execution policy.
+
+
+
See also
DynamicGraph
+
+ExecutionPolicy
+ +

Definition at line 31 of file DynamicGraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.png b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.png new file mode 100644 index 00000000..963a7682 Binary files /dev/null and b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.png differ diff --git a/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..2873f342 --- /dev/null +++ b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,114 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference
+
+
+ +

If OpenMP is not available, the parallel loops are run sequentially. + More...

+ +

#include <DynamicGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > +egoa::internal::GraphLoopDifferentiation< GraphType, Policy > + +
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >

If OpenMP is not available, the parallel loops are run sequentially.

+
Template Parameters
+ + +
GraphTypeThe type of the graph
+
+
+ +

Definition at line 267 of file DynamicGraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..f6862ebc Binary files /dev/null and b/classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_generation_strategy_differentiation.html b/classegoa_1_1internal_1_1_generation_strategy_differentiation.html new file mode 100644 index 00000000..4fd668d9 --- /dev/null +++ b/classegoa_1_1internal_1_1_generation_strategy_differentiation.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GenerationStrategyDifferentiation< NetworkType, GenerationType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GenerationStrategyDifferentiation< NetworkType, GenerationType > Class Template Reference
+
+
+ +

This base class to differentiate between different generation strategy. + More...

+

Detailed Description

+
template<typename NetworkType, Vertices::GenerationStrategyDifferentiationType GenerationType>
+class egoa::internal::GenerationStrategyDifferentiation< NetworkType, GenerationType >

This base class to differentiate between different generation strategy.

+

Implementations for the loops are defined in the template specializations for the different generation strategies.

+
Template Parameters
+ + + +
NetworkTypeThe type of the network.
GenerationTypeThe generation strategy.
+
+
+ +

Definition at line 26 of file GenerationStrategy.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html b/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html new file mode 100644 index 00000000..0ad20f69 --- /dev/null +++ b/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html @@ -0,0 +1,295 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot > Class Template Reference
+
+
+ +

This base class to differentiate between different generation strategy. + More...

+ +

#include <GenerationStrategy.hpp>

+ + + + + + + + + + +

+Static Public Member Functions

Total vertex real power generation per snapshot
static Types::real TotalRealPowerGenerationAt (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)
 Total real power generation $\realpowergeneration(\vertex)$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.
 
Total vertex reactive power generation per snapshot.
static Types::real TotalReactivePowerGenerationAt (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)
 The total reactive power generation $\reactivepowergeneration$ of all generator snapshots for one timestamp at vertex $\vertex\in\vertices$ with identifier vertexId.
 
+ + + + + +

+Private Types

using TNetwork = NetworkType
 
using TGeneratorProperties = typename TNetwork::TGeneratorProperties
 
+

Detailed Description

+
template<typename NetworkType>
+class egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >

This base class to differentiate between different generation strategy.

+

This is the Vertices::GenerationStrategyDifferentiationType::totalVertexRealPowerGenerationPerSnapshot specialization.

+
See also
Vertices::GenerationStrategyDifferentiationType::totalVertexRealPowerGenerationPerSnapshot
+
Template Parameters
+ + +
NetworkTypeThe type of the network.
+
+
+ +

Definition at line 40 of file GenerationStrategy.hpp.

+

Member Typedef Documentation

+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename NetworkType >
+ + + + + +
+ + + + +
using egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TGeneratorProperties = typename TNetwork::TGeneratorProperties
+ 		+private
+
+ +

Definition at line 43 of file GenerationStrategy.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename NetworkType >
+ + + + + +
+ + + + +
using egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TNetwork = NetworkType
+ 		+private
+
+ +

Definition at line 42 of file GenerationStrategy.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ TotalReactivePowerGenerationAt()

+ +
+
+
+template<typename NetworkType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Types::real egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalReactivePowerGenerationAt (TNetwork const & network,
Types::vertexId vertexId,
Types::index timestampPosition = 0 
)
+ 		+inlinestatic
+
+ +

The total reactive power generation $\reactivepowergeneration$ of all generator snapshots for one timestamp at vertex $\vertex\in\vertices$ with identifier vertexId.

+
Parameters
+ + +
[in]vertexIdThe vertex $\vertex\in\vertices$ with identifier vertexId.
+
+
+
Note
The total reactive power generation $\reactivepowergeneration$ only includes the snapshots of active generators. In addition, if the vertex $\vertex\in\vertices$ has no generators the return value is 0.
+
Returns
The total reactive power generation $\reactivepowergeneration$ of all generator snapshots at a vertex $\vertex\in\vertices$ with identifier vertexId.
+ +

Definition at line 109 of file GenerationStrategy.hpp.

+ +
+
+ +

◆ TotalRealPowerGenerationAt()

+ +
+
+
+template<typename NetworkType >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Types::real egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalRealPowerGenerationAt (TNetwork const & network,
Types::vertexId vertexId,
Types::index timestampPosition = 0 
)
+ 		+inlinestatic
+
+ +

Total real power generation $\realpowergeneration(\vertex)$ at a vertex $\vertex\in\vertices$ with vertex identifier vertexId.

+
Parameters
+ + + + +
networkThe network $\network$.
[in]vertexIdThe vertex identifier.
[in]timestampPositionThe timestamp position.
+
+
+
Returns
A real power generation at a vertex $\vertex\in\vertices$.
+ +

Definition at line 63 of file GenerationStrategy.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1f158c708e15137ee2e802c6cfde13063.html b/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1f158c708e15137ee2e802c6cfde13063.html new file mode 100644 index 00000000..34685445 --- /dev/null +++ b/classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1f158c708e15137ee2e802c6cfde13063.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >, including all inherited members.

+ + + + + +
TGeneratorProperties typedef (defined in egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >)egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >private
TNetwork typedef (defined in egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >)egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >private
TotalReactivePowerGenerationAt(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >inlinestatic
TotalRealPowerGenerationAt(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition=0)egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >inlinestatic
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation.html b/classegoa_1_1internal_1_1_graph_loop_differentiation.html new file mode 100644 index 00000000..5731bb43 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation.html @@ -0,0 +1,118 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphLoopDifferentiation< GraphType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphLoopDifferentiation< GraphType, Policy > Class Template Reference
+
+
+ +

The base class for for loops for graphs. + More...

+ +

#include <GraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::GraphLoopDifferentiation< GraphType, Policy >:
+
+
+ + +egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > +egoa::internal::DynamicGraphLoopDifferentiation< GraphType, Policy > +egoa::internal::StaticGraphLoopDifferentiation< GraphType, Policy > +egoa::internal::DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > + +
+

Detailed Description

+
template<typename GraphType, ExecutionPolicy Policy>
+class egoa::internal::GraphLoopDifferentiation< GraphType, Policy >

The base class for for loops for graphs.

+

Implementations for the loops are defined in the template specializations for the different execution policies.

+
Template Parameters
+ + + +
GraphTypeThe type of the graph.
PolicyThe execution policy.
+
+
+ +

Definition at line 30 of file GraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation.png b/classegoa_1_1internal_1_1_graph_loop_differentiation.png new file mode 100644 index 00000000..84afe7e8 Binary files /dev/null and b/classegoa_1_1internal_1_1_graph_loop_differentiation.png differ diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..0962e19d --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
TEdgeId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TGraph typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TVertex typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TVertexId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..1c2b7b43 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,1100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Class Template Reference
+
+
+ +

Breakable for loops for graphs. + More...

+ +

#include <GraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >:
+
+
+ + +egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

Breakable Vertex Loops
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The breakable for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
Breakable Edge Loops
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all identifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The breakable for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
Breakable Neighborhood Loops
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+ + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TVertex = typename TGraph::TVertex
 
using TVertexId = typename TGraph::TVertexId
 
using TEdgeId = typename TGraph::TEdgeId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >

Breakable for loops for graphs.

+

The loops are aborted if the function returns false.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 423 of file GraphIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TEdgeId = typename TGraph::TEdgeId
+ 		+private
+
+ +

Definition at line 428 of file GraphIterators.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 425 of file GraphIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 426 of file GraphIterators.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TVertexId = typename TGraph::TVertexId
+ 		+private
+
+ +

Definition at line 427 of file GraphIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all identifiers of edges in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
[]( Types::edgeId edgeId ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge identifier.
+
return whetherToContinue;
+
}
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all vertex identifiers in the graph .
Definition GraphIterators.hpp:457
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 562 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edge_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TGraph::TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 627 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all edges $\edges$ in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 595 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all edges at a vertex $\vertex\in\vertices$.

+

This is a loop over incoming and outgoing edges. The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all edges at $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 666 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all edges at a vertex $\vertex\in\vertices$.

+

This is a loop over incoming and outgoing edges. The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all edges at $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 697 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all vertex identifiers in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type Types::vertexId e.g.,
[]( Types::vertexId vertexId ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the vertex identifier.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 457 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TGraph::TVertex, e.g.,
[]( Types::vertexId vertexId, TVertex vertex ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the vertex identifier and object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 524 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertices()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertices (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all vertex objects $\vertices$ in the graph $\graph$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type TGraph::TVertex, e.g.,
[]( TVertex & vertex ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the vertex identifier.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 490 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_in_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all incoming edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 736 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_in_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all incoming edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 766 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_out_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all outgoing edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 800 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_out_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.

+

The loop is aborted if the function returns false.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all outgoing edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 830 of file GraphIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png new file mode 100644 index 00000000..0918940d Binary files /dev/null and b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png differ diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..697eb93f --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
TEdgeId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TGraph typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertexId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..1751af10 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,168 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+List of all members
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference
+
+
+ +

If OpenMP is not available, the loops are run sequentially. + More...

+ +

#include <GraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Member Functions inherited from egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >

If OpenMP is not available, the loops are run sequentially.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 1073 of file GraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..b7d4c757 Binary files /dev/null and b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html new file mode 100644 index 00000000..e01e80e9 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
TEdgeId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TGraph typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertexId typedef (defined in egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..b1bbb76c --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,1067 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Class Template Reference
+
+
+ +

The base class for sequential for loops for graphs. + More...

+ +

#include <GraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > +egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > +egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

Sequential Vertex Loops
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
Sequential Edge Loops
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
Sequential Neighborhood Loops
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+ + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TVertex = typename TGraph::TVertex
 
using TVertexId = typename TGraph::TVertexId
 
using TEdgeId = typename TGraph::TEdgeId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >

The base class for sequential for loops for graphs.

+
Template Parameters
+ + +
GraphTypeThe type of the graph
+
+
+ +

Definition at line 38 of file GraphIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TEdgeId = typename TGraph::TEdgeId
+ 		+private
+
+ +

Definition at line 43 of file GraphIterators.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 40 of file GraphIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 41 of file GraphIterators.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TVertexId = typename TGraph::TVertexId
+ 		+private
+
+ +

Definition at line 42 of file GraphIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all indentifiers of edges in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
[]( Types::edgeId edgeId )
+
{
+
// Do something with the edge identifier.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 161 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edge_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TGraph::TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge & edge )
+
{
+
// Do something with the edge.
+
}
+
egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The for loop over all vertex identifiers in the graph .
Definition GraphIterators.hpp:69
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 219 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all edges $\edges$ in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 190 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all edges at a vertex $\vertex\in\vertices$.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all edges at $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 254 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all edges at a vertex $\vertex\in\vertices$.

+

This is a loop over incoming and outgoing edges.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all edges at $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 282 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all vertex identifiers in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type TGraph::TVertexId, e.g.,
[]( Types::vertexId vertexId )
+
{
+
// Do something with the vertex identifier.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 69 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TGraph::TVertex, e.g.,
[]( Types::vertexId vertexId, TVertex & vertex )
+
{
+
// Do something with the vertex identifier and object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 127 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertices()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertices (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all vertex objects $\vertices$ in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type TGraph::TVertex, e.g.,
[]( TVertex & vertex )
+
{
+
// Do something with the vertex object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 98 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_in_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all incoming edges of a vertex $\vertex\in\vertices$.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all incoming edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 317 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_in_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all incoming edges of a vertex $\vertex\in\vertices$.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all incoming edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 345 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_out_edges_at() [1/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at (TGraph & graph,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexThe vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all outgoing edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 376 of file GraphIterators.hpp.

+ +
+
+ +

◆ for_out_edges_at() [2/2]

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at (TGraph & graph,
TVertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.

+
Parameters
+ + + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]vertexIdThe identifier of the vertex $\vertex\in\vertices$.
[in]functionThe function object that is called for all outgoing edges of $\vertex$. It must accept one argument of type TGraph::TEdge, e.g.,
[]( TEdge & edge )
+
{
+
// Do something with the edge object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 404 of file GraphIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..434b5892 Binary files /dev/null and b/classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png differ diff --git a/classegoa_1_1internal_1_1_graph_type_loop_differentiation.html b/classegoa_1_1internal_1_1_graph_type_loop_differentiation.html new file mode 100644 index 00000000..1d32ae67 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_type_loop_differentiation.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphTypeLoopDifferentiation< GraphType, IsDirected > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphTypeLoopDifferentiation< GraphType, IsDirected > Class Template Reference
+
+
+

Detailed Description

+
template<typename GraphType, bool IsDirected>
+class egoa::internal::GraphTypeLoopDifferentiation< GraphType, IsDirected >
+

Definition at line 22 of file Traversal.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4-members.html b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4-members.html new file mode 100644 index 00000000..0b296e83 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4-members.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphTypeLoopDifferentiation< GraphType, false > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >, including all inherited members.

+ + + + + +
breakable_for_all_edges_at(TGraph const &graph, TVertexId const &vertex, FUNCTION function) (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId const &vertex, FUNCTION function) (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >inlinestatic
TGraph typedef (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >private
TVertexId typedef (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4.html b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4.html new file mode 100644 index 00000000..68523cb9 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4.html @@ -0,0 +1,263 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphTypeLoopDifferentiation< GraphType, false > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::GraphTypeLoopDifferentiation< GraphType, false > Class Template Reference
+
+
+ + + + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void breakable_for_all_edges_at (TGraph const &graph, TVertexId const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId const &vertex, FUNCTION function)
 
+ + + + + +

+Private Types

using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >
+

Definition at line 312 of file Traversal.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 314 of file Traversal.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >::TVertexId = typename GraphType::TVertexId
+ 		+private
+
+ +

Definition at line 315 of file Traversal.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ breakable_for_all_edges_at()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >::breakable_for_all_edges_at (TGraph const & graph,
TVertexId const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 320 of file Traversal.hpp.

+ +
+
+ +

◆ for_all_edges_at()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphTypeLoopDifferentiation< GraphType, false >::for_all_edges_at (TGraph & graph,
TVertexId const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 329 of file Traversal.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4-members.html b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4-members.html new file mode 100644 index 00000000..17526556 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4-members.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::GraphTypeLoopDifferentiation< GraphType, true > Member List
+
+
+ +

This is the complete list of members for egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >, including all inherited members.

+ + + + + +
breakable_for_all_edges_at(TGraph const &graph, TVertexId const &vertex, FUNCTION function) (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >inlinestatic
for_all_edges_at(TGraph const &graph, TVertexId const &vertex, FUNCTION function) (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >inlinestatic
TGraph typedef (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >private
TVertexId typedef (defined in egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >)egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4.html b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4.html new file mode 100644 index 00000000..0e12ee76 --- /dev/null +++ b/classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4.html @@ -0,0 +1,263 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::GraphTypeLoopDifferentiation< GraphType, true > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::GraphTypeLoopDifferentiation< GraphType, true > Class Template Reference
+
+
+ + + + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void breakable_for_all_edges_at (TGraph const &graph, TVertexId const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph const &graph, TVertexId const &vertex, FUNCTION function)
 
+ + + + + +

+Private Types

using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >
+

Definition at line 284 of file Traversal.hpp.

+

Member Typedef Documentation

+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 286 of file Traversal.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >::TVertexId = typename GraphType::TVertexId
+ 		+private
+
+ +

Definition at line 287 of file Traversal.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ breakable_for_all_edges_at()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >::breakable_for_all_edges_at (TGraph const & graph,
TVertexId const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 292 of file Traversal.hpp.

+ +
+
+ +

◆ for_all_edges_at()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::GraphTypeLoopDifferentiation< GraphType, true >::for_all_edges_at (TGraph const & graph,
TVertexId const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 301 of file Traversal.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation.html b/classegoa_1_1internal_1_1_network_differentiation.html new file mode 100644 index 00000000..e2aa323a --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, GraphType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, GraphType > Class Template Reference
+
+
+

Detailed Description

+
template<typename VertexTypeProperties, typename EdgeTypeProperties, typename GraphType>
+class egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, GraphType >
+

Definition at line 34 of file PyPsaParser.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr828ec4fd22b4d3b547d9914b4f2478c6.html b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr828ec4fd22b4d3b547d9914b4f2478c6.html new file mode 100644 index 00000000..04c7ac61 --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr828ec4fd22b4d3b547d9914b4f2478c6.html @@ -0,0 +1,301 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > > Class Template Reference
+
+
+ + + + + + +

+Static Public Member Functions

static Types::edgeId AddEdge (TGraph &network, TIoEdge const &ioEdge)
 
static Types::vertexId AddVertex (TGraph &network, TVertexProperties const &vertexProperties)
 
+ + + + + + + + + +

+Private Types

using TVertexProperties = VertexTypeProperties
 
using TEdgeProperties = EdgeTypeProperties
 
using TGraph = StaticGraph< TVertexProperties, TEdgeProperties >
 
using TIoEdge = io::Edge< TEdgeProperties >
 
+

Detailed Description

+
template<typename VertexTypeProperties, typename EdgeTypeProperties>
+class egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >
+

Definition at line 3246 of file PyPsaParser.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeProperties

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::TEdgeProperties = EdgeTypeProperties
+ 		+private
+
+ +

Definition at line 3252 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::TGraph = StaticGraph<TVertexProperties , TEdgeProperties>
+ 		+private
+
+ +

Definition at line 3254 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TIoEdge

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::TIoEdge = io::Edge<TEdgeProperties>
+ 		+private
+
+ +

Definition at line 3257 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::TVertexProperties = VertexTypeProperties
+ 		+private
+
+ +

Definition at line 3251 of file PyPsaParser.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddEdge()

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::edgeId egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::AddEdge (TGraph & network,
TIoEdge const & ioEdge 
)
+ 		+inlinestatic
+
+ +

Definition at line 3259 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVertex()

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::vertexId egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >::AddVertex (TGraph & network,
TVertexProperties const & vertexProperties 
)
+ 		+inlinestatic
+
+ +

Definition at line 3265 of file PyPsaParser.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr95fa1fc366e5b030b1043055b1ebef80.html b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr95fa1fc366e5b030b1043055b1ebef80.html new file mode 100644 index 00000000..c8b09201 --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr95fa1fc366e5b030b1043055b1ebef80.html @@ -0,0 +1,301 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > > Class Template Reference
+
+
+ + + + + + +

+Static Public Member Functions

static Types::edgeId AddEdge (TGraph &network, TIoEdge const &ioEdge)
 
static Types::vertexId AddVertex (TGraph &network, TVertexProperties const &vertexProperties)
 
+ + + + + + + + + +

+Private Types

using TVertexProperties = VertexTypeProperties
 
using TEdgeProperties = EdgeTypeProperties
 
using TGraph = PowerGrid< StaticGraph< TVertexProperties, TEdgeProperties > >
 
using TIoEdge = io::Edge< TEdgeProperties >
 
+

Detailed Description

+
template<typename VertexTypeProperties, typename EdgeTypeProperties>
+class egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >
+

Definition at line 3273 of file PyPsaParser.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeProperties

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::TEdgeProperties = EdgeTypeProperties
+ 		+private
+
+ +

Definition at line 3281 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::TGraph = PowerGrid<StaticGraph<TVertexProperties , TEdgeProperties> >
+ 		+private
+
+ +

Definition at line 3283 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TIoEdge

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::TIoEdge = io::Edge<TEdgeProperties>
+ 		+private
+
+ +

Definition at line 3286 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::TVertexProperties = VertexTypeProperties
+ 		+private
+
+ +

Definition at line 3280 of file PyPsaParser.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddEdge()

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::edgeId egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::AddEdge (TGraph & network,
TIoEdge const & ioEdge 
)
+ 		+inlinestatic
+
+ +

Definition at line 3289 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVertex()

+ +
+
+
+template<typename VertexTypeProperties , typename EdgeTypeProperties >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::vertexId egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >::AddVertex (TGraph & network,
TVertexProperties const & vertexProperties 
)
+ 		+inlinestatic
+
+ +

Definition at line 3295 of file PyPsaParser.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pra51d120e779886086e6d7ea0ae269e07.html b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pra51d120e779886086e6d7ea0ae269e07.html new file mode 100644 index 00000000..46cc74ef --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pra51d120e779886086e6d7ea0ae269e07.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > > Member List
+
+
+ +

This is the complete list of members for egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >, including all inherited members.

+ + + + + + + +
AddEdge(TGraph &network, TIoEdge const &ioEdge) (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >inlinestatic
AddVertex(TGraph &network, TVertexProperties const &vertexProperties) (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >inlinestatic
TEdgeProperties typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >private
TGraph typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >private
TIoEdge typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >private
TVertexProperties typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_prfe473e5b8b13e5b8e7f9198ab30d5f88.html b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_prfe473e5b8b13e5b8e7f9198ab30d5f88.html new file mode 100644 index 00000000..1a75a13b --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_prfe473e5b8b13e5b8e7f9198ab30d5f88.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > > Member List
+
+
+ +

This is the complete list of members for egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >, including all inherited members.

+ + + + + + + +
AddEdge(TGraph &network, TIoEdge const &ioEdge) (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >inlinestatic
AddVertex(TGraph &network, TVertexProperties const &vertexProperties) (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >inlinestatic
TEdgeProperties typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >private
TGraph typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >private
TIoEdge typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >private
TVertexProperties typedef (defined in egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >)egoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie25fdcdc3c845cdb06c6c2944360d5752.html b/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie25fdcdc3c845cdb06c6c2944360d5752.html new file mode 100644 index 00000000..768b76c1 --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie25fdcdc3c845cdb06c6c2944360d5752.html @@ -0,0 +1,288 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > > Class Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > > Class Reference
+
+
+ + + + + + +

+Static Public Member Functions

static Types::edgeId AddEdge (TGraph &network, TIoEdge const &ioEdge)
 
static Types::vertexId AddVertex (TGraph &network, TVertexProperties const &vertexProperties)
 
+ + + + + + + + + +

+Private Types

using TGraph = StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties >
 
using TVertexProperties = egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >
 
using TEdgeProperties = egoa::Edges::ElectricalProperties
 
using TIoEdge = io::Edge< TEdgeProperties >
 
+

Detailed Description

+
+

Definition at line 3219 of file PyPsaParser.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeProperties

+ +
+
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::TEdgeProperties = egoa::Edges::ElectricalProperties
+ 		+private
+
+ +

Definition at line 3227 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::TGraph = StaticGraph<egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType> , egoa::Edges::ElectricalProperties>
+ 		+private
+
+ +

Definition at line 3224 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TIoEdge

+ +
+
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::TIoEdge = io::Edge<TEdgeProperties>
+ 		+private
+
+ +

Definition at line 3229 of file PyPsaParser.hpp.

+ +
+
+ +

◆ TVertexProperties

+ +
+
+ + + + + +
+ + + + +
using egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::TVertexProperties = egoa::Vertices::ElectricalProperties<egoa::Vertices::IeeeBusType>
+ 		+private
+
+ +

Definition at line 3226 of file PyPsaParser.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ AddEdge()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::edgeId egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::AddEdge (TGraph & network,
TIoEdge const & ioEdge 
)
+ 		+inlinestatic
+
+ +

Definition at line 3232 of file PyPsaParser.hpp.

+ +
+
+ +

◆ AddVertex()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Types::vertexId egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >::AddVertex (TGraph & network,
TVertexProperties const & vertexProperties 
)
+ 		+inlinestatic
+
+ +

Definition at line 3238 of file PyPsaParser.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie35248b0ea9b1474e3ec9e021187b712c.html b/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie35248b0ea9b1474e3ec9e021187b712c.html new file mode 100644 index 00000000..3b6ec158 --- /dev/null +++ b/classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie35248b0ea9b1474e3ec9e021187b712c.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > > Member List
+
+
+ +

This is the complete list of members for egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >, including all inherited members.

+ + + + + + + +
AddEdge(TGraph &network, TIoEdge const &ioEdge) (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >inlinestatic
AddVertex(TGraph &network, TVertexProperties const &vertexProperties) (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >inlinestatic
TEdgeProperties typedef (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >private
TGraph typedef (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >private
TIoEdge typedef (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >private
TVertexProperties typedef (defined in egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >)egoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation.html new file mode 100644 index 00000000..a175749f --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::PowerGridLoopDifferentiation< PowerGridType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, Policy > Class Template Reference
+
+
+ +

The base class for for loops for power grid. + More...

+

Detailed Description

+
template<typename PowerGridType, ExecutionPolicy Policy>
+class egoa::internal::PowerGridLoopDifferentiation< PowerGridType, Policy >

The base class for for loops for power grid.

+

Implementations for the loops are defined in the template specializations for the different execution policies.

+
Template Parameters
+ + + +
PowerGridTypeThe type of a power grid, e.g., PowerGrid.
PolicyThe execution policy.
+
+
+ +

Definition at line 33 of file PowerGridIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_padf6a4dfcea2feadc5b083097e9d17dc.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_padf6a4dfcea2feadc5b083097e9d17dc.html new file mode 100644 index 00000000..73e9c94d --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_padf6a4dfcea2feadc5b083097e9d17dc.html @@ -0,0 +1,146 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
for_all_generator_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_tuple(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(TVertex const &vertex, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_tuple(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_tuples(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_tuples(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(TVertex const &vertex, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots(TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, Types::vertexId vertexId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, TVertex const &vertex, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork &network, Types::generatorId generatorId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork const &network, Types::generatorId generatorId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork const &network, TGeneratorProperties generatorProperties, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots(TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, Types::vertexId vertexId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, TVertex const &vertex, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork &network, Types::loadId loadId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork const &network, Types::loadId loadId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork const &network, TLoadProperties const &loadProperties, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers_with_generator(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers_with_load(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
TGeneratorProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TLoadProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TLoopDifferentiation typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TNetwork typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4-members.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..0e83f411 --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,97 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >, including all inherited members.

+ + + + + + + + + + +
for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >inlinestatic
for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >inlinestatic
for_all_loads_at(Types::vertexId vertexId, TNetwork &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >inlinestatic
for_all_loads_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >inlinestatic
TGeneratorProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >private
TLoadProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >private
TLoopDifferentiation typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >private
TNetwork typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >private
TVertex typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..6c36c6c9 --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,462 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +Private Types | +List of all members
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable > Class Template Reference
+
+
+ +

Breakable for loops for PowerGrid. + More...

+ +

#include <PowerGridIterators.hpp>

+ + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename FUNCTION >
static void for_all_load_identifiers_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_load_identifiers_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId vertexId, TNetwork &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 
+ + + + + + + + + + + +

+Private Types

using TNetwork = PowerGridType
 
using TVertex = typename TNetwork::TVertex
 
using TGeneratorProperties = typename TNetwork::TGeneratorProperties
 
using TLoadProperties = typename TNetwork::TLoadProperties
 
using TLoopDifferentiation = PowerGridLoopDifferentiation< TNetwork, ExecutionPolicy::sequential >
 
+

Detailed Description

+
template<typename PowerGridType>
+class egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >

Breakable for loops for PowerGrid.

+

The loops are aborted if the function returns false.

+
Template Parameters
+ + +
PowerGridTypeThe type of the power grid.
+
+
+ +

Definition at line 1837 of file PowerGridIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::TGeneratorProperties = typename TNetwork::TGeneratorProperties
+ 		+private
+
+ +

Definition at line 1841 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::TLoadProperties = typename TNetwork::TLoadProperties
+ 		+private
+
+ +

Definition at line 1842 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TLoopDifferentiation

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::TLoopDifferentiation = PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::sequential>
+ 		+private
+
+ +

Definition at line 1843 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::TNetwork = PowerGridType
+ 		+private
+
+ +

Definition at line 1839 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::TVertex = typename TNetwork::TVertex
+ 		+private
+
+ +

Definition at line 1840 of file PowerGridIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_load_identifiers_at() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::for_all_load_identifiers_at (TVertex const & vertex,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1873 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_load_identifiers_at() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::for_all_load_identifiers_at (Types::vertexId vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1858 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::for_all_loads_at (Types::vertexId vertexId,
TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1884 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >::for_all_loads_at (Types::vertexId vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1902 of file PowerGridIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4-members.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..0e7b824d --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,146 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel > Member List
+
+
+ +

This is the complete list of members for egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
for_all_generator_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_tuple(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generator_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(TVertex const &vertex, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_tuple(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_generators_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_tuples(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_load_tuples(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(TVertex const &vertex, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_loads_tuple(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots(TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, Types::vertexId vertexId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, TVertex const &vertex, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_at(TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork &network, Types::generatorId generatorId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork const &network, Types::generatorId generatorId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_generator_snapshots_of(TNetwork const &network, TGeneratorProperties generatorProperties, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots(TNetwork &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots(TNetwork const &network, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, Types::vertexId vertexId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, TVertex const &vertex, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_at(TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork &network, Types::loadId loadId, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork const &network, Types::loadId loadId, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_real_power_load_snapshots_of(TNetwork const &network, TLoadProperties const &loadProperties, FUNCTION function) (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers_with_generator(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers_with_load(TNetwork const &network, FUNCTION function)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >inlinestatic
TGeneratorProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TLoadProperties typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TLoopDifferentiation typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TNetwork typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >)egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..6df35716 --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,318 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+List of all members
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel > Class Template Reference
+
+
+ +

If OpenMP is not available, fall back to sequential execution of the loops. + More...

+ +

#include <PowerGridIterators.hpp>

+
+Inheritance diagram for egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Member Functions inherited from egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_generators (TNetwork &network, FUNCTION function)
 The sequential for loop over all generators (vertex independent).
 
template<typename FUNCTION >
static void for_all_generators (TNetwork const &network, FUNCTION function)
 The sequential for loop over all generators (vertex independent).
 
template<typename FUNCTION >
static void for_all_vertex_identifiers_with_generator (TNetwork const &network, FUNCTION function)
 The sequential for loop over all vertices that have a generator.
 
template<typename FUNCTION >
static void for_all_generator_identifiers_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator identifiers at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generator_identifiers_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator identifiers at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (TVertex const &vertex, TNetwork &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generators_at (Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generator_tuple (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator and its generator objects.
 
template<typename FUNCTION >
static void for_all_generator_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator and its generator objects.
 
template<typename FUNCTION >
static void for_all_generators_tuple (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator.
 
template<typename FUNCTION >
static void for_all_generators_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots (TNetwork &network, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots (TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork &network, Types::generatorId generatorId, FUNCTION function)
 The sequential for loop over all maximum real power p.u. snapshots of a generator with generatorId.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork const &network, Types::generatorId generatorId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)
 The sequential for loop over all maximum real power p.u. snapshots of a generator.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork const &network, TGeneratorProperties generatorProperties, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, Types::vertexId vertexId, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, Types::vertexId vertexId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, TVertex const &vertex, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots at a vertex.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, TVertex const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The sequential for loop over snapshots with a certain @ timestampPosition for all generators.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_loads (TNetwork &network, FUNCTION function)
 The sequential for loop over all loads (vertex independent).
 
template<typename FUNCTION >
static void for_all_loads (TNetwork const &network, FUNCTION function)
 The sequential for loop over all loads (vertex independent).
 
template<typename FUNCTION >
static void for_all_vertex_identifiers_with_load (TNetwork const &network, FUNCTION function)
 The sequential for loop over all vertices that have a load.
 
template<typename FUNCTION >
static void for_all_load_identifiers_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load identifiers at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_load_identifiers_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load identifiers at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (TVertex const &vertex, TNetwork &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_load_tuples (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load and its load objects.
 
template<typename FUNCTION >
static void for_all_load_tuples (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load and its load objects.
 
template<typename FUNCTION >
static void for_all_loads_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots (TNetwork &network, FUNCTION function)
 The sequential for loop over all load real power snapshots.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots (TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork &network, Types::loadId loadId, FUNCTION function)
 The sequential for loop over all real power snapshots of a load with loadId.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork const &network, Types::loadId loadId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)
 The sequential for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork const &network, TLoadProperties const &loadProperties, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, Types::vertexId vertexId, FUNCTION function)
 The sequential for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, Types::vertexId vertexId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, TVertex const &vertex, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, TVertex const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The sequential for loop over snapshots with a certain @ timestampPosition for all load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a load and a timestamp at timestampPosition.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 
+

Detailed Description

+
template<typename PowerGridType>
+class egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel >

If OpenMP is not available, fall back to sequential execution of the loops.

+
Template Parameters
+ + +
PowerGridTypeThe type of the power grid.
+
+
+ +

Definition at line 3735 of file PowerGridIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..adecc8b9 Binary files /dev/null and b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..c842c913 --- /dev/null +++ b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,3906 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential > Class Template Reference
+
+
+
+Inheritance diagram for egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >:
+
+
+ + +egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

Sequential Generator Loops
template<typename FUNCTION >
static void for_all_generators (TNetwork &network, FUNCTION function)
 The sequential for loop over all generators (vertex independent).
 
template<typename FUNCTION >
static void for_all_generators (TNetwork const &network, FUNCTION function)
 The sequential for loop over all generators (vertex independent).
 
template<typename FUNCTION >
static void for_all_vertex_identifiers_with_generator (TNetwork const &network, FUNCTION function)
 The sequential for loop over all vertices that have a generator.
 
template<typename FUNCTION >
static void for_all_generator_identifiers_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator identifiers at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generator_identifiers_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator identifiers at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (TVertex const &vertex, TNetwork &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex.
 
template<typename FUNCTION >
static void for_all_generators_at (Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generators_at (Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all generator objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_generator_tuple (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator and its generator objects.
 
template<typename FUNCTION >
static void for_all_generator_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator and its generator objects.
 
template<typename FUNCTION >
static void for_all_generators_tuple (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator.
 
template<typename FUNCTION >
static void for_all_generators_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a generator.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots (TNetwork &network, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots (TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork &network, Types::generatorId generatorId, FUNCTION function)
 The sequential for loop over all maximum real power p.u. snapshots of a generator with generatorId.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork const &network, Types::generatorId generatorId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)
 The sequential for loop over all maximum real power p.u. snapshots of a generator.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_of (TNetwork const &network, TGeneratorProperties generatorProperties, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, Types::vertexId vertexId, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, Types::vertexId vertexId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, TVertex const &vertex, FUNCTION function)
 The sequential for loop over all generator maximum real power p.u. snapshots at a vertex.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, TVertex const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The sequential for loop over snapshots with a certain @ timestampPosition for all generators.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.
 
template<typename FUNCTION >
static void for_all_real_power_generator_snapshots_at (TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 
Sequential Load Loops
template<typename FUNCTION >
static void for_all_loads (TNetwork &network, FUNCTION function)
 The sequential for loop over all loads (vertex independent).
 
template<typename FUNCTION >
static void for_all_loads (TNetwork const &network, FUNCTION function)
 The sequential for loop over all loads (vertex independent).
 
template<typename FUNCTION >
static void for_all_vertex_identifiers_with_load (TNetwork const &network, FUNCTION function)
 The sequential for loop over all vertices that have a load.
 
template<typename FUNCTION >
static void for_all_load_identifiers_at (Types::vertexId vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load identifiers at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_load_identifiers_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load identifiers at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (TVertex const &vertex, TNetwork &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (TVertex const &vertex, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex.
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId const vertexId, TNetwork &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_loads_at (Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)
 The sequential for loop over all load objects at a vertex identifier vertexId.
 
template<typename FUNCTION >
static void for_all_load_tuples (TNetwork &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load and its load objects.
 
template<typename FUNCTION >
static void for_all_load_tuples (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load and its load objects.
 
template<typename FUNCTION >
static void for_all_loads_tuple (TNetwork const &network, FUNCTION function)
 The sequential for loop over all verticesthat have a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots (TNetwork &network, FUNCTION function)
 The sequential for loop over all load real power snapshots.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots (TNetwork const &network, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork &network, Types::loadId loadId, FUNCTION function)
 The sequential for loop over all real power snapshots of a load with loadId.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork const &network, Types::loadId loadId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)
 The sequential for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_of (TNetwork const &network, TLoadProperties const &loadProperties, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, Types::vertexId vertexId, FUNCTION function)
 The sequential for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, Types::vertexId vertexId, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, TVertex const &vertex, FUNCTION function)
 The for loop over all real power snapshots of a load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, TVertex const &vertex, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 The sequential for loop over snapshots with a certain @ timestampPosition for all load.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 The for loop over all real power snapshots of a load and a timestamp at timestampPosition.
 
template<typename FUNCTION >
static void for_all_real_power_load_snapshots_at (TNetwork const &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)
 
+ + + + + + + + + + + +

+Private Types

using TNetwork = PowerGridType
 
using TVertex = typename TNetwork::TVertex
 
using TGeneratorProperties = typename TNetwork::TGeneratorProperties
 
using TLoadProperties = typename TNetwork::TLoadProperties
 
using TLoopDifferentiation = PowerGridLoopDifferentiation< TNetwork, ExecutionPolicy::sequential >
 
+

Detailed Description

+
template<typename PowerGridType>
+class egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >
+

Definition at line 36 of file PowerGridIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TGeneratorProperties

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::TGeneratorProperties = typename TNetwork::TGeneratorProperties
+ 		+private
+
+ +

Definition at line 40 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TLoadProperties

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::TLoadProperties = typename TNetwork::TLoadProperties
+ 		+private
+
+ +

Definition at line 41 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TLoopDifferentiation

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::TLoopDifferentiation = PowerGridLoopDifferentiation<TNetwork, ExecutionPolicy::sequential>
+ 		+private
+
+ +

Definition at line 42 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TNetwork

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::TNetwork = PowerGridType
+ 		+private
+
+ +

Definition at line 38 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename PowerGridType >
+ + + + + +
+ + + + +
using egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::TVertex = typename TNetwork::TVertex
+ 		+private
+
+ +

Definition at line 39 of file PowerGridIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_generator_identifiers_at() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at (TVertex const & vertex,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator identifiers at a vertex.

+
Parameters
+ + + + +
[in]vertexThe vertex object.
[in]networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator identifier generatorId as input.
+
+
+
[]( Types::generatorId generatorId )
+
{
+
Do something with the generator identifier at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator identifiers at vertexId.
+
+
+ +

Definition at line 214 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generator_identifiers_at() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at (Types::vertexId vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator identifiers at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
[in]networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator identifier Types::generatorId as input.
+
+
+
[]( Types::generatorId generatorId )
+
{
+
Do something with the generator identifier at the @p vertexId.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator identifiers at vertexId.
+
+
+ +

Definition at line 174 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generator_tuple() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a generator and its generator objects.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a generator objectas input.
+
+
+
[]( Types::vertexId vertexId, TGeneratorProperties & generatorProperties )
+
{
+
Do something with the vertexId and the generator object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator tuple (vertexId, generatorProperties).
+
+
+ +

Definition at line 378 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generator_tuple() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a generator and its generator objects.

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a generator objectas input.
+
+
+
[]( Types::vertexId vertexId, TGeneratorProperties const & generator )
+
{
+
Do something with the vertexId and the generator object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator tuple (vertexId, generatorProperties).
+
+
+ +

Definition at line 420 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generators (vertex independent).

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties & generatorProperties )
+
{
+
Do something with the generator properties.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties in the power grid.
+
+
+ +

Definition at line 72 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generators (vertex independent).

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties const & generatorProperties )
+
{
+
Do something with the generator properties.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties in the power grid.
+
+
+ +

Definition at line 103 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_at() [1/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at (TVertex const & vertex,
TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator objects at a vertex.

+
Parameters
+ + + + +
vertexThe vertex object.
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties & generator )
+
{
+
Do something with the generator object at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties at vertex.
+
+
+ +

Definition at line 246 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_at() [2/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at (TVertex const & vertex,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator objects at a vertex.

+
Parameters
+ + + + +
vertexThe vertex object.
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties const & generator )
+
{
+
Do something with the generator object at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties at vertex.
+
+
+ +

Definition at line 277 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_at() [3/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at (Types::vertexId const vertexId,
TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator objects at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties & generator )
+
{
+
Do something with the generator object at the @p vertexId.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties at vertexId.
+
+
+ +

Definition at line 308 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_at() [4/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at (Types::vertexId const vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator objects at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a generator object as input.
+
+
+
[]( TGeneratorProperties const & generator )
+
{
+
Do something with the generator object at the @p vertexId.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator properties at vertexId.
+
+
+ +

Definition at line 343 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_tuple() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a generator.

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and its generator objectsas input.
+
+
+
[]( Types::vertexId vertexId, std::vector<TGeneratorProperties> const & generators )
+
{
+
Do something with the set of generators at the vertexId
+
and identifier of the vertex that has generators.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator tuple (vertexId, vector of generatorProperties).
+
+
+ +

Definition at line 463 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_generators_tuple() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a generator.

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and its generator objectsas input.
+
+
+
[]( Types::vertexId vertexId, std::vector<TGeneratorProperties> const & generators )
+
{
+
// Do something with the set of generators at the vertexId
+
// and identifier of the vertex that has generators.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all generator tuple (vertexId, vector of generatorProperties).
+
+
+ +

Definition at line 505 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_load_identifiers_at() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at (TVertex const & vertex,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load identifiers at a vertex.

+
Parameters
+ + + + +
vertexThe vertex object.
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load identifier as input.
+
+
+
[]( Types::loadId loadId )
+
{
+
Do something with the load identifier at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load identifiers at vertex.
+
+
+ +

Definition at line 1130 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_load_identifiers_at() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at (Types::vertexId vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load identifiers at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load identifier Types::loadId as input.
+
+
+
[]( Types::loadId loadId )
+
{
+
Do something with the load identifier at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all vertex identifiers at vertexId.
+
+
+ +

Definition at line 1092 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_load_tuples() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a load and its load objects.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a load objectas input.
+
+
+
[]( Types::vertexId vertexId, TLoadProperties & loadProperties )
+
{
+
Do something with the vertexId and load object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load tuples (vertexId, loadProperties).
+
+
+ +

Definition at line 1293 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_load_tuples() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a load and its load objects.

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and a load objectas input.
+
+
+
[]( Types::vertexId vertexId, TLoadProperties const & loadProperties )
+
{
+
Do something with the vertexId and load object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load tuples (vertexId, loadProperties).
+
+
+ +

Definition at line 1335 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all loads (vertex independent).

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
[]( TLoadProperties & load )
+
{
+
Do something with the load object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all loads.
+
+
+ +

Definition at line 988 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all loads (vertex independent).

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a const load object as input.
+
+
+
[]( TLoadProperties const & load )
+
{
+
Do something with the load object.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all loads.
+
+
+ +

Definition at line 1019 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [1/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at (TVertex const & vertex,
TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load objects at a vertex.

+
Parameters
+ + + + +
vertexThe vertex object.
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
[]( TLoadProperties & loadProperties )
+
{
+
Do something with the load object at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load properties at vertex.
+
+
+ +

Definition at line 1161 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [2/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at (TVertex const & vertex,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load objects at a vertex.

+
Parameters
+ + + + +
vertexThe vertex object.
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
[]( TLoadProperties const & load )
+
{
+
Do something with the load object at the @p vertex.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load properties at vertex.
+
+
+ +

Definition at line 1192 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [3/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at (Types::vertexId const vertexId,
TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load objects at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
[]( TLoadProperties & load )
+
{
+
Do something with the load object at the @p vertexId.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load properties at vertexId.
+
+
+ +

Definition at line 1223 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_at() [4/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at (Types::vertexId const vertexId,
TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load objects at a vertex identifier vertexId.

+
Parameters
+ + + + +
[in]vertexIdThe vertex identifier.
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a load object as input.
+
+
+
[]( TLoadProperties const & load )
+
{
+
Do something with the load object at the @p vertexId.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load properties at vertexId.
+
+
+ +

Definition at line 1258 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_loads_tuple()

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_tuple (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all verticesthat have a load.

+
Parameters
+ + + +
networkThe const network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier vertexId and its load objectsas input.
+
+
+
[]( Types::vertexId vertexId, std::vector<TLoadProperties> & loads )
+
{
+
Do something with the set of loads at the vertexId
+
and identifier of the vertex that has loads.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all load tuples (vertexId, vector of loadProperties).
+
+
+ +

Definition at line 1378 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator maximum real power p.u. snapshots.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_generator_snapshots<ExecutionPolicy::sequential>(
+
network,
+
[]( Types::index snapshotId
+
, Types::generatorSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator snapshots.
+
+
+ +

Definition at line 550 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 563 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [1/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork & network,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator maximum real power p.u. snapshots at a vertex.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
vertexThe vertex.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the vertex vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator snapshots at vertex.
+
+
+ +

Definition at line 796 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [2/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork & network,
TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all real power snapshots of a generator and a timestamp at timestampPosition.

+
Parameters
+ + + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
vertexThe vertex
[in]timestampPositionThe timestamp position
[in]functionThe function
+
+
+
Precondition
Check if the vertex vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertex,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 934 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [3/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork & network,
Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all generator maximum real power p.u. snapshots at a vertex with vertexId.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
vertexIdThe identifier of a vertex.
[in]functionThe function, e.g. , lambda function.
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator snapshots at vertexId.
+
+
+ +

Definition at line 729 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [4/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork & network,
Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over snapshots with a certain @ timestampPosition for all generators.

+

This loop basically extracts a row.

+
Parameters
+ + + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
vertexIdThe identifier of a vertex
timestampPositionThe position of the snapshot (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_generator_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertexId,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator at timestamp at vertex.
+
+
+ +

Definition at line 864 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [5/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork const & network,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 812 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [6/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork const & network,
TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 948 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [7/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork const & network,
Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 746 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_at() [8/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at (TNetwork const & network,
Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 882 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [1/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of (TNetwork & network,
TGeneratorProperties generatorProperties,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all maximum real power p.u. snapshots of a generator.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
generatorPropertiesThe generator properties.
[in]functionThe function, e.g. , lambda function.
+
+
+
Precondition
Check if the generator's properties generatorProperties exists before using this method.
+
if ( network.HasGenerator ( network.GeneratorId ( generatorProperties ) ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
network,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator snapshots of generatorProperties.
+
+
+ +

Definition at line 671 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [2/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of (TNetwork & network,
Types::generatorId generatorId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all maximum real power p.u. snapshots of a generator with generatorId.

+
Parameters
+ + + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots)$.
generatorIdThe identifier of the generator.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the generator identifier generatorId of the generatorProperties exists before using this method.
+
if ( network.HasGenerator ( generatorId ) )
+
{
+
for_all_real_power_generator_snapshots_of<ExecutionPolicy::sequential> (
+
network,
+
generatorId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
// Do something with the snapshotId and generator snapshot object.
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power generator snapshots at generatorId.
+
+
+ +

Definition at line 608 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [3/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of (TNetwork const & network,
TGeneratorProperties generatorProperties,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 684 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_generator_snapshots_of() [4/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of (TNetwork const & network,
Types::generatorId generatorId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 624 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots() [1/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots (TNetwork & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all load real power snapshots.

+
Parameters
+ + + +
networkThe network
[in]functionThe function, e.g., lambda function.
+
+
+
for_all_real_power_load_snapshots<ExecutionPolicy::sequential>(
+
network,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load snapshots.
+
+
+ +

Definition at line 1424 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots() [2/2]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1439 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [1/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork & network,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
networkThe network
vertexThe vertex
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( network.Graph().VertexId( vertex ) ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertex,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load snapshots at vertex.
+
+
+ +

Definition at line 1671 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [2/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork & network,
TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all real power snapshots of a load and a timestamp at timestampPosition.

+
Parameters
+ + + + + +
networkThe network
vertexThe vertex
[in]timestampPositionThe timestamp position
[in]functionThe function
+
+
+
Precondition
Check if the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertex,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 1800 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [3/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork & network,
Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
networkThe network
vertexIdThe identifier of a vertex
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertexId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object }
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load snapshots at vertexId.
+
+
+ +

Definition at line 1607 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [4/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork & network,
Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over snapshots with a certain @ timestampPosition for all load.

+

This loop basically extracts a row.

+
Parameters
+ + + + + +
networkThe network
vertexIdThe identifier of a vertex
timestampPositionThe position of the snapshot (timestamp of the snapshot).
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the vertex identifier vertexId of the vertex exists before using this method.
+
if ( network.Graph().VertexExists( vertexId ) )
+
{
+
for_all_real_power_load_snapshots_at<ExecutionPolicy::sequential> (
+
network,
+
vertexId,
+
timestampPosition,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load at timestamp at vertex.
+
+
+ +

Definition at line 1732 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [5/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork const & network,
TVertex const & vertex,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1684 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [6/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork const & network,
TVertex const & vertex,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1814 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [7/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork const & network,
Types::vertexId vertexId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1624 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_at() [8/8]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at (TNetwork const & network,
Types::vertexId vertexId,
Types::index timestampPosition,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1750 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [1/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of (TNetwork & network,
TLoadProperties const & loadProperties,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all real power snapshots of a load.

+
Parameters
+ + + + +
networkThe network.
loadPropertiesThe load properties.
[in]functionThe function, e.g. , lambda function
+
+
+
Precondition
Check if the load's properties loadProperties exists before using this method.
+
if ( network.HasLoad ( network.LoadId ( loadProperties ) ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
network,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load snapshots at loadProperties.
+
+
+ +

Definition at line 1550 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [2/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of (TNetwork & network,
Types::loadId loadId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all real power snapshots of a load with loadId.

+
Parameters
+ + + + +
networkThe network.
loadIdThe identifier of the load.
[in]functionThe function, e.g., lambda function.
+
+
+
Precondition
Check if the load identifier loadId of the loadProperties exists before using this method.
+
if ( network.HasLoad ( loadId ) )
+
{
+
for_all_real_power_load_snapshots_of<ExecutionPolicy::sequential> (
+
network,
+
loadId,
+
[]( Types::index snapshotId
+
, Types::loadSnapshot snapshot )
+
{
+
Do something with the snapshotId and load snapshot object
+
}
+
);
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all real power load snapshots at loadId.
+
+
+ +

Definition at line 1485 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [3/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of (TNetwork const & network,
TLoadProperties const & loadProperties,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1563 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_real_power_load_snapshots_of() [4/4]

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of (TNetwork const & network,
Types::loadId loadId,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

Definition at line 1502 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers_with_generator()

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_generator (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all vertices that have a generator.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier Types::vertexId as input.
+
+
+
[]( Types::vertexId vertexId )
+
{
+
Do something with the vertex identifier that has generators.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all vertex identifiers that have a generator.
+
+
+ +

Definition at line 134 of file PowerGridIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers_with_load()

+ +
+
+
+template<typename PowerGridType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_load (TNetwork const & network,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The sequential for loop over all vertices that have a load.

+
Parameters
+ + + +
networkThe network $\network = ( \graph, + \generators, \consumers, \capacity, \susceptance, \dots + )$.
[in]functionThe function pointer, e.g., lambda function that has a vertex identifier Types::vertexId as input.
+
+
+
[]( Types::vertexId vertexId )
+
{
+
Do something with the vertex identifier that has loads.
+
}
+
Template Parameters
+ + +
FUNCTIONThe function object that is called for all vertex identifiers that have a load.
+
+
+ +

Definition at line 1051 of file PowerGridIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.png b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..dffc9404 Binary files /dev/null and b/classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.png differ diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation.html new file mode 100644 index 00000000..864f64ed --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation.html @@ -0,0 +1,118 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::StaticGraphLoopDifferentiation< GraphType, Policy > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, Policy > Class Template Reference
+
+
+ +

The for loops for StaticGraph. + More...

+ +

#include <StaticGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::StaticGraphLoopDifferentiation< GraphType, Policy >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, Policy > + +
+

Detailed Description

+
template<typename GraphType, ExecutionPolicy Policy>
+class egoa::internal::StaticGraphLoopDifferentiation< GraphType, Policy >

The for loops for StaticGraph.

+

The usage of templates is faster instead of ordinary function pointers such as std::function ( see https://stackoverflow.com/questions/14677997/stdfunction-vs-template for more information). This is the reason why the following code is not used inline void for_all_<SOME_FUNCTION>(std::function<void(TVertex & vertex)> function) {}

+
Template Parameters
+ + + +
GraphTypeThe type of the graph, e.g., StaticGraph<VertexType, EdgeType>. If the graph type is const, const references to the vertices and edges are passed to the function objects.
PolicyThe execution policy, e.g., ExecutionPolicy::sequential.
+
+
+
See also
StaticGraph
+
+ExecutionPolicy
+ +

Definition at line 40 of file StaticGraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation.png b/classegoa_1_1internal_1_1_static_graph_loop_differentiation.png new file mode 100644 index 00000000..306946b5 Binary files /dev/null and b/classegoa_1_1internal_1_1_static_graph_loop_differentiation.png differ diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..830712eb --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Member List
+
+
+ +

This is the complete list of members for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >inlinestatic
TEdgeId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TGraph typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TVertex typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
TVertexId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..4cc76b78 --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,560 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > Class Template Reference
+
+
+ +

Breakable for loops for StaticGraph. + More...

+ +

#include <StaticGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

Breakable Vertex Loops
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
Breakable Edge Loops
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all identifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
- Static Public Member Functions inherited from egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The breakable for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The breakable for loop over all identifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The breakable for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The breakable for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The breakable for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+ + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TVertexId = typename GraphType::TVertexId
 
using TVertex = typename GraphType::TVertex
 
using TEdgeId = typename GraphType::TEdgeId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >

Breakable for loops for StaticGraph.

+

The loops are aborted if the function returns false.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 201 of file StaticGraphIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TEdgeId = typename GraphType::TEdgeId
+ 		+private
+
+ +

Definition at line 206 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 203 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TVertex = typename GraphType::TVertex
+ 		+private
+
+ +

Definition at line 205 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::TVertexId = typename GraphType::TVertexId
+ 		+private
+
+ +

Definition at line 204 of file StaticGraphIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all identifiers of edges in the graph $\graph$.

+

The loop is aborted if the function returns false, otherwise it continues.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
[]( Types::edgeId edgeId ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge identifier
+
return whetherToContinue;
+
}
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The breakable for loop over all vertex identifiers in the graph .
Definition StaticGraphIterators.hpp:234
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 311 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_edge_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.

+

The loop is aborted if the function returns false, otherwise it continues.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TGraph::TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge & edge ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the edge
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 348 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all vertex identifiers in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type Types::vertexId e.g.,
[]( Types::vertexId vertexId ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the vertex identifier.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 234 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The breakable for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TGraph::TVertex, e.g.,
[]( Types::vertexId vertexId, TVertex & vertex ) -> bool
+
{
+
bool whetherToContinue = true;
+
// Do something with the vertex identifier and object.
+
return whetherToContinue;
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 269 of file StaticGraphIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png new file mode 100644 index 00000000..c5d315a3 Binary files /dev/null and b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.png differ diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..dab77c23 --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Member List
+
+
+ +

This is the complete list of members for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
TEdgeId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TGraph typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertexId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..3380b94b --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,186 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+List of all members
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > Class Template Reference
+
+
+ +

If OpenMP is not available, fall back to sequential execution of the loops. + More...

+ +

#include <StaticGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >:
+
+
+ + +egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > +egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Member Functions inherited from egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
- Static Public Member Functions inherited from egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >

If OpenMP is not available, fall back to sequential execution of the loops.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 591 of file StaticGraphIterators.hpp.

+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..41152f3d Binary files /dev/null and b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.png differ diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html new file mode 100644 index 00000000..4418e796 --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4-members.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Member List
+
+
+ +

This is the complete list of members for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
for_all_edge_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edge_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_identifiers(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertex_tuples(TGraph &graph, FUNCTION function)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_all_vertices(TGraph &graph, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >inlinestatic
TEdgeId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TGraph typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertex typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
TVertexId typedef (defined in egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >)egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >private
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..754184ef --- /dev/null +++ b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,550 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Private Types | +List of all members
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > Class Template Reference
+
+
+ +

The sequential for loops for StaticGraph. + More...

+ +

#include <StaticGraphIterators.hpp>

+
+Inheritance diagram for egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >:
+
+
+ + +egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > +egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

Sequential Vertex Loops
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
Sequential Edge Loops
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
- Static Public Member Functions inherited from egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >
template<typename FUNCTION >
static void for_all_vertex_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all vertex identifiers in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertices (TGraph &graph, FUNCTION function)
 The for loop over all vertex objects $\vertices$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_vertex_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_identifiers (TGraph &graph, FUNCTION function)
 The for loop over all indentifiers of edges in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges (TGraph &graph, FUNCTION function)
 The for loop over all edges $\edges$ in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edge_tuples (TGraph &graph, FUNCTION function)
 The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_all_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all edges at a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_in_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all incoming edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertex const &vertex, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
template<typename FUNCTION >
static void for_out_edges_at (TGraph &graph, TVertexId vertexId, FUNCTION function)
 The for loop over all outgoing edges of a vertex $\vertex\in\vertices$.
 
+ + + + + + + + + +

+Private Types

using TGraph = GraphType
 
using TVertex = typename TGraph::TVertex
 
using TVertexId = typename TGraph::TVertexId
 
using TEdgeId = typename TGraph::TEdgeId
 
+

Detailed Description

+
template<typename GraphType>
+class egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >

The sequential for loops for StaticGraph.

+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+ +

Definition at line 50 of file StaticGraphIterators.hpp.

+

Member Typedef Documentation

+ +

◆ TEdgeId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TEdgeId = typename TGraph::TEdgeId
+ 		+private
+
+ +

Definition at line 57 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TGraph

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TGraph = GraphType
+ 		+private
+
+ +

Definition at line 54 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TVertex

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TVertex = typename TGraph::TVertex
+ 		+private
+
+ +

Definition at line 55 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ TVertexId

+ +
+
+
+template<typename GraphType >
+ + + + + +
+ + + + +
using egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::TVertexId = typename TGraph::TVertexId
+ 		+private
+
+ +

Definition at line 56 of file StaticGraphIterators.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ for_all_edge_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all indentifiers of edges in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept one argument of type Types::edgeId, e.g.,
[]( Types::edgeId edgeId )
+
{
+
// Do something with the edge identifier.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 149 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_edge_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all pairs of edge identifiers and edge objects in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all edges. It must accept two arguments of types Types::edgeId and TGraph::TEdge, e.g.,
[]( Types::edgeId edgeId, TEdge & edge )
+
{
+
// Do something with the edge.
+
}
+
egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers
static void for_all_vertex_identifiers(TGraph &graph, FUNCTION function)
The for loop over all vertex identifiers in the graph .
Definition StaticGraphIterators.hpp:82
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 180 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_identifiers()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all vertex identifiers in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept one argument of type TGraph::TVertexId, e.g.,
[]( Types::vertexId vertexId )
+
{
+
// Do something with the vertex identifier
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 82 of file StaticGraphIterators.hpp.

+ +
+
+ +

◆ for_all_vertex_tuples()

+ +
+
+
+template<typename GraphType >
+
+template<typename FUNCTION >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples (TGraph & graph,
FUNCTION function 
)
+ 		+inlinestatic
+
+ +

The for loop over all pairs of vertex identifiers and vertex tuples in the graph $\graph$.

+
Parameters
+ + + +
graphThe graph $\graph = (\vertices, \edges)$.
[in]functionThe function object that is called for all vertices. It must accept two arguments of types Types::vertexId and TGraph::TVertex, e.g.,
[]( Types::vertexId vertexId, TVertex & vertex )
+
{
+
// Do something with the vertex identifier and object.
+
}
+
+
+
+
Template Parameters
+ + +
FUNCTIONThe type of the function object.
+
+
+ +

Definition at line 113 of file StaticGraphIterators.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..2892cc4f Binary files /dev/null and b/classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.png differ diff --git a/classegoa_1_1io_1_1_edge-members.html b/classegoa_1_1io_1_1_edge-members.html new file mode 100644 index 00000000..650b320f --- /dev/null +++ b/classegoa_1_1io_1_1_edge-members.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
egoa::io::Edge< PropertiesType > Member List
+
+
+ +

This is the complete list of members for egoa::io::Edge< PropertiesType >, including all inherited members.

+ + + + + + + + + + + + +
Edge() (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
Properties() (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
Properties() const (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
properties_ (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >private
Source() const (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
Source() (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
source_egoa::io::Edge< PropertiesType >private
Target() const (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
Target() (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >inline
target_egoa::io::Edge< PropertiesType >private
TProperties typedef (defined in egoa::io::Edge< PropertiesType >)egoa::io::Edge< PropertiesType >
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classegoa_1_1io_1_1_edge.html b/classegoa_1_1io_1_1_edge.html new file mode 100644 index 00000000..787380d8 --- /dev/null +++ b/classegoa_1_1io_1_1_edge.html @@ -0,0 +1,432 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::io::Edge< PropertiesType > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Private Attributes | +List of all members
+
egoa::io::Edge< PropertiesType > Class Template Reference
+
+
+ + + + +

+Public Types

using TProperties = PropertiesType
 
+ + + + + + + + + + + + + +

+Public Member Functions

Types::vertexId Source () const
 
Types::vertexId & Source ()
 
Types::vertexId Target () const
 
Types::vertexId & Target ()
 
TProperties & Properties ()
 
TProperties const & Properties () const
 
+ + + + + + + +

+Private Attributes

Types::vertexId source_
 
Types::vertexId target_
 
TProperties properties_
 
+

Detailed Description

+
template<typename PropertiesType>
+class egoa::io::Edge< PropertiesType >
+

Definition at line 16 of file Edge.hpp.

+

Member Typedef Documentation

+ +

◆ TProperties

+ +
+
+
+template<typename PropertiesType >
+ + + + +
using egoa::io::Edge< PropertiesType >::TProperties = PropertiesType
+
+ +

Definition at line 18 of file Edge.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Edge()

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
egoa::io::Edge< PropertiesType >::Edge ()
+ 		+inline
+
+ +

Definition at line 20 of file Edge.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ Properties() [1/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
TProperties & egoa::io::Edge< PropertiesType >::Properties ()
+ 		+inline
+
+ +

Definition at line 32 of file Edge.hpp.

+ +
+
+ +

◆ Properties() [2/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
TProperties const & egoa::io::Edge< PropertiesType >::Properties () const
+ 		+inline
+
+ +

Definition at line 33 of file Edge.hpp.

+ +
+
+ +

◆ Source() [1/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId & egoa::io::Edge< PropertiesType >::Source ()
+ 		+inline
+
+ +

Definition at line 27 of file Edge.hpp.

+ +
+
+ +

◆ Source() [2/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::io::Edge< PropertiesType >::Source () const
+ 		+inline
+
+ +

Definition at line 26 of file Edge.hpp.

+ +
+
+ +

◆ Target() [1/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId & egoa::io::Edge< PropertiesType >::Target ()
+ 		+inline
+
+ +

Definition at line 30 of file Edge.hpp.

+ +
+
+ +

◆ Target() [2/2]

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + + + + +
Types::vertexId egoa::io::Edge< PropertiesType >::Target () const
+ 		+inline
+
+ +

Definition at line 29 of file Edge.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ properties_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
TProperties egoa::io::Edge< PropertiesType >::properties_
+ 		+private
+
+ +

Definition at line 38 of file Edge.hpp.

+ +
+
+ +

◆ source_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
Types::vertexId egoa::io::Edge< PropertiesType >::source_
+ 		+private
+
+

Source bus

+ +

Definition at line 36 of file Edge.hpp.

+ +
+
+ +

◆ target_

+ +
+
+
+template<typename PropertiesType >
+ + + + + +
+ + + + +
Types::vertexId egoa::io::Edge< PropertiesType >::target_
+ 		+private
+
+

Target bus

+ +

Definition at line 37 of file Edge.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/classes.html b/classes.html new file mode 100644 index 00000000..7c1073de --- /dev/null +++ b/classes.html @@ -0,0 +1,141 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Index + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class Index
+
+
+
A | B | C | D | E | G | H | I | K | L | M | N | O | P | Q | S | T | U | V
+
+
+
A
+
ArticulationVertexDetection (egoa)
+
+
B
+
BetweennessCentrality (egoa)
BFS (egoa)
BinaryHeap (egoa)
BinaryHeapCheck (egoa::internal)
BinaryHeapCheck< Type, false > (egoa::internal)
BinaryHeapCheck< Type, true > (egoa::internal)
BinaryHeapLoopDifferentiation (egoa::internal)
BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable > (egoa::internal)
BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential > (egoa::internal)
BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable > (egoa::internal)
BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel > (egoa::internal)
BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential > (egoa::internal)
BlockCutTree::Block (egoa)
BlockCutTree (egoa)
BlockCutTreeBuilder (egoa::internal)
BlockCutTreeTraversal (egoa)
BlockCutTreeBuilder::BlockUnderConstruction (egoa::internal)
Bound (egoa)
BoundMismatch (egoa)
Bucket (egoa)
BucketElement (egoa)
BucketLoopDifferentiation (egoa::internal)
BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable > (egoa::internal)
BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel > (egoa::internal)
BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential > (egoa::internal)
+
+
C
+
CallbackEmpty (egoa)
CarrierDifferentiation (egoa::Edges)
CarrierDifferentiation< Edges::CarrierDifferentiationType::AC > (egoa::Edges)
CarrierDifferentiation< Edges::CarrierDifferentiationType::DC > (egoa::Edges)
CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown > (egoa::Edges)
Color (egoa)
ContainerLoop (egoa::internal)
ContainerLoop< ExecutionPolicy::breakable > (egoa::internal)
ContainerLoop< ExecutionPolicy::parallel > (egoa::internal)
ContainerLoop< ExecutionPolicy::sequential > (egoa::internal)
BlockCutTree::CutVertex (egoa)
+
+
D
+
DepthFirstSearch (egoa)
DominatingThetaPath (egoa)
DominationDifferentiation (egoa::internal)
DominationDifferentiation< ElementType, DominationCriterion::none > (egoa::internal)
DominationDifferentiation< ElementType, DominationCriterion::strict > (egoa::internal)
DominationDifferentiation< ElementType, DominationCriterion::weak > (egoa::internal)
DtpRuntimeCollection (egoa::IO)
DtpRuntimeRow (egoa::IO)
DynamicGraph (egoa)
DynamicGraphLoopDifferentiation (egoa::internal)
DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > (egoa::internal)
+
+
E
+
Edge (egoa::Edges)
Edge (egoa::io)
ElectricalProperties (egoa::Edges)
ElectricalProperties (egoa::Vertices)
+
+
G
+
GenerationStrategyDifferentiation (egoa::internal)
GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot > (egoa::internal)
GeneratorProperties (egoa::Vertices)
GeoJsonWriter (egoa::IO)
GraphLoopDifferentiation (egoa::internal)
GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > (egoa::internal)
GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > (egoa::internal)
GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > (egoa::internal)
GraphTypeLoopDifferentiation (egoa::internal)
GraphTypeLoopDifferentiation< GraphType, false > (egoa::internal)
GraphTypeLoopDifferentiation< GraphType, true > (egoa::internal)
GurobiSolver (egoa)
+
+
H
+
BinaryHeap::HeapIterator (egoa)
+
+
I
+
IeeeCdfMatlabParser (egoa)
+
+
K
+
Kruskal (egoa)
+
+
L
+
Label (egoa)
LoadProperties (egoa::Vertices)
+
+
M
+
MappingBinaryHeap (egoa)
MatchPathSeparator (egoa::Auxiliary)
MST (egoa)
+
+
N
+
NetworkDifferentiation (egoa::internal)
NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > > (egoa::internal)
NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > > (egoa::internal)
NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > > (egoa::internal)
+
+
O
+
OmittingIterator (egoa)
DynamicGraph::OmittingVectorView (egoa)
+
+
P
+
PowerGrid (egoa)
PowerGridIO (egoa)
PowerGridLoopDifferentiation (egoa::internal)
PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable > (egoa::internal)
PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel > (egoa::internal)
PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential > (egoa::internal)
Prim (egoa)
PriorityQueue (egoa)
PyPsaParser (egoa)
+
+
Q
+
Queue (egoa)
+
+
S
+
SolverRuntimeCollection (egoa::IO)
SolverRuntimeRow (egoa::IO)
StaticGraph (egoa)
StaticGraphLoopDifferentiation (egoa::internal)
StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable > (egoa::internal)
StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel > (egoa::internal)
StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential > (egoa::internal)
StdQueue (egoa)
Stroke (egoa)
Subgraph (egoa)
SusceptanceNormLabel (egoa)
+
+
T
+
Timer (egoa::Auxiliary)
Traversal (egoa)
+
+
U
+
UnionFind (egoa)
+
+
V
+
VectorBasedComparator (egoa)
VectorView (egoa)
Vertex (egoa::Vertices)
VoltageAngleDifferenceLabel (egoa)
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/closed.png b/closed.png new file mode 100644 index 00000000..98cc2c90 Binary files /dev/null and b/closed.png differ diff --git a/dir_08148af5b585a808e4ff49eefa3a451d.html b/dir_08148af5b585a808e4ff49eefa3a451d.html new file mode 100644 index 00000000..798a1d92 --- /dev/null +++ b/dir_08148af5b585a808e4ff49eefa3a451d.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Appearance Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Appearance Directory Reference
+
+
+ + + + + + +

+Files

 Color.hpp
 
 Stroke.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_0c92a72c5d0046a348df803e0d3c6829.html b/dir_0c92a72c5d0046a348df803e0d3c6829.html new file mode 100644 index 00000000..92365962 --- /dev/null +++ b/dir_0c92a72c5d0046a348df803e0d3c6829.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/SpanningTree Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SpanningTree Directory Reference
+
+
+ + + + + + + + +

+Files

 Kruskal.hpp
 
 MST.hpp
 
 Prim.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_0f14700551a60ac37627dfce9ba5d326.html b/dir_0f14700551a60ac37627dfce9ba5d326.html new file mode 100644 index 00000000..88d14675 --- /dev/null +++ b/dir_0f14700551a60ac37627dfce9ba5d326.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Vertices Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vertices Directory Reference
+
+
+ + + + + + + + + + + + +

+Files

 ElectricalProperties.hpp
 
 GeneratorProperties.hpp
 
 LoadProperties.hpp
 
 Type.hpp
 
 Vertex.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_1752a20dc17a5b895822668bb3b841de.html b/dir_1752a20dc17a5b895822668bb3b841de.html new file mode 100644 index 00000000..5c1deff8 --- /dev/null +++ b/dir_1752a20dc17a5b895822668bb3b841de.html @@ -0,0 +1,98 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Container Directory Reference
+
+
+ + + + +

+Directories

 Queues
 
+ + + + + +

+Files

 DominationCriterion.hpp
 
 UnionFind.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_1bd0afe292e00d0a4e200f351763bc4f.html b/dir_1bd0afe292e00d0a4e200f351763bc4f.html new file mode 100644 index 00000000..7a990550 --- /dev/null +++ b/dir_1bd0afe292e00d0a4e200f351763bc4f.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/Runnables Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Runnables Directory Reference
+
+
+ + + + +

+Files

 main.cpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_1feb286f4781c752994d85cc2f2db043.html b/dir_1feb286f4781c752994d85cc2f2db043.html new file mode 100644 index 00000000..3a5556fd --- /dev/null +++ b/dir_1feb286f4781c752994d85cc2f2db043.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Auxiliary Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Auxiliary Directory Reference
+
+
+ + + + + + + + + + + + + + + + +

+Files

 Auxiliary.hpp
 
 Comparators.hpp
 
 Constants.hpp
 
 ContainerLoop.hpp
 
 ExecutionPolicy.hpp
 
 Timer.hpp
 
 Types.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_210436fb218d60f6ab98768cd1e20421.html b/dir_210436fb218d60f6ab98768cd1e20421.html new file mode 100644 index 00000000..7f84ca92 --- /dev/null +++ b/dir_210436fb218d60f6ab98768cd1e20421.html @@ -0,0 +1,97 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Statistics Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Statistics Directory Reference
+
+
+ + + + + + + + + + +

+Files

 DtpRuntimeCollection.hpp
 
 DtpRuntimeRow.hpp
 
 SolverRuntimeCollection.hpp
 
 SolverRuntimeRow.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_27c4d0cf215a585e30af4e5f959acb41.html b/dir_27c4d0cf215a585e30af4e5f959acb41.html new file mode 100644 index 00000000..861abb5e --- /dev/null +++ b/dir_27c4d0cf215a585e30af4e5f959acb41.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Wrapper Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Wrapper Directory Reference
+
+
+ + + + +

+Files

 Edge.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_37401ccf0080e6867c29a03743a3fbc5.html b/dir_37401ccf0080e6867c29a03743a3fbc5.html new file mode 100644 index 00000000..45497c40 --- /dev/null +++ b/dir_37401ccf0080e6867c29a03743a3fbc5.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/GraphTraversal Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GraphTraversal Directory Reference
+
+
+ + + + + + + + + + + + +

+Files

 ArticulationVertexDetection.hpp
 
 BreadthFirstSearch.hpp
 
 CycleDetection.hpp
 
 DepthFirstSearch.hpp
 
 Traversal.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_3a0fb8bddda4a3a9e625cbbc804bd394.html b/dir_3a0fb8bddda4a3a9e625cbbc804bd394.html new file mode 100644 index 00000000..99064367 --- /dev/null +++ b/dir_3a0fb8bddda4a3a9e625cbbc804bd394.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Algorithms Directory Reference
+
+
+ + + + + + + + + + +

+Directories

 Centralities
 
 GraphTraversal
 
 PathFinding
 
 SpanningTree
 
+ + + +

+Files

 BlockCutTreeTraversal.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_4045643538bad1aadeff61b05dc9bc0d.html b/dir_4045643538bad1aadeff61b05dc9bc0d.html new file mode 100644 index 00000000..7affe847 --- /dev/null +++ b/dir_4045643538bad1aadeff61b05dc9bc0d.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Exceptions Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Exceptions Directory Reference
+
+
+ + + + + + +

+Files

 Assertions.hpp
 
 Exceptions.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_4d8b910da55623d3d2ab674a6b4d4529.html b/dir_4d8b910da55623d3d2ab674a6b4d4529.html new file mode 100644 index 00000000..4a682738 --- /dev/null +++ b/dir_4d8b910da55623d3d2ab674a6b4d4529.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Iterators Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Iterators Directory Reference
+
+
+ + + + + + + + + + + + +

+Files

 DynamicGraphIterators.hpp
 
 GraphIterators.hpp
 
 OmittingIterator.hpp
 
 PowerGridIterators.hpp
 
 StaticGraphIterators.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_4ed92d81751bbdcebe30ff7c7dd29e72.html b/dir_4ed92d81751bbdcebe30ff7c7dd29e72.html new file mode 100644 index 00000000..5eecca82 --- /dev/null +++ b/dir_4ed92d81751bbdcebe30ff7c7dd29e72.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Parser Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Parser Directory Reference
+
+
+ + + + + + +

+Files

 IeeeCdfMatlabParser.hpp
 
 PyPsaParser.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_59e4c3c47c5e8ce53bbfa4b8f780a89d.html b/dir_59e4c3c47c5e8ce53bbfa4b8f780a89d.html new file mode 100644 index 00000000..1884d1b8 --- /dev/null +++ b/dir_59e4c3c47c5e8ce53bbfa4b8f780a89d.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/IO/Appearance Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Appearance Directory Reference
+
+
+ + + + +

+Files

 Color.cpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_6756fa7f4bde466df87bbc8ae5c52462.html b/dir_6756fa7f4bde466df87bbc8ae5c52462.html new file mode 100644 index 00000000..d59e5ca7 --- /dev/null +++ b/dir_6756fa7f4bde466df87bbc8ae5c52462.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs/Edges Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Edges Directory Reference
+
+
+ + + + + + + + +

+Files

 Edge.hpp
 
 ElectricalProperties.hpp
 
 Type.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html new file mode 100644 index 00000000..417b5574 --- /dev/null +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
src Directory Reference
+
+
+ + + + + + +

+Directories

 IO
 
 Runnables
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_6cc6ae344c9c86eee4fa489bb947ccc5.html b/dir_6cc6ae344c9c86eee4fa489bb947ccc5.html new file mode 100644 index 00000000..0a92c16b --- /dev/null +++ b/dir_6cc6ae344c9c86eee4fa489bb947ccc5.html @@ -0,0 +1,97 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Labels Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Labels Directory Reference
+
+
+ + + + + + + + + + +

+Files

 BucketElement.hpp
 
 Label.hpp
 
 SusceptanceNormLabel.hpp
 
 VoltageAngleDifferenceLabel.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_84a0cdeeed10a51ba3ff61ca2a982258.html b/dir_84a0cdeeed10a51ba3ff61ca2a982258.html new file mode 100644 index 00000000..a963c1eb --- /dev/null +++ b/dir_84a0cdeeed10a51ba3ff61ca2a982258.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Views Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Views Directory Reference
+
+
+ + + + +

+Files

 VectorView.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_90283ce059e2353638303443fc5ae490.html b/dir_90283ce059e2353638303443fc5ae490.html new file mode 100644 index 00000000..1f56d826 --- /dev/null +++ b/dir_90283ce059e2353638303443fc5ae490.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/PathFinding Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PathFinding Directory Reference
+
+
+ + + + +

+Files

 DominatingThetaPath.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_909597452498ddce8c7611c449df4cc5.html b/dir_909597452498ddce8c7611c449df4cc5.html new file mode 100644 index 00000000..673d4331 --- /dev/null +++ b/dir_909597452498ddce8c7611c449df4cc5.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Networks Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Networks Directory Reference
+
+
+ + + + + + +

+Files

 GenerationStrategy.hpp
 
 PowerGrid.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_ab830505b5c814a33a041e231ee5333a.html b/dir_ab830505b5c814a33a041e231ee5333a.html new file mode 100644 index 00000000..bc81420d --- /dev/null +++ b/dir_ab830505b5c814a33a041e231ee5333a.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/MathematicalModel/Callbacks Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Callbacks Directory Reference
+
+
+ + + + +

+Files

 CallbackEmpty.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_afbf3e043cd0116a31270be68b676f2f.html b/dir_afbf3e043cd0116a31270be68b676f2f.html new file mode 100644 index 00000000..7e9d7ed4 --- /dev/null +++ b/dir_afbf3e043cd0116a31270be68b676f2f.html @@ -0,0 +1,101 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Container/Queues Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Queues Directory Reference
+
+
+ + + + + + + + + + + + + + +

+Files

 BinaryHeap.hpp
 
 Bucket.hpp
 
 MappingBinaryHeap.hpp
 
 PriorityQueue.hpp
 
 Queue.hpp
 
 StdQueue.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_b6ecd118aab832b9b1a8edd8b6d82827.html b/dir_b6ecd118aab832b9b1a8edd8b6d82827.html new file mode 100644 index 00000000..f900ac84 --- /dev/null +++ b/dir_b6ecd118aab832b9b1a8edd8b6d82827.html @@ -0,0 +1,96 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/MathematicalModel Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
MathematicalModel Directory Reference
+
+
+ + + + +

+Directories

 Callbacks
 
+ + + +

+Files

 Types.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_bcf637cda62e02e2898dbf99b81d0dfc.html b/dir_bcf637cda62e02e2898dbf99b81d0dfc.html new file mode 100644 index 00000000..173494fd --- /dev/null +++ b/dir_bcf637cda62e02e2898dbf99b81d0dfc.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Helper Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Helper Directory Reference
+
+
+ + + + +

+Files

 DataValidation.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_c375ec6104647626e6047af7564c08d0.html b/dir_c375ec6104647626e6047af7564c08d0.html new file mode 100644 index 00000000..cbfc36e5 --- /dev/null +++ b/dir_c375ec6104647626e6047af7564c08d0.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/Algorithms/Centralities Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Centralities Directory Reference
+
+
+ + + + + + +

+Files

 BetweennessCentrality.hpp
 
 GeneratorBasedBetweennessCentrality.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_cab52edb0a880aba27eada31817ee90d.html b/dir_cab52edb0a880aba27eada31817ee90d.html new file mode 100644 index 00000000..88f2e0d5 --- /dev/null +++ b/dir_cab52edb0a880aba27eada31817ee90d.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
IO Directory Reference
+
+
+ + + + + + + + + + + + + + +

+Directories

 Appearance
 
 Helper
 
 Parser
 
 Statistics
 
 Wrapper
 
 Writer
 
+ + + +

+Files

 PowerGridIO.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_d44c64559bbebec7f509842c48db8b23.html b/dir_d44c64559bbebec7f509842c48db8b23.html new file mode 100644 index 00000000..2922b315 --- /dev/null +++ b/dir_d44c64559bbebec7f509842c48db8b23.html @@ -0,0 +1,101 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
include Directory Reference
+
+
+ + + + + + + + + + + + + + +

+Directories

 Algorithms
 
 Auxiliary
 
 DataStructures
 
 Exceptions
 
 IO
 
 MathematicalModel
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_da326e167cd4be868fa4b04cf9ff4615.html b/dir_da326e167cd4be868fa4b04cf9ff4615.html new file mode 100644 index 00000000..58c07245 --- /dev/null +++ b/dir_da326e167cd4be868fa4b04cf9ff4615.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
DataStructures Directory Reference
+
+
+ + + + + + + + + + + + + + +

+Directories

 Container
 
 Graphs
 
 Iterators
 
 Labels
 
 Networks
 
 Views
 
+ + + +

+Files

 Bound.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_ddeb7ec241953004457f8e8beb009b63.html b/dir_ddeb7ec241953004457f8e8beb009b63.html new file mode 100644 index 00000000..6da0ea8f --- /dev/null +++ b/dir_ddeb7ec241953004457f8e8beb009b63.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/DataStructures/Graphs Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Graphs Directory Reference
+
+
+ + + + + + +

+Directories

 Edges
 
 Vertices
 
+ + + + + + + + + + + +

+Files

 BlockCutTree.hpp
 
 DynamicGraph.hpp
 
 StaticGraph.hpp
 
 Subgraph.hpp
 
 Type.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_e434f13170dc2d405b7e0ad252778e4a.html b/dir_e434f13170dc2d405b7e0ad252778e4a.html new file mode 100644 index 00000000..cf41e3ce --- /dev/null +++ b/dir_e434f13170dc2d405b7e0ad252778e4a.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): include/IO/Writer Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Writer Directory Reference
+
+
+ + + + +

+Files

 GeojsonWriter.hpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/dir_fae119eb913a40fe8ed97cde8b98911e.html b/dir_fae119eb913a40fe8ed97cde8b98911e.html new file mode 100644 index 00000000..cbe954f5 --- /dev/null +++ b/dir_fae119eb913a40fe8ed97cde8b98911e.html @@ -0,0 +1,96 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/IO Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
IO Directory Reference
+
+
+ + + + +

+Directories

 Appearance
 
+ + + +

+Files

 PowerGridIO.cpp
 
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/doc.svg b/doc.svg new file mode 100644 index 00000000..0b928a53 --- /dev/null +++ b/doc.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/docd.svg b/docd.svg new file mode 100644 index 00000000..ac18b275 --- /dev/null +++ b/docd.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/doxygen.css b/doxygen.css new file mode 100644 index 00000000..009a9b55 --- /dev/null +++ b/doxygen.css @@ -0,0 +1,2045 @@ +/* The standard CSS for doxygen 1.9.8*/ + +html { +/* page base colors */ +--page-background-color: white; +--page-foreground-color: black; +--page-link-color: #3D578C; +--page-visited-link-color: #4665A2; + +/* index */ +--index-odd-item-bg-color: #F8F9FC; +--index-even-item-bg-color: white; +--index-header-color: black; +--index-separator-color: #A0A0A0; + +/* header */ +--header-background-color: #F9FAFC; +--header-separator-color: #C4CFE5; +--header-gradient-image: url('nav_h.png'); +--group-header-separator-color: #879ECB; +--group-header-color: #354C7B; +--inherit-header-color: gray; + +--footer-foreground-color: #2A3D61; +--footer-logo-width: 104px; +--citation-label-color: #334975; +--glow-color: cyan; + +--title-background-color: white; +--title-separator-color: #5373B4; +--directory-separator-color: #9CAFD4; +--separator-color: #4A6AAA; + +--blockquote-background-color: #F7F8FB; +--blockquote-border-color: #9CAFD4; + +--scrollbar-thumb-color: #9CAFD4; +--scrollbar-background-color: #F9FAFC; + +--icon-background-color: #728DC1; +--icon-foreground-color: white; +--icon-doc-image: url('doc.svg'); +--icon-folder-open-image: url('folderopen.svg'); +--icon-folder-closed-image: url('folderclosed.svg'); + +/* brief member declaration list */ +--memdecl-background-color: #F9FAFC; +--memdecl-separator-color: #DEE4F0; +--memdecl-foreground-color: #555; +--memdecl-template-color: #4665A2; + +/* detailed member list */ +--memdef-border-color: #A8B8D9; +--memdef-title-background-color: #E2E8F2; +--memdef-title-gradient-image: url('nav_f.png'); +--memdef-proto-background-color: #DFE5F1; +--memdef-proto-text-color: #253555; +--memdef-proto-text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); +--memdef-doc-background-color: white; +--memdef-param-name-color: #602020; +--memdef-template-color: #4665A2; + +/* tables */ +--table-cell-border-color: #2D4068; +--table-header-background-color: #374F7F; +--table-header-foreground-color: #FFFFFF; + +/* labels */ +--label-background-color: #728DC1; +--label-left-top-border-color: #5373B4; +--label-right-bottom-border-color: #C4CFE5; +--label-foreground-color: white; + +/** navigation bar/tree/menu */ +--nav-background-color: #F9FAFC; +--nav-foreground-color: #364D7C; +--nav-gradient-image: url('tab_b.png'); +--nav-gradient-hover-image: url('tab_h.png'); +--nav-gradient-active-image: url('tab_a.png'); +--nav-gradient-active-image-parent: url("../tab_a.png"); +--nav-separator-image: url('tab_s.png'); +--nav-breadcrumb-image: url('bc_s.png'); +--nav-breadcrumb-border-color: #C2CDE4; +--nav-splitbar-image: url('splitbar.png'); +--nav-font-size-level1: 13px; +--nav-font-size-level2: 10px; +--nav-font-size-level3: 9px; +--nav-text-normal-color: #283A5D; +--nav-text-hover-color: white; +--nav-text-active-color: white; +--nav-text-normal-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); +--nav-text-hover-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); +--nav-text-active-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); +--nav-menu-button-color: #364D7C; +--nav-menu-background-color: white; +--nav-menu-foreground-color: #555555; +--nav-menu-toggle-color: rgba(255, 255, 255, 0.5); +--nav-arrow-color: #9CAFD4; +--nav-arrow-selected-color: #9CAFD4; + +/* table of contents */ +--toc-background-color: #F4F6FA; +--toc-border-color: #D8DFEE; +--toc-header-color: #4665A2; +--toc-down-arrow-image: url("data:image/svg+xml;utf8,&%238595;"); + +/** search field */ +--search-background-color: white; +--search-foreground-color: #909090; +--search-magnification-image: url('mag.svg'); +--search-magnification-select-image: url('mag_sel.svg'); +--search-active-color: black; +--search-filter-background-color: #F9FAFC; +--search-filter-foreground-color: black; +--search-filter-border-color: #90A5CE; +--search-filter-highlight-text-color: white; +--search-filter-highlight-bg-color: #3D578C; +--search-results-foreground-color: #425E97; +--search-results-background-color: #EEF1F7; +--search-results-border-color: black; +--search-box-shadow: inset 0.5px 0.5px 3px 0px #555; + +/** code fragments */ +--code-keyword-color: #008000; +--code-type-keyword-color: #604020; +--code-flow-keyword-color: #E08000; +--code-comment-color: #800000; +--code-preprocessor-color: #806020; +--code-string-literal-color: #002080; +--code-char-literal-color: #008080; +--code-xml-cdata-color: black; +--code-vhdl-digit-color: #FF00FF; +--code-vhdl-char-color: #000000; +--code-vhdl-keyword-color: #700070; +--code-vhdl-logic-color: #FF0000; +--code-link-color: #4665A2; +--code-external-link-color: #4665A2; +--fragment-foreground-color: black; +--fragment-background-color: #FBFCFD; +--fragment-border-color: #C4CFE5; +--fragment-lineno-border-color: #00FF00; +--fragment-lineno-background-color: #E8E8E8; +--fragment-lineno-foreground-color: black; +--fragment-lineno-link-fg-color: #4665A2; +--fragment-lineno-link-bg-color: #D8D8D8; +--fragment-lineno-link-hover-fg-color: #4665A2; +--fragment-lineno-link-hover-bg-color: #C8C8C8; +--tooltip-foreground-color: black; +--tooltip-background-color: white; +--tooltip-border-color: gray; +--tooltip-doc-color: grey; +--tooltip-declaration-color: #006318; +--tooltip-link-color: #4665A2; +--tooltip-shadow: 1px 1px 7px gray; +--fold-line-color: #808080; +--fold-minus-image: url('minus.svg'); +--fold-plus-image: url('plus.svg'); +--fold-minus-image-relpath: url('../../minus.svg'); +--fold-plus-image-relpath: url('../../plus.svg'); + +/** font-family */ +--font-family-normal: Roboto,sans-serif; +--font-family-monospace: 'JetBrains Mono',Consolas,Monaco,'Andale Mono','Ubuntu Mono',monospace,fixed; +--font-family-nav: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; +--font-family-title: Tahoma,Arial,sans-serif; +--font-family-toc: Verdana,'DejaVu Sans',Geneva,sans-serif; +--font-family-search: Arial,Verdana,sans-serif; +--font-family-icon: Arial,Helvetica; +--font-family-tooltip: Roboto,sans-serif; + +} + +@media (prefers-color-scheme: dark) { + html:not(.dark-mode) { + color-scheme: dark; + +/* page base colors */ +--page-background-color: black; +--page-foreground-color: #C9D1D9; +--page-link-color: #90A5CE; +--page-visited-link-color: #A3B4D7; + +/* index */ +--index-odd-item-bg-color: #0B101A; +--index-even-item-bg-color: black; +--index-header-color: #C4CFE5; +--index-separator-color: #334975; + +/* header */ +--header-background-color: #070B11; +--header-separator-color: #141C2E; +--header-gradient-image: url('nav_hd.png'); +--group-header-separator-color: #283A5D; +--group-header-color: #90A5CE; +--inherit-header-color: #A0A0A0; + +--footer-foreground-color: #5B7AB7; +--footer-logo-width: 60px; +--citation-label-color: #90A5CE; +--glow-color: cyan; + +--title-background-color: #090D16; +--title-separator-color: #354C79; +--directory-separator-color: #283A5D; +--separator-color: #283A5D; + +--blockquote-background-color: #101826; +--blockquote-border-color: #283A5D; + +--scrollbar-thumb-color: #283A5D; +--scrollbar-background-color: #070B11; + +--icon-background-color: #334975; +--icon-foreground-color: #C4CFE5; +--icon-doc-image: url('docd.svg'); +--icon-folder-open-image: url('folderopend.svg'); +--icon-folder-closed-image: url('folderclosedd.svg'); + +/* brief member declaration list */ +--memdecl-background-color: #0B101A; +--memdecl-separator-color: #2C3F65; +--memdecl-foreground-color: #BBB; +--memdecl-template-color: #7C95C6; + +/* detailed member list */ +--memdef-border-color: #233250; +--memdef-title-background-color: #1B2840; +--memdef-title-gradient-image: url('nav_fd.png'); +--memdef-proto-background-color: #19243A; +--memdef-proto-text-color: #9DB0D4; +--memdef-proto-text-shadow: 0px 1px 1px rgba(0, 0, 0, 0.9); +--memdef-doc-background-color: black; +--memdef-param-name-color: #D28757; +--memdef-template-color: #7C95C6; + +/* tables */ +--table-cell-border-color: #283A5D; +--table-header-background-color: #283A5D; +--table-header-foreground-color: #C4CFE5; + +/* labels */ +--label-background-color: #354C7B; +--label-left-top-border-color: #4665A2; +--label-right-bottom-border-color: #283A5D; +--label-foreground-color: #CCCCCC; + +/** navigation bar/tree/menu */ +--nav-background-color: #101826; +--nav-foreground-color: #364D7C; +--nav-gradient-image: url('tab_bd.png'); +--nav-gradient-hover-image: url('tab_hd.png'); +--nav-gradient-active-image: url('tab_ad.png'); +--nav-gradient-active-image-parent: url("../tab_ad.png"); +--nav-separator-image: url('tab_sd.png'); +--nav-breadcrumb-image: url('bc_sd.png'); +--nav-breadcrumb-border-color: #2A3D61; +--nav-splitbar-image: url('splitbard.png'); +--nav-font-size-level1: 13px; +--nav-font-size-level2: 10px; +--nav-font-size-level3: 9px; +--nav-text-normal-color: #B6C4DF; +--nav-text-hover-color: #DCE2EF; +--nav-text-active-color: #DCE2EF; +--nav-text-normal-shadow: 0px 1px 1px black; +--nav-text-hover-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); +--nav-text-active-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); +--nav-menu-button-color: #B6C4DF; +--nav-menu-background-color: #05070C; +--nav-menu-foreground-color: #BBBBBB; +--nav-menu-toggle-color: rgba(255, 255, 255, 0.2); +--nav-arrow-color: #334975; +--nav-arrow-selected-color: #90A5CE; + +/* table of contents */ +--toc-background-color: #151E30; +--toc-border-color: #202E4A; +--toc-header-color: #A3B4D7; +--toc-down-arrow-image: url("data:image/svg+xml;utf8,&%238595;"); + +/** search field */ +--search-background-color: black; +--search-foreground-color: #C5C5C5; +--search-magnification-image: url('mag_d.svg'); +--search-magnification-select-image: url('mag_seld.svg'); +--search-active-color: #C5C5C5; +--search-filter-background-color: #101826; +--search-filter-foreground-color: #90A5CE; +--search-filter-border-color: #7C95C6; +--search-filter-highlight-text-color: #BCC9E2; +--search-filter-highlight-bg-color: #283A5D; +--search-results-background-color: #101826; +--search-results-foreground-color: #90A5CE; +--search-results-border-color: #7C95C6; +--search-box-shadow: inset 0.5px 0.5px 3px 0px #2F436C; + +/** code fragments */ +--code-keyword-color: #CC99CD; +--code-type-keyword-color: #AB99CD; +--code-flow-keyword-color: #E08000; +--code-comment-color: #717790; +--code-preprocessor-color: #65CABE; +--code-string-literal-color: #7EC699; +--code-char-literal-color: #00E0F0; +--code-xml-cdata-color: #C9D1D9; +--code-vhdl-digit-color: #FF00FF; +--code-vhdl-char-color: #C0C0C0; +--code-vhdl-keyword-color: #CF53C9; +--code-vhdl-logic-color: #FF0000; +--code-link-color: #79C0FF; +--code-external-link-color: #79C0FF; +--fragment-foreground-color: #C9D1D9; +--fragment-background-color: black; +--fragment-border-color: #30363D; +--fragment-lineno-border-color: #30363D; +--fragment-lineno-background-color: black; +--fragment-lineno-foreground-color: #6E7681; +--fragment-lineno-link-fg-color: #6E7681; +--fragment-lineno-link-bg-color: #303030; +--fragment-lineno-link-hover-fg-color: #8E96A1; +--fragment-lineno-link-hover-bg-color: #505050; +--tooltip-foreground-color: #C9D1D9; +--tooltip-background-color: #202020; +--tooltip-border-color: #C9D1D9; +--tooltip-doc-color: #D9E1E9; +--tooltip-declaration-color: #20C348; +--tooltip-link-color: #79C0FF; +--tooltip-shadow: none; +--fold-line-color: #808080; +--fold-minus-image: url('minusd.svg'); +--fold-plus-image: url('plusd.svg'); +--fold-minus-image-relpath: url('../../minusd.svg'); +--fold-plus-image-relpath: url('../../plusd.svg'); + +/** font-family */ +--font-family-normal: Roboto,sans-serif; +--font-family-monospace: 'JetBrains Mono',Consolas,Monaco,'Andale Mono','Ubuntu Mono',monospace,fixed; +--font-family-nav: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; +--font-family-title: Tahoma,Arial,sans-serif; +--font-family-toc: Verdana,'DejaVu Sans',Geneva,sans-serif; +--font-family-search: Arial,Verdana,sans-serif; +--font-family-icon: Arial,Helvetica; +--font-family-tooltip: Roboto,sans-serif; + +}} +body { + background-color: var(--page-background-color); + color: var(--page-foreground-color); +} + +body, table, div, p, dl { + font-weight: 400; + font-size: 14px; + font-family: var(--font-family-normal); + line-height: 22px; +} + +/* @group Heading Levels */ + +.title { + font-weight: 400; + font-size: 14px; + font-family: var(--font-family-normal); + line-height: 28px; + font-size: 150%; + font-weight: bold; + margin: 10px 2px; +} + +h1.groupheader { + font-size: 150%; +} + +h2.groupheader { + border-bottom: 1px solid var(--group-header-separator-color); + color: var(--group-header-color); + font-size: 150%; + font-weight: normal; + margin-top: 1.75em; + padding-top: 8px; + padding-bottom: 4px; + width: 100%; +} + +h3.groupheader { + font-size: 100%; +} + +h1, h2, h3, h4, h5, h6 { + -webkit-transition: text-shadow 0.5s linear; + -moz-transition: text-shadow 0.5s linear; + -ms-transition: text-shadow 0.5s linear; + -o-transition: text-shadow 0.5s linear; + transition: text-shadow 0.5s linear; + margin-right: 15px; +} + +h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow { + text-shadow: 0 0 15px var(--glow-color); +} + +dt { + font-weight: bold; +} + +p.startli, p.startdd { + margin-top: 2px; +} + +th p.starttd, th p.intertd, th p.endtd { + font-size: 100%; + font-weight: 700; +} + +p.starttd { + margin-top: 0px; +} + +p.endli { + margin-bottom: 0px; +} + +p.enddd { + margin-bottom: 4px; +} + +p.endtd { + margin-bottom: 2px; +} + +p.interli { +} + +p.interdd { +} + +p.intertd { +} + +/* @end */ + +caption { + font-weight: bold; +} + +span.legend { + font-size: 70%; + text-align: center; +} + +h3.version { + font-size: 90%; + text-align: center; +} + +div.navtab { + padding-right: 15px; + text-align: right; + line-height: 110%; +} + +div.navtab table { + border-spacing: 0; +} + +td.navtab { + padding-right: 6px; + padding-left: 6px; +} + +td.navtabHL { + background-image: var(--nav-gradient-active-image); + background-repeat:repeat-x; + padding-right: 6px; + padding-left: 6px; +} + +td.navtabHL a, td.navtabHL a:visited { + color: var(--nav-text-hover-color); + text-shadow: var(--nav-text-hover-shadow); +} + +a.navtab { + font-weight: bold; +} + +div.qindex{ + text-align: center; + width: 100%; + line-height: 140%; + font-size: 130%; + color: var(--index-separator-color); +} + +#main-menu a:focus { + outline: auto; + z-index: 10; + position: relative; +} + +dt.alphachar{ + font-size: 180%; + font-weight: bold; +} + +.alphachar a{ + color: var(--index-header-color); +} + +.alphachar a:hover, .alphachar a:visited{ + text-decoration: none; +} + +.classindex dl { + padding: 25px; + column-count:1 +} + +.classindex dd { + display:inline-block; + margin-left: 50px; + width: 90%; + line-height: 1.15em; +} + +.classindex dl.even { + background-color: var(--index-even-item-bg-color); +} + +.classindex dl.odd { + background-color: var(--index-odd-item-bg-color); +} + +@media(min-width: 1120px) { + .classindex dl { + column-count:2 + } +} + +@media(min-width: 1320px) { + .classindex dl { + column-count:3 + } +} + + +/* @group Link Styling */ + +a { + color: var(--page-link-color); + font-weight: normal; + text-decoration: none; +} + +.contents a:visited { + color: var(--page-visited-link-color); +} + +a:hover { + text-decoration: underline; +} + +a.el { + font-weight: bold; +} + +a.elRef { +} + +a.code, a.code:visited, a.line, a.line:visited { + color: var(--code-link-color); +} + +a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited { + color: var(--code-external-link-color); +} + +a.code.hl_class { /* style for links to class names in code snippets */ } +a.code.hl_struct { /* style for links to struct names in code snippets */ } +a.code.hl_union { /* style for links to union names in code snippets */ } +a.code.hl_interface { /* style for links to interface names in code snippets */ } +a.code.hl_protocol { /* style for links to protocol names in code snippets */ } +a.code.hl_category { /* style for links to category names in code snippets */ } +a.code.hl_exception { /* style for links to exception names in code snippets */ } +a.code.hl_service { /* style for links to service names in code snippets */ } +a.code.hl_singleton { /* style for links to singleton names in code snippets */ } +a.code.hl_concept { /* style for links to concept names in code snippets */ } +a.code.hl_namespace { /* style for links to namespace names in code snippets */ } +a.code.hl_package { /* style for links to package names in code snippets */ } +a.code.hl_define { /* style for links to macro names in code snippets */ } +a.code.hl_function { /* style for links to function names in code snippets */ } +a.code.hl_variable { /* style for links to variable names in code snippets */ } +a.code.hl_typedef { /* style for links to typedef names in code snippets */ } +a.code.hl_enumvalue { /* style for links to enum value names in code snippets */ } +a.code.hl_enumeration { /* style for links to enumeration names in code snippets */ } +a.code.hl_signal { /* style for links to Qt signal names in code snippets */ } +a.code.hl_slot { /* style for links to Qt slot names in code snippets */ } +a.code.hl_friend { /* style for links to friend names in code snippets */ } +a.code.hl_dcop { /* style for links to KDE3 DCOP names in code snippets */ } +a.code.hl_property { /* style for links to property names in code snippets */ } +a.code.hl_event { /* style for links to event names in code snippets */ } +a.code.hl_sequence { /* style for links to sequence names in code snippets */ } +a.code.hl_dictionary { /* style for links to dictionary names in code snippets */ } + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +ul { + overflow: visible; +} + +ul.multicol { + -moz-column-gap: 1em; + -webkit-column-gap: 1em; + column-gap: 1em; + -moz-column-count: 3; + -webkit-column-count: 3; + column-count: 3; + list-style-type: none; +} + +#side-nav ul { + overflow: visible; /* reset ul rule for scroll bar in GENERATE_TREEVIEW window */ +} + +#main-nav ul { + overflow: visible; /* reset ul rule for the navigation bar drop down lists */ +} + +.fragment { + text-align: left; + direction: ltr; + overflow-x: auto; /*Fixed: fragment lines overlap floating elements*/ + overflow-y: hidden; +} + +pre.fragment { + border: 1px solid var(--fragment-border-color); + background-color: var(--fragment-background-color); + color: var(--fragment-foreground-color); + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: var(--font-family-monospace); + font-size: 105%; +} + +div.fragment { + padding: 0 0 1px 0; /*Fixed: last line underline overlap border*/ + margin: 4px 8px 4px 2px; + color: var(--fragment-foreground-color); + background-color: var(--fragment-background-color); + border: 1px solid var(--fragment-border-color); +} + +div.line { + font-family: var(--font-family-monospace); + font-size: 13px; + min-height: 13px; + line-height: 1.2; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +div.line:after { + content:"\000A"; + white-space: pre; +} + +div.line.glow { + background-color: var(--glow-color); + box-shadow: 0 0 10px var(--glow-color); +} + +span.fold { + margin-left: 5px; + margin-right: 1px; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; + display: inline-block; + width: 12px; + height: 12px; + background-repeat:no-repeat; + background-position:center; +} + +span.lineno { + padding-right: 4px; + margin-right: 9px; + text-align: right; + border-right: 2px solid var(--fragment-lineno-border-color); + color: var(--fragment-lineno-foreground-color); + background-color: var(--fragment-lineno-background-color); + white-space: pre; +} +span.lineno a, span.lineno a:visited { + color: var(--fragment-lineno-link-fg-color); + background-color: var(--fragment-lineno-link-bg-color); +} + +span.lineno a:hover { + color: var(--fragment-lineno-link-hover-fg-color); + background-color: var(--fragment-lineno-link-hover-bg-color); +} + +.lineno { + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +div.classindex ul { + list-style: none; + padding-left: 0; +} + +div.classindex span.ai { + display: inline-block; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +body { + color: var(--page-foreground-color); + margin: 0; +} + +div.contents { + margin-top: 10px; + margin-left: 12px; + margin-right: 8px; +} + +p.formulaDsp { + text-align: center; +} + +img.dark-mode-visible { + display: none; +} +img.light-mode-visible { + display: none; +} + +img.formulaDsp { + +} + +img.formulaInl, img.inline { + vertical-align: middle; +} + +div.center { + text-align: center; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; +} + +div.center img { + border: 0px; +} + +address.footer { + text-align: right; + padding-right: 12px; +} + +img.footer { + border: 0px; + vertical-align: middle; + width: var(--footer-logo-width); +} + +.compoundTemplParams { + color: var(--memdecl-template-color); + font-size: 80%; + line-height: 120%; +} + +/* @group Code Colorization */ + +span.keyword { + color: var(--code-keyword-color); +} + +span.keywordtype { + color: var(--code-type-keyword-color); +} + +span.keywordflow { + color: var(--code-flow-keyword-color); +} + +span.comment { + color: var(--code-comment-color); +} + +span.preprocessor { + color: var(--code-preprocessor-color); +} + +span.stringliteral { + color: var(--code-string-literal-color); +} + +span.charliteral { + color: var(--code-char-literal-color); +} + +span.xmlcdata { + color: var(--code-xml-cdata-color); +} + +span.vhdldigit { + color: var(--code-vhdl-digit-color); +} + +span.vhdlchar { + color: var(--code-vhdl-char-color); +} + +span.vhdlkeyword { + color: var(--code-vhdl-keyword-color); +} + +span.vhdllogic { + color: var(--code-vhdl-logic-color); +} + +blockquote { + background-color: var(--blockquote-background-color); + border-left: 2px solid var(--blockquote-border-color); + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + +/* @end */ + +td.tiny { + font-size: 75%; +} + +.dirtab { + padding: 4px; + border-collapse: collapse; + border: 1px solid var(--table-cell-border-color); +} + +th.dirtab { + background-color: var(--table-header-background-color); + color: var(--table-header-foreground-color); + font-weight: bold; +} + +hr { + height: 0px; + border: none; + border-top: 1px solid var(--separator-color); +} + +hr.footer { + height: 1px; +} + +/* @group Member Descriptions */ + +table.memberdecls { + border-spacing: 0px; + padding: 0px; +} + +.memberdecls td, .fieldtable tr { + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +.memberdecls td.glow, .fieldtable tr.glow { + background-color: var(--glow-color); + box-shadow: 0 0 15px var(--glow-color); +} + +.mdescLeft, .mdescRight, +.memItemLeft, .memItemRight, +.memTemplItemLeft, .memTemplItemRight, .memTemplParams { + background-color: var(--memdecl-background-color); + border: none; + margin: 4px; + padding: 1px 0 0 8px; +} + +.mdescLeft, .mdescRight { + padding: 0px 8px 4px 8px; + color: var(--memdecl-foreground-color); +} + +.memSeparator { + border-bottom: 1px solid var(--memdecl-separator-color); + line-height: 1px; + margin: 0px; + padding: 0px; +} + +.memItemLeft, .memTemplItemLeft { + white-space: nowrap; +} + +.memItemRight, .memTemplItemRight { + width: 100%; +} + +.memTemplParams { + color: var(--memdecl-template-color); + white-space: nowrap; + font-size: 80%; +} + +/* @end */ + +/* @group Member Details */ + +/* Styles for detailed member documentation */ + +.memtitle { + padding: 8px; + border-top: 1px solid var(--memdef-border-color); + border-left: 1px solid var(--memdef-border-color); + border-right: 1px solid var(--memdef-border-color); + border-top-right-radius: 4px; + border-top-left-radius: 4px; + margin-bottom: -1px; + background-image: var(--memdef-title-gradient-image); + background-repeat: repeat-x; + background-color: var(--memdef-title-background-color); + line-height: 1.25; + font-weight: 300; + float:left; +} + +.permalink +{ + font-size: 65%; + display: inline-block; + vertical-align: middle; +} + +.memtemplate { + font-size: 80%; + color: var(--memdef-template-color); + font-weight: normal; + margin-left: 9px; +} + +.mempage { + width: 100%; +} + +.memitem { + padding: 0; + margin-bottom: 10px; + margin-right: 5px; + -webkit-transition: box-shadow 0.5s linear; + -moz-transition: box-shadow 0.5s linear; + -ms-transition: box-shadow 0.5s linear; + -o-transition: box-shadow 0.5s linear; + transition: box-shadow 0.5s linear; + display: table !important; + width: 100%; +} + +.memitem.glow { + box-shadow: 0 0 15px var(--glow-color); +} + +.memname { + font-weight: 400; + margin-left: 6px; +} + +.memname td { + vertical-align: bottom; +} + +.memproto, dl.reflist dt { + border-top: 1px solid var(--memdef-border-color); + border-left: 1px solid var(--memdef-border-color); + border-right: 1px solid var(--memdef-border-color); + padding: 6px 0px 6px 0px; + color: var(--memdef-proto-text-color); + font-weight: bold; + text-shadow: var(--memdef-proto-text-shadow); + background-color: var(--memdef-proto-background-color); + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + border-top-right-radius: 4px; +} + +.overload { + font-family: var(--font-family-monospace); + font-size: 65%; +} + +.memdoc, dl.reflist dd { + border-bottom: 1px solid var(--memdef-border-color); + border-left: 1px solid var(--memdef-border-color); + border-right: 1px solid var(--memdef-border-color); + padding: 6px 10px 2px 10px; + border-top-width: 0; + background-image:url('nav_g.png'); + background-repeat:repeat-x; + background-color: var(--memdef-doc-background-color); + /* opera specific markup */ + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + /* firefox specific markup */ + -moz-border-radius-bottomleft: 4px; + -moz-border-radius-bottomright: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + /* webkit specific markup */ + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +dl.reflist dt { + padding: 5px; +} + +dl.reflist dd { + margin: 0px 0px 10px 0px; + padding: 5px; +} + +.paramkey { + text-align: right; +} + +.paramtype { + white-space: nowrap; +} + +.paramname { + color: var(--memdef-param-name-color); + white-space: nowrap; +} +.paramname em { + font-style: normal; +} +.paramname code { + line-height: 14px; +} + +.params, .retval, .exception, .tparams { + margin-left: 0px; + padding-left: 0px; +} + +.params .paramname, .retval .paramname, .tparams .paramname, .exception .paramname { + font-weight: bold; + vertical-align: top; +} + +.params .paramtype, .tparams .paramtype { + font-style: italic; + vertical-align: top; +} + +.params .paramdir, .tparams .paramdir { + font-family: var(--font-family-monospace); + vertical-align: top; +} + +table.mlabels { + border-spacing: 0px; +} + +td.mlabels-left { + width: 100%; + padding: 0px; +} + +td.mlabels-right { + vertical-align: bottom; + padding: 0px; + white-space: nowrap; +} + +span.mlabels { + margin-left: 8px; +} + +span.mlabel { + background-color: var(--label-background-color); + border-top:1px solid var(--label-left-top-border-color); + border-left:1px solid var(--label-left-top-border-color); + border-right:1px solid var(--label-right-bottom-border-color); + border-bottom:1px solid var(--label-right-bottom-border-color); + text-shadow: none; + color: var(--label-foreground-color); + margin-right: 4px; + padding: 2px 3px; + border-radius: 3px; + font-size: 7pt; + white-space: nowrap; + vertical-align: middle; +} + + + +/* @end */ + +/* these are for tree view inside a (index) page */ + +div.directory { + margin: 10px 0px; + border-top: 1px solid var(--directory-separator-color); + border-bottom: 1px solid var(--directory-separator-color); + width: 100%; +} + +.directory table { + border-collapse:collapse; +} + +.directory td { + margin: 0px; + padding: 0px; + vertical-align: top; +} + +.directory td.entry { + white-space: nowrap; + padding-right: 6px; + padding-top: 3px; +} + +.directory td.entry a { + outline:none; +} + +.directory td.entry a img { + border: none; +} + +.directory td.desc { + width: 100%; + padding-left: 6px; + padding-right: 6px; + padding-top: 3px; + border-left: 1px solid rgba(0,0,0,0.05); +} + +.directory tr.odd { + padding-left: 6px; + background-color: var(--index-odd-item-bg-color); +} + +.directory tr.even { + padding-left: 6px; + background-color: var(--index-even-item-bg-color); +} + +.directory img { + vertical-align: -30%; +} + +.directory .levels { + white-space: nowrap; + width: 100%; + text-align: right; + font-size: 9pt; +} + +.directory .levels span { + cursor: pointer; + padding-left: 2px; + padding-right: 2px; + color: var(--page-link-color); +} + +.arrow { + color: var(--nav-arrow-color); + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + font-size: 80%; + display: inline-block; + width: 16px; + height: 22px; +} + +.icon { + font-family: var(--font-family-icon); + line-height: normal; + font-weight: bold; + font-size: 12px; + height: 14px; + width: 16px; + display: inline-block; + background-color: var(--icon-background-color); + color: var(--icon-foreground-color); + text-align: center; + border-radius: 4px; + margin-left: 2px; + margin-right: 2px; +} + +.icona { + width: 24px; + height: 22px; + display: inline-block; +} + +.iconfopen { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:var(--icon-folder-open-image); + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.iconfclosed { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:var(--icon-folder-closed-image); + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.icondoc { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:var(--icon-doc-image); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +/* @end */ + +div.dynheader { + margin-top: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +address { + font-style: normal; + color: var(--footer-foreground-color); +} + +table.doxtable caption { + caption-side: top; +} + +table.doxtable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.doxtable td, table.doxtable th { + border: 1px solid var(--table-cell-border-color); + padding: 3px 7px 2px; +} + +table.doxtable th { + background-color: var(--table-header-background-color); + color: var(--table-header-foreground-color); + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +table.fieldtable { + margin-bottom: 10px; + border: 1px solid var(--memdef-border-color); + border-spacing: 0px; + border-radius: 4px; + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); +} + +.fieldtable td, .fieldtable th { + padding: 3px 7px 2px; +} + +.fieldtable td.fieldtype, .fieldtable td.fieldname { + white-space: nowrap; + border-right: 1px solid var(--memdef-border-color); + border-bottom: 1px solid var(--memdef-border-color); + vertical-align: top; +} + +.fieldtable td.fieldname { + padding-top: 3px; +} + +.fieldtable td.fielddoc { + border-bottom: 1px solid var(--memdef-border-color); +} + +.fieldtable td.fielddoc p:first-child { + margin-top: 0px; +} + +.fieldtable td.fielddoc p:last-child { + margin-bottom: 2px; +} + +.fieldtable tr:last-child td { + border-bottom: none; +} + +.fieldtable th { + background-image: var(--memdef-title-gradient-image); + background-repeat:repeat-x; + background-color: var(--memdef-title-background-color); + font-size: 90%; + color: var(--memdef-proto-text-color); + padding-bottom: 4px; + padding-top: 5px; + text-align:left; + font-weight: 400; + border-top-left-radius: 4px; + border-top-right-radius: 4px; + border-bottom: 1px solid var(--memdef-border-color); +} + + +.tabsearch { + top: 0px; + left: 10px; + height: 36px; + background-image: var(--nav-gradient-image); + z-index: 101; + overflow: hidden; + font-size: 13px; +} + +.navpath ul +{ + font-size: 11px; + background-image: var(--nav-gradient-image); + background-repeat:repeat-x; + background-position: 0 -5px; + height:30px; + line-height:30px; + color:var(--nav-text-normal-color); + border:solid 1px var(--nav-breadcrumb-border-color); + overflow:hidden; + margin:0px; + padding:0px; +} + +.navpath li +{ + list-style-type:none; + float:left; + padding-left:10px; + padding-right:15px; + background-image:var(--nav-breadcrumb-image); + background-repeat:no-repeat; + background-position:right; + color: var(--nav-foreground-color); +} + +.navpath li.navelem a +{ + height:32px; + display:block; + text-decoration: none; + outline: none; + color: var(--nav-text-normal-color); + font-family: var(--font-family-nav); + text-shadow: var(--nav-text-normal-shadow); + text-decoration: none; +} + +.navpath li.navelem a:hover +{ + color: var(--nav-text-hover-color); + text-shadow: var(--nav-text-hover-shadow); +} + +.navpath li.footer +{ + list-style-type:none; + float:right; + padding-left:10px; + padding-right:15px; + background-image:none; + background-repeat:no-repeat; + background-position:right; + color: var(--footer-foreground-color); + font-size: 8pt; +} + + +div.summary +{ + float: right; + font-size: 8pt; + padding-right: 5px; + width: 50%; + text-align: right; +} + +div.summary a +{ + white-space: nowrap; +} + +table.classindex +{ + margin: 10px; + white-space: nowrap; + margin-left: 3%; + margin-right: 3%; + width: 94%; + border: 0; + border-spacing: 0; + padding: 0; +} + +div.ingroups +{ + font-size: 8pt; + width: 50%; + text-align: left; +} + +div.ingroups a +{ + white-space: nowrap; +} + +div.header +{ + background-image: var(--header-gradient-image); + background-repeat:repeat-x; + background-color: var(--header-background-color); + margin: 0px; + border-bottom: 1px solid var(--header-separator-color); +} + +div.headertitle +{ + padding: 5px 5px 5px 10px; +} + +.PageDocRTL-title div.headertitle { + text-align: right; + direction: rtl; +} + +dl { + padding: 0 0 0 0; +} + +/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug, dl.examples */ +dl.section { + margin-left: 0px; + padding-left: 0px; +} + +dl.note { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #D0C000; +} + +dl.warning, dl.attention { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #FF0000; +} + +dl.pre, dl.post, dl.invariant { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #00D000; +} + +dl.deprecated { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #505050; +} + +dl.todo { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #00C0E0; +} + +dl.test { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #3030E0; +} + +dl.bug { + margin-left: -7px; + padding-left: 3px; + border-left: 4px solid; + border-color: #C08050; +} + +dl.section dd { + margin-bottom: 6px; +} + + +#projectrow +{ + height: 56px; +} + +#projectlogo +{ + text-align: center; + vertical-align: bottom; + border-collapse: separate; +} + +#projectlogo img +{ + border: 0px none; +} + +#projectalign +{ + vertical-align: middle; + padding-left: 0.5em; +} + +#projectname +{ + font-size: 200%; + font-family: var(--font-family-title); + margin: 0px; + padding: 2px 0px; +} + +#projectbrief +{ + font-size: 90%; + font-family: var(--font-family-title); + margin: 0px; + padding: 0px; +} + +#projectnumber +{ + font-size: 50%; + font-family: 50% var(--font-family-title); + margin: 0px; + padding: 0px; +} + +#titlearea +{ + padding: 0px; + margin: 0px; + width: 100%; + border-bottom: 1px solid var(--title-separator-color); + background-color: var(--title-background-color); +} + +.image +{ + text-align: center; +} + +.dotgraph +{ + text-align: center; +} + +.mscgraph +{ + text-align: center; +} + +.plantumlgraph +{ + text-align: center; +} + +.diagraph +{ + text-align: center; +} + +.caption +{ + font-weight: bold; +} + +dl.citelist { + margin-bottom:50px; +} + +dl.citelist dt { + color:var(--citation-label-color); + float:left; + font-weight:bold; + margin-right:10px; + padding:5px; + text-align:right; + width:52px; +} + +dl.citelist dd { + margin:2px 0 2px 72px; + padding:5px 0; +} + +div.toc { + padding: 14px 25px; + background-color: var(--toc-background-color); + border: 1px solid var(--toc-border-color); + border-radius: 7px 7px 7px 7px; + float: right; + height: auto; + margin: 0 8px 10px 10px; + width: 200px; +} + +div.toc li { + background: var(--toc-down-arrow-image) no-repeat scroll 0 5px transparent; + font: 10px/1.2 var(--font-family-toc); + margin-top: 5px; + padding-left: 10px; + padding-top: 2px; +} + +div.toc h3 { + font: bold 12px/1.2 var(--font-family-toc); + color: var(--toc-header-color); + border-bottom: 0 none; + margin: 0; +} + +div.toc ul { + list-style: none outside none; + border: medium none; + padding: 0px; +} + +div.toc li.level1 { + margin-left: 0px; +} + +div.toc li.level2 { + margin-left: 15px; +} + +div.toc li.level3 { + margin-left: 15px; +} + +div.toc li.level4 { + margin-left: 15px; +} + +span.emoji { + /* font family used at the site: https://unicode.org/emoji/charts/full-emoji-list.html + * font-family: "Noto Color Emoji", "Apple Color Emoji", "Segoe UI Emoji", Times, Symbola, Aegyptus, Code2000, Code2001, Code2002, Musica, serif, LastResort; + */ +} + +span.obfuscator { + display: none; +} + +.inherit_header { + font-weight: bold; + color: var(--inherit-header-color); + cursor: pointer; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.inherit_header td { + padding: 6px 0px 2px 5px; +} + +.inherit { + display: none; +} + +tr.heading h2 { + margin-top: 12px; + margin-bottom: 4px; +} + +/* tooltip related style info */ + +.ttc { + position: absolute; + display: none; +} + +#powerTip { + cursor: default; + /*white-space: nowrap;*/ + color: var(--tooltip-foreground-color); + background-color: var(--tooltip-background-color); + border: 1px solid var(--tooltip-border-color); + border-radius: 4px 4px 4px 4px; + box-shadow: var(--tooltip-shadow); + display: none; + font-size: smaller; + max-width: 80%; + opacity: 0.9; + padding: 1ex 1em 1em; + position: absolute; + z-index: 2147483647; +} + +#powerTip div.ttdoc { + color: var(--tooltip-doc-color); + font-style: italic; +} + +#powerTip div.ttname a { + font-weight: bold; +} + +#powerTip a { + color: var(--tooltip-link-color); +} + +#powerTip div.ttname { + font-weight: bold; +} + +#powerTip div.ttdeci { + color: var(--tooltip-declaration-color); +} + +#powerTip div { + margin: 0px; + padding: 0px; + font-size: 12px; + font-family: var(--font-family-tooltip); + line-height: 16px; +} + +#powerTip:before, #powerTip:after { + content: ""; + position: absolute; + margin: 0px; +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.s:after, #powerTip.s:before, +#powerTip.w:after, #powerTip.w:before, +#powerTip.e:after, #powerTip.e:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.nw:after, #powerTip.nw:before, +#powerTip.sw:after, #powerTip.sw:before { + border: solid transparent; + content: " "; + height: 0; + width: 0; + position: absolute; +} + +#powerTip.n:after, #powerTip.s:after, +#powerTip.w:after, #powerTip.e:after, +#powerTip.nw:after, #powerTip.ne:after, +#powerTip.sw:after, #powerTip.se:after { + border-color: rgba(255, 255, 255, 0); +} + +#powerTip.n:before, #powerTip.s:before, +#powerTip.w:before, #powerTip.e:before, +#powerTip.nw:before, #powerTip.ne:before, +#powerTip.sw:before, #powerTip.se:before { + border-color: rgba(128, 128, 128, 0); +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.nw:after, #powerTip.nw:before { + top: 100%; +} + +#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after { + border-top-color: var(--tooltip-background-color); + border-width: 10px; + margin: 0px -10px; +} +#powerTip.n:before, #powerTip.ne:before, #powerTip.nw:before { + border-top-color: var(--tooltip-border-color); + border-width: 11px; + margin: 0px -11px; +} +#powerTip.n:after, #powerTip.n:before { + left: 50%; +} + +#powerTip.nw:after, #powerTip.nw:before { + right: 14px; +} + +#powerTip.ne:after, #powerTip.ne:before { + left: 14px; +} + +#powerTip.s:after, #powerTip.s:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.sw:after, #powerTip.sw:before { + bottom: 100%; +} + +#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after { + border-bottom-color: var(--tooltip-background-color); + border-width: 10px; + margin: 0px -10px; +} + +#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before { + border-bottom-color: var(--tooltip-border-color); + border-width: 11px; + margin: 0px -11px; +} + +#powerTip.s:after, #powerTip.s:before { + left: 50%; +} + +#powerTip.sw:after, #powerTip.sw:before { + right: 14px; +} + +#powerTip.se:after, #powerTip.se:before { + left: 14px; +} + +#powerTip.e:after, #powerTip.e:before { + left: 100%; +} +#powerTip.e:after { + border-left-color: var(--tooltip-border-color); + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.e:before { + border-left-color: var(--tooltip-border-color); + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +#powerTip.w:after, #powerTip.w:before { + right: 100%; +} +#powerTip.w:after { + border-right-color: var(--tooltip-border-color); + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.w:before { + border-right-color: var(--tooltip-border-color); + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +@media print +{ + #top { display: none; } + #side-nav { display: none; } + #nav-path { display: none; } + body { overflow:visible; } + h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } + .summary { display: none; } + .memitem { page-break-inside: avoid; } + #doc-content + { + margin-left:0 !important; + height:auto !important; + width:auto !important; + overflow:inherit; + display:inline; + } +} + +/* @group Markdown */ + +table.markdownTable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.markdownTable td, table.markdownTable th { + border: 1px solid var(--table-cell-border-color); + padding: 3px 7px 2px; +} + +table.markdownTable tr { +} + +th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone { + background-color: var(--table-header-background-color); + color: var(--table-header-foreground-color); + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +th.markdownTableHeadLeft, td.markdownTableBodyLeft { + text-align: left +} + +th.markdownTableHeadRight, td.markdownTableBodyRight { + text-align: right +} + +th.markdownTableHeadCenter, td.markdownTableBodyCenter { + text-align: center +} + +tt, code, kbd, samp +{ + display: inline-block; +} +/* @end */ + +u { + text-decoration: underline; +} + +details>summary { + list-style-type: none; +} + +details > summary::-webkit-details-marker { + display: none; +} + +details>summary::before { + content: "\25ba"; + padding-right:4px; + font-size: 80%; +} + +details[open]>summary::before { + content: "\25bc"; + padding-right:4px; + font-size: 80%; +} + +body { + scrollbar-color: var(--scrollbar-thumb-color) var(--scrollbar-background-color); +} + +::-webkit-scrollbar { + background-color: var(--scrollbar-background-color); + height: 12px; + width: 12px; +} +::-webkit-scrollbar-thumb { + border-radius: 6px; + box-shadow: inset 0 0 12px 12px var(--scrollbar-thumb-color); + border: solid 2px transparent; +} +::-webkit-scrollbar-corner { + background-color: var(--scrollbar-background-color); +} + diff --git a/doxygen.svg b/doxygen.svg new file mode 100644 index 00000000..79a76354 --- /dev/null +++ b/doxygen.svg @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynsections.js b/dynsections.js new file mode 100644 index 00000000..9b281563 --- /dev/null +++ b/dynsections.js @@ -0,0 +1,199 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file + */ +function toggleVisibility(linkObj) +{ + var base = $(linkObj).attr('id'); + var summary = $('#'+base+'-summary'); + var content = $('#'+base+'-content'); + var trigger = $('#'+base+'-trigger'); + var src=$(trigger).attr('src'); + if (content.is(':visible')===true) { + content.hide(); + summary.show(); + $(linkObj).addClass('closed').removeClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); + } else { + content.show(); + summary.hide(); + $(linkObj).removeClass('closed').addClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); + } + return false; +} + +function updateStripes() +{ + $('table.directory tr'). + removeClass('even').filter(':visible:even').addClass('even'); + $('table.directory tr'). + removeClass('odd').filter(':visible:odd').addClass('odd'); +} + +function toggleLevel(level) +{ + $('table.directory tr').each(function() { + var l = this.id.split('_').length-1; + var i = $('#img'+this.id.substring(3)); + var a = $('#arr'+this.id.substring(3)); + if (l'); + // add vertical lines to other rows + $('span[class=lineno]').not(':eq(0)').append(''); + // add toggle controls to lines with fold divs + $('div[class=foldopen]').each(function() { + // extract specific id to use + var id = $(this).attr('id').replace('foldopen',''); + // extract start and end foldable fragment attributes + var start = $(this).attr('data-start'); + var end = $(this).attr('data-end'); + // replace normal fold span with controls for the first line of a foldable fragment + $(this).find('span[class=fold]:first').replaceWith(''); + // append div for folded (closed) representation + $(this).after(''); + // extract the first line from the "open" section to represent closed content + var line = $(this).children().first().clone(); + // remove any glow that might still be active on the original line + $(line).removeClass('glow'); + if (start) { + // if line already ends with a start marker (e.g. trailing {), remove it + $(line).html($(line).html().replace(new RegExp('\\s*'+start+'\\s*$','g'),'')); + } + // replace minus with plus symbol + $(line).find('span[class=fold]').css('background-image',plusImg[relPath]); + // append ellipsis + $(line).append(' '+start+'…'+end); + // insert constructed line into closed div + $('#foldclosed'+id).html(line); + }); +} + +/* @license-end */ +$(document).ready(function() { + $('.code,.codeRef').each(function() { + $(this).data('powertip',$('#a'+$(this).attr('href').replace(/.*\//,'').replace(/[^a-z_A-Z0-9]/g,'_')).html()); + $.fn.powerTip.smartPlacementLists.s = [ 's', 'n', 'ne', 'se' ]; + $(this).powerTip({ placement: 's', smartPlacement: true, mouseOnToPopup: true }); + }); +}); diff --git a/files.html b/files.html new file mode 100644 index 00000000..544d1dd6 --- /dev/null +++ b/files.html @@ -0,0 +1,188 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): File List + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
File List
+
+
+
Here is a list of all documented files with brief descriptions:
+
[detail level 12345]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼ include
 ▼ Algorithms
 ▼ Centralities
 BetweennessCentrality.hpp
 GeneratorBasedBetweennessCentrality.hpp
 ▼ GraphTraversal
 ArticulationVertexDetection.hpp
 BreadthFirstSearch.hpp
 CycleDetection.hpp
 DepthFirstSearch.hpp
 Traversal.hpp
 ▼ PathFinding
 DominatingThetaPath.hpp
 ▼ SpanningTree
 Kruskal.hpp
 MST.hpp
 Prim.hpp
 BlockCutTreeTraversal.hpp
 ▼ Auxiliary
 Auxiliary.hpp
 Comparators.hpp
 Constants.hpp
 ContainerLoop.hpp
 ExecutionPolicy.hpp
 Timer.hpp
 Types.hpp
 ▼ DataStructures
 ▼ Container
 ► Queues
 DominationCriterion.hpp
 UnionFind.hpp
 ▼ Graphs
 ► Edges
 ► Vertices
 BlockCutTree.hpp
 DynamicGraph.hpp
 StaticGraph.hpp
 Subgraph.hpp
 Type.hpp
 ▼ Iterators
 DynamicGraphIterators.hpp
 GraphIterators.hpp
 OmittingIterator.hpp
 PowerGridIterators.hpp
 StaticGraphIterators.hpp
 ▼ Labels
 BucketElement.hpp
 Label.hpp
 SusceptanceNormLabel.hpp
 VoltageAngleDifferenceLabel.hpp
 ▼ Networks
 GenerationStrategy.hpp
 PowerGrid.hpp
 ▼ Views
 VectorView.hpp
 Bound.hpp
 ▼ Exceptions
 Assertions.hpp
 Exceptions.hpp
 ▼ IO
 ▼ Appearance
 Color.hpp
 Stroke.hpp
 ▼ Helper
 DataValidation.hpp
 ▼ Parser
 IeeeCdfMatlabParser.hpp
 PyPsaParser.hpp
 ▼ Statistics
 DtpRuntimeCollection.hpp
 DtpRuntimeRow.hpp
 SolverRuntimeCollection.hpp
 SolverRuntimeRow.hpp
 ▼ Wrapper
 Edge.hpp
 ▼ Writer
 GeojsonWriter.hpp
 PowerGridIO.hpp
 ▼ MathematicalModel
 ▼ Callbacks
 CallbackEmpty.hpp
 Types.hpp
 ▼ src
 ▼ IO
 ▼ Appearance
 Color.cpp
 PowerGridIO.cpp
 ▼ Runnables
 main.cpp
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/folderclosed.svg b/folderclosed.svg new file mode 100644 index 00000000..b04bed2e --- /dev/null +++ b/folderclosed.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/folderclosedd.svg b/folderclosedd.svg new file mode 100644 index 00000000..52f0166a --- /dev/null +++ b/folderclosedd.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/folderopen.svg b/folderopen.svg new file mode 100644 index 00000000..f6896dd2 --- /dev/null +++ b/folderopen.svg @@ -0,0 +1,17 @@ + + + + + + + + + + diff --git a/folderopend.svg b/folderopend.svg new file mode 100644 index 00000000..2d1f06e7 --- /dev/null +++ b/folderopend.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/functions.html b/functions.html new file mode 100644 index 00000000..53995c70 --- /dev/null +++ b/functions.html @@ -0,0 +1,194 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- a -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_b.html b/functions_b.html new file mode 100644 index 00000000..7d04dbfc --- /dev/null +++ b/functions_b.html @@ -0,0 +1,106 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- b -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_c.html b/functions_c.html new file mode 100644 index 00000000..bae05249 --- /dev/null +++ b/functions_c.html @@ -0,0 +1,109 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- c -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_d.html b/functions_d.html new file mode 100644 index 00000000..cafc8e9f --- /dev/null +++ b/functions_d.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- d -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_e.html b/functions_e.html new file mode 100644 index 00000000..cd335580 --- /dev/null +++ b/functions_e.html @@ -0,0 +1,115 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- e -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_enum.html b/functions_enum.html new file mode 100644 index 00000000..a7294721 --- /dev/null +++ b/functions_enum.html @@ -0,0 +1,81 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Enumerations + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented enums with links to the class documentation for each member:
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_f.html b/functions_f.html new file mode 100644 index 00000000..99518fc5 --- /dev/null +++ b/functions_f.html @@ -0,0 +1,130 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- f -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func.html b/functions_func.html new file mode 100644 index 00000000..45f01f70 --- /dev/null +++ b/functions_func.html @@ -0,0 +1,190 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- a -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_b.html b/functions_func_b.html new file mode 100644 index 00000000..21ae02cd --- /dev/null +++ b/functions_func_b.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- b -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_c.html b/functions_func_c.html new file mode 100644 index 00000000..e1397999 --- /dev/null +++ b/functions_func_c.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- c -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_d.html b/functions_func_d.html new file mode 100644 index 00000000..3ca1d9e8 --- /dev/null +++ b/functions_func_d.html @@ -0,0 +1,93 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- d -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_e.html b/functions_func_e.html new file mode 100644 index 00000000..c5fa4680 --- /dev/null +++ b/functions_func_e.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- e -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_f.html b/functions_func_f.html new file mode 100644 index 00000000..b4295d81 --- /dev/null +++ b/functions_func_f.html @@ -0,0 +1,117 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- f -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_g.html b/functions_func_g.html new file mode 100644 index 00000000..1d2f630a --- /dev/null +++ b/functions_func_g.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- g -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_h.html b/functions_func_h.html new file mode 100644 index 00000000..7f08dff7 --- /dev/null +++ b/functions_func_h.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- h -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_i.html b/functions_func_i.html new file mode 100644 index 00000000..7a5c2b86 --- /dev/null +++ b/functions_func_i.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- i -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_j.html b/functions_func_j.html new file mode 100644 index 00000000..f70d5ea1 --- /dev/null +++ b/functions_func_j.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- j -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_k.html b/functions_func_k.html new file mode 100644 index 00000000..9ec49a74 --- /dev/null +++ b/functions_func_k.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- k -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_l.html b/functions_func_l.html new file mode 100644 index 00000000..2bdfcf13 --- /dev/null +++ b/functions_func_l.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- l -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_m.html b/functions_func_m.html new file mode 100644 index 00000000..3a8ddf42 --- /dev/null +++ b/functions_func_m.html @@ -0,0 +1,105 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- m -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_n.html b/functions_func_n.html new file mode 100644 index 00000000..930b6fdd --- /dev/null +++ b/functions_func_n.html @@ -0,0 +1,99 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- n -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_o.html b/functions_func_o.html new file mode 100644 index 00000000..97e4fb4f --- /dev/null +++ b/functions_func_o.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- o -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_p.html b/functions_func_p.html new file mode 100644 index 00000000..2bd4c216 --- /dev/null +++ b/functions_func_p.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- p -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_q.html b/functions_func_q.html new file mode 100644 index 00000000..8d4f3481 --- /dev/null +++ b/functions_func_q.html @@ -0,0 +1,86 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- q -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_r.html b/functions_func_r.html new file mode 100644 index 00000000..35f0c5a6 --- /dev/null +++ b/functions_func_r.html @@ -0,0 +1,134 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- r -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_s.html b/functions_func_s.html new file mode 100644 index 00000000..65dd39d3 --- /dev/null +++ b/functions_func_s.html @@ -0,0 +1,109 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- s -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_t.html b/functions_func_t.html new file mode 100644 index 00000000..cd3de8b7 --- /dev/null +++ b/functions_func_t.html @@ -0,0 +1,104 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- t -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_u.html b/functions_func_u.html new file mode 100644 index 00000000..b0d3f564 --- /dev/null +++ b/functions_func_u.html @@ -0,0 +1,91 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- u -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_v.html b/functions_func_v.html new file mode 100644 index 00000000..e3c38f55 --- /dev/null +++ b/functions_func_v.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- v -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_w.html b/functions_func_w.html new file mode 100644 index 00000000..f14f8481 --- /dev/null +++ b/functions_func_w.html @@ -0,0 +1,110 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- w -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_z.html b/functions_func_z.html new file mode 100644 index 00000000..4981f24e --- /dev/null +++ b/functions_func_z.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- z -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_func_~.html b/functions_func_~.html new file mode 100644 index 00000000..958730a4 --- /dev/null +++ b/functions_func_~.html @@ -0,0 +1,87 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented functions with links to the class documentation for each member:
+ +

- ~ -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_g.html b/functions_g.html new file mode 100644 index 00000000..dd8b9cf4 --- /dev/null +++ b/functions_g.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- g -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_h.html b/functions_h.html new file mode 100644 index 00000000..a5fefc9e --- /dev/null +++ b/functions_h.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- h -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_i.html b/functions_i.html new file mode 100644 index 00000000..e7c60301 --- /dev/null +++ b/functions_i.html @@ -0,0 +1,111 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- i -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_j.html b/functions_j.html new file mode 100644 index 00000000..065afd95 --- /dev/null +++ b/functions_j.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- j -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_k.html b/functions_k.html new file mode 100644 index 00000000..a2049294 --- /dev/null +++ b/functions_k.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- k -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_l.html b/functions_l.html new file mode 100644 index 00000000..a22896b1 --- /dev/null +++ b/functions_l.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- l -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_m.html b/functions_m.html new file mode 100644 index 00000000..62028447 --- /dev/null +++ b/functions_m.html @@ -0,0 +1,118 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- m -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_n.html b/functions_n.html new file mode 100644 index 00000000..40d085d6 --- /dev/null +++ b/functions_n.html @@ -0,0 +1,128 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- n -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_o.html b/functions_o.html new file mode 100644 index 00000000..74e6e622 --- /dev/null +++ b/functions_o.html @@ -0,0 +1,103 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- o -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_p.html b/functions_p.html new file mode 100644 index 00000000..4eb5349c --- /dev/null +++ b/functions_p.html @@ -0,0 +1,113 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- p -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_q.html b/functions_q.html new file mode 100644 index 00000000..c22d946a --- /dev/null +++ b/functions_q.html @@ -0,0 +1,89 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- q -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_r.html b/functions_r.html new file mode 100644 index 00000000..dbdb4fbf --- /dev/null +++ b/functions_r.html @@ -0,0 +1,153 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- r -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_rela.html b/functions_rela.html new file mode 100644 index 00000000..5d073c9a --- /dev/null +++ b/functions_rela.html @@ -0,0 +1,96 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Related Symbols + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented related symbols with links to the class documentation for each member:
+ +

- e -

+ + +

- o -

+ + +

- s -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_s.html b/functions_s.html new file mode 100644 index 00000000..e450445d --- /dev/null +++ b/functions_s.html @@ -0,0 +1,123 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- s -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_t.html b/functions_t.html new file mode 100644 index 00000000..c61c5f35 --- /dev/null +++ b/functions_t.html @@ -0,0 +1,144 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- t -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_type.html b/functions_type.html new file mode 100644 index 00000000..0126ed21 --- /dev/null +++ b/functions_type.html @@ -0,0 +1,132 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Typedefs + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented typedefs with links to the class documentation for each member:
+ +

- d -

+ + +

- i -

+ + +

- p -

+ + +

- r -

+ + +

- t -

+ + +

- v -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_u.html b/functions_u.html new file mode 100644 index 00000000..7d742fe4 --- /dev/null +++ b/functions_u.html @@ -0,0 +1,94 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- u -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_v.html b/functions_v.html new file mode 100644 index 00000000..30528a67 --- /dev/null +++ b/functions_v.html @@ -0,0 +1,115 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- v -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars.html b/functions_vars.html new file mode 100644 index 00000000..cd09e50e --- /dev/null +++ b/functions_vars.html @@ -0,0 +1,86 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- a -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_b.html b/functions_vars_b.html new file mode 100644 index 00000000..3ae5efdc --- /dev/null +++ b/functions_vars_b.html @@ -0,0 +1,88 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- b -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_c.html b/functions_vars_c.html new file mode 100644 index 00000000..3535fe2d --- /dev/null +++ b/functions_vars_c.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- c -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_d.html b/functions_vars_d.html new file mode 100644 index 00000000..0ad53373 --- /dev/null +++ b/functions_vars_d.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- d -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_e.html b/functions_vars_e.html new file mode 100644 index 00000000..0c58431f --- /dev/null +++ b/functions_vars_e.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- e -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_f.html b/functions_vars_f.html new file mode 100644 index 00000000..eea254b1 --- /dev/null +++ b/functions_vars_f.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- f -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_g.html b/functions_vars_g.html new file mode 100644 index 00000000..384da1f6 --- /dev/null +++ b/functions_vars_g.html @@ -0,0 +1,90 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- g -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_i.html b/functions_vars_i.html new file mode 100644 index 00000000..6cf99f07 --- /dev/null +++ b/functions_vars_i.html @@ -0,0 +1,88 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- i -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_l.html b/functions_vars_l.html new file mode 100644 index 00000000..de29c30f --- /dev/null +++ b/functions_vars_l.html @@ -0,0 +1,89 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- l -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_m.html b/functions_vars_m.html new file mode 100644 index 00000000..34211a8f --- /dev/null +++ b/functions_vars_m.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- m -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_n.html b/functions_vars_n.html new file mode 100644 index 00000000..3778cf07 --- /dev/null +++ b/functions_vars_n.html @@ -0,0 +1,115 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- n -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_o.html b/functions_vars_o.html new file mode 100644 index 00000000..618d8e43 --- /dev/null +++ b/functions_vars_o.html @@ -0,0 +1,84 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- o -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_p.html b/functions_vars_p.html new file mode 100644 index 00000000..3f4aaca0 --- /dev/null +++ b/functions_vars_p.html @@ -0,0 +1,92 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- p -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_q.html b/functions_vars_q.html new file mode 100644 index 00000000..c0cc42de --- /dev/null +++ b/functions_vars_q.html @@ -0,0 +1,85 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- q -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_r.html b/functions_vars_r.html new file mode 100644 index 00000000..40fecbbc --- /dev/null +++ b/functions_vars_r.html @@ -0,0 +1,100 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- r -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_s.html b/functions_vars_s.html new file mode 100644 index 00000000..e4dda945 --- /dev/null +++ b/functions_vars_s.html @@ -0,0 +1,95 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- s -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_t.html b/functions_vars_t.html new file mode 100644 index 00000000..f3a52f58 --- /dev/null +++ b/functions_vars_t.html @@ -0,0 +1,97 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- t -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_u.html b/functions_vars_u.html new file mode 100644 index 00000000..aaa324a2 --- /dev/null +++ b/functions_vars_u.html @@ -0,0 +1,85 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- u -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_v.html b/functions_vars_v.html new file mode 100644 index 00000000..ee6f149b --- /dev/null +++ b/functions_vars_v.html @@ -0,0 +1,96 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- v -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_x.html b/functions_vars_x.html new file mode 100644 index 00000000..372f26a5 --- /dev/null +++ b/functions_vars_x.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- x -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_y.html b/functions_vars_y.html new file mode 100644 index 00000000..c23318f6 --- /dev/null +++ b/functions_vars_y.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- y -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_vars_z.html b/functions_vars_z.html new file mode 100644 index 00000000..077fd255 --- /dev/null +++ b/functions_vars_z.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members - Variables + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented variables with links to the class documentation for each member:
+ +

- z -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_w.html b/functions_w.html new file mode 100644 index 00000000..31a5c08b --- /dev/null +++ b/functions_w.html @@ -0,0 +1,110 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- w -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_x.html b/functions_x.html new file mode 100644 index 00000000..0316a135 --- /dev/null +++ b/functions_x.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- x -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_y.html b/functions_y.html new file mode 100644 index 00000000..3873027b --- /dev/null +++ b/functions_y.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- y -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_z.html b/functions_z.html new file mode 100644 index 00000000..ccb6679b --- /dev/null +++ b/functions_z.html @@ -0,0 +1,84 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- z -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/functions_~.html b/functions_~.html new file mode 100644 index 00000000..0c3fbda5 --- /dev/null +++ b/functions_~.html @@ -0,0 +1,87 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Members + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- ~ -

+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/group__bctree.html b/group__bctree.html new file mode 100644 index 00000000..be3a9c87 --- /dev/null +++ b/group__bctree.html @@ -0,0 +1,154 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Block-cut tree related classes and functions + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Classes | +Functions
+
Block-cut tree related classes and functions
+
+
+ + + + + + + + + + + + + + + + + +

+Classes

class  egoa::BlockCutTreeTraversal< GraphType >
 Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited. More...
 
class  egoa::BlockCutTree< GraphType >
 A block-cut tree. More...
 
class  egoa::BlockCutTree< GraphType >::Block
 A block. More...
 
class  egoa::BlockCutTree< GraphType >::CutVertex
 Class for cut-vertices. More...
 
class  egoa::internal::BlockCutTreeBuilder< GraphType >
 A class to build BlockCutTree objects for a graph. More...
 
+ + + + + +

+Functions

template<typename GraphType >
BlockCutTree< GraphType > egoa::buildBlockCutTree (GraphType const &graph)
 Builds a block-cut tree.
 
+

Detailed Description

+

This module contains all functions and classes that are related to block-cut trees.

+

To build a block-cut tree the functions buildBlockCutTree(GraphType const &) or BlockCutTree<GraphType>::Build(GraphType const &) can be used.

+

Function Documentation

+ +

◆ buildBlockCutTree()

+ +
+
+
+template<typename GraphType >
+ + + + + + + + +
BlockCutTree< GraphType > egoa::buildBlockCutTree (GraphType const & graph)
+
+ +

Builds a block-cut tree.

+

Convenience function for building a block-cut tree. Using the static member function BlockCutTree<GraphType>::Build() requires explicit template arguments. Here, these are deduced by the compiler.

+
Parameters
+ + +
graphThe graph for which the block-cut tree shall be built.
+
+
+
Template Parameters
+ + +
GraphTypeThe type of the graph.
+
+
+
Returns
The block-cut tree.
+ +

Definition at line 363 of file BlockCutTree.hpp.

+ +

References egoa::BlockCutTree< GraphType >::Build().

+ +
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/hierarchy.html b/hierarchy.html new file mode 100644 index 00000000..425c0d1a --- /dev/null +++ b/hierarchy.html @@ -0,0 +1,210 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Class Hierarchy + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class Hierarchy
+
+
+
This inheritance list is sorted roughly, but not completely, alphabetically:
+
[detail level 1234]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 Cegoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >Class for betweenness centrality
 Cegoa::BinaryHeap< ElementType >Class for binary heap data structure
 Cegoa::BinaryHeap< VoltageAngleDifferenceLabel< Edges::Edge< Edges::ElectricalProperties > > >
 Cegoa::internal::BinaryHeapCheck< Type, inOrder >Class for binary heap check
 Cegoa::internal::BinaryHeapCheck< Type, false >
 Cegoa::internal::BinaryHeapCheck< Type, true >
 Cegoa::internal::BinaryHeapLoopDifferentiation< HeapType, Policy >The for loops for BinaryHeap
 Cegoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >
 Cegoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >Sequential loops for const BinaryHeap
 Cegoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >
 ►Cegoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >Sequential loops for BinaryHeap
 Cegoa::BlockCutTree< GraphType >::BlockA block
 Cegoa::BlockCutTree< GraphType >A block-cut tree
 Cegoa::BlockCutTree< TGraph >
 Cegoa::BlockCutTreeTraversal< GraphType >Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited
 Cegoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
 Cegoa::Bound< BoundType >Class for bounds
 Cegoa::Bound< Types::real >
 Cegoa::Bucket< PriorityQueue >Class for bucket data structure
 Cegoa::BucketElement< ElementType >Class representing the minimal bucket element
 Cegoa::internal::BucketLoopDifferentiation< BucketType, Policy >Class for bucket loop differentiation
 Cegoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >
 ►Cegoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >
 Cegoa::Edges::CarrierDifferentiation< CarrierType >
 Cegoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >
 Cegoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >Class for carrier differentiation
 Cegoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >Class for carrier differentiation
 Cegoa::Color
 Cegoa::internal::ContainerLoop< Policy >Loops over containers
 Cegoa::internal::ContainerLoop< ExecutionPolicy::breakable >Breakable loop over all elements in the container
 ►Cegoa::internal::ContainerLoop< ExecutionPolicy::sequential >Sequential loop over all elements in the container
 Cegoa::BlockCutTree< GraphType >::CutVertexClass for cut-vertices
 Cegoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >Class for dominating theta path
 Cegoa::internal::DominationDifferentiation< ElementType, Domination >Class for domination differentiation
 Cegoa::internal::DominationDifferentiation< ElementType, DominationCriterion::none >
 Cegoa::internal::DominationDifferentiation< ElementType, DominationCriterion::strict >
 Cegoa::internal::DominationDifferentiation< ElementType, DominationCriterion::weak >
 Cegoa::IO::DtpRuntimeCollectionA collections of DtpRuntimeRow objects for multiple runs of the DTP-algorithm
 Cegoa::IO::DtpRuntimeRowStatistics about one execution of the DTP algorithm
 Cegoa::DynamicGraph< VertexProperties, EdgeProperties >A graph data structure that supports adding and removing vertices and edges
 Cegoa::Edges::Edge< PropertiesType >Class for edge
 Cegoa::io::Edge< PropertiesType >
 Cegoa::Edges::ElectricalPropertiesClass having all edge electrical properties (branch properties)
 Cegoa::Vertices::ElectricalProperties< VertexType >Class for electrical properties
 Cegoa::internal::GenerationStrategyDifferentiation< NetworkType, GenerationType >This base class to differentiate between different generation strategy
 Cegoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >This base class to differentiate between different generation strategy
 Cegoa::Vertices::GeneratorProperties< VertexType >Class having all generator properties
 Cegoa::IO::GeoJsonWriter< GraphType >
 ►Cegoa::internal::GraphLoopDifferentiation< GraphType, Policy >The base class for for loops for graphs
 ►Cegoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >Breakable for loops for graphs
 ►Cegoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >The base class for sequential for loops for graphs
 Cegoa::internal::GraphTypeLoopDifferentiation< GraphType, IsDirected >
 Cegoa::internal::GraphTypeLoopDifferentiation< GraphType, false >
 Cegoa::internal::GraphTypeLoopDifferentiation< GraphType, true >
 ►CGRBCallback
 Cegoa::GurobiSolver< CallbackType >
 Cegoa::BinaryHeap< ElementType >::HeapIteratorClass for a heap iterator
 Cegoa::IeeeCdfMatlabParser< GraphType >
 ►Cegoa::Label< ElementType, VertexSetContainer, PointerType >Interface for label
 Cegoa::Label< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId >
 Cegoa::Vertices::LoadProperties< VertexType >Class having all load properties
 Cegoa::MappingBinaryHeap< ElementType, KeyType, MapType >Class for binary heap data structure, in which elements are sorted by keys
 Cegoa::MappingBinaryHeap< typename GraphType::TVertexId, VoltageAngleDifferenceLabel< typename GraphType::TEdge > >
 Cegoa::Auxiliary::MatchPathSeparatorPath separator in UNIX systems
 ►Cegoa::MST< GraphType >Base class for minimum spanning tree algorithms
 Cegoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, GraphType >
 Cegoa::internal::NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >
 Cegoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >
 Cegoa::internal::NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >
 Cegoa::OmittingIterator< ElementVectorIt, BoolVectorIt >An iterator that omits elements of a range if another range of bool indicates that the element is invalid
 Cegoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >A view on a vector, in which some elements are invalid
 Cegoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >
 Cegoa::PowerGridIO< GraphType >Class for power grid io
 Cegoa::internal::PowerGridLoopDifferentiation< PowerGridType, Policy >The base class for for loops for power grid
 Cegoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >Breakable for loops for PowerGrid
 ►Cegoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >
 Cegoa::PyPsaParser< GraphType >
 ►Cegoa::Queue< Type >
 ►Cstd::runtime_error
 Cegoa::IO::SolverRuntimeCollection
 Cegoa::IO::SolverRuntimeRowA struct representing one row of the statistics for mathematical models
 Cegoa::StaticGraph< VertexProperties, EdgeProperties >A graph data structure that supports adding vertices and edges
 Cegoa::StaticGraph< Vertices::ElectricalProperties< Vertices::IeeeBusType >, Edges::ElectricalProperties >
 Cegoa::StdQueue< ElementType >
 Cegoa::StdQueue< GraphType::TVertexId >
 Cegoa::Stroke
 Cegoa::Subgraph< GraphType >A subgraph of an existing graph
 Cegoa::Subgraph< TGraph >
 Cegoa::Subgraph< TGraph const >
 Cegoa::Auxiliary::Timer
 ►Cegoa::Traversal< GraphType, IsDirected >Interface for graph traversal
 Cegoa::Traversal< false >
 Cegoa::Traversal< GraphType, false >
 ►Cegoa::Traversal< GraphType, IsDirected >
 Cegoa::UnionFindThis class describes an union find
 Cegoa::VectorBasedComparator< WeightType, ComparatorType >A comparator that compares based on elements in the vector
 Cegoa::VectorView< ElementType, Const >Provides a restricted view on a vector
 Cegoa::Vertices::Vertex< PropertyType >Class for a vertex
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/index.html b/index.html new file mode 100644 index 00000000..09565577 --- /dev/null +++ b/index.html @@ -0,0 +1,81 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Main Page + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Energy Grid Optimization & Analysis (EGOA) Documentation
+
+
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/jquery.js b/jquery.js new file mode 100644 index 00000000..1dffb65b --- /dev/null +++ b/jquery.js @@ -0,0 +1,34 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,e){e=y(e||this.defaultElement||this)[0],this.element=y(e),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=y(),this.hoverable=y(),this.focusable=y(),this.classesElementLookup={},e!==this&&(y.data(e,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===e&&this.destroy()}}),this.document=y(e.style?e.ownerDocument:e.document||e),this.window=y(this.document[0].defaultView||this.document[0].parentWindow)),this.options=y.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:y.noop,_create:y.noop,_init:y.noop,destroy:function(){var i=this;this._destroy(),y.each(this.classesElementLookup,function(t,e){i._removeClass(e,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:y.noop,widget:function(){return this.element},option:function(t,e){var i,s,n,o=t;if(0===arguments.length)return y.widget.extend({},this.options);if("string"==typeof t)if(o={},t=(i=t.split(".")).shift(),i.length){for(s=o[t]=y.widget.extend({},this.options[t]),n=0;n
"),i=e.children()[0];return y("body").append(e),t=i.offsetWidth,e.css("overflow","scroll"),t===(i=i.offsetWidth)&&(i=e[0].clientWidth),e.remove(),s=t-i},getScrollInfo:function(t){var e=t.isWindow||t.isDocument?"":t.element.css("overflow-x"),i=t.isWindow||t.isDocument?"":t.element.css("overflow-y"),e="scroll"===e||"auto"===e&&t.widthx(D(s),D(n))?o.important="horizontal":o.important="vertical",p.using.call(this,t,o)}),h.offset(y.extend(l,{using:t}))})},y.ui.position={fit:{left:function(t,e){var i=e.within,s=i.isWindow?i.scrollLeft:i.offset.left,n=i.width,o=t.left-e.collisionPosition.marginLeft,h=s-o,a=o+e.collisionWidth-n-s;e.collisionWidth>n?0n?0=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}}),y.ui.plugin={add:function(t,e,i){var s,n=y.ui[t].prototype;for(s in i)n.plugins[s]=n.plugins[s]||[],n.plugins[s].push([e,i[s]])},call:function(t,e,i,s){var n,o=t.plugins[e];if(o&&(s||t.element[0].parentNode&&11!==t.element[0].parentNode.nodeType))for(n=0;n").css({overflow:"hidden",position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.resizable("instance")),this.elementIsWrapper=!0,t={marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom"),marginLeft:this.originalElement.css("marginLeft")},this.element.css(t),this.originalElement.css("margin",0),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css(t),this._proportionallyResize()),this._setupHandles(),e.autoHide&&y(this.element).on("mouseenter",function(){e.disabled||(i._removeClass("ui-resizable-autohide"),i._handles.show())}).on("mouseleave",function(){e.disabled||i.resizing||(i._addClass("ui-resizable-autohide"),i._handles.hide())}),this._mouseInit()},_destroy:function(){this._mouseDestroy(),this._addedHandles.remove();function t(t){y(t).removeData("resizable").removeData("ui-resizable").off(".resizable")}var e;return this.elementIsWrapper&&(t(this.element),e=this.element,this.originalElement.css({position:e.css("position"),width:e.outerWidth(),height:e.outerHeight(),top:e.css("top"),left:e.css("left")}).insertAfter(e),e.remove()),this.originalElement.css("resize",this.originalResizeStyle),t(this.originalElement),this},_setOption:function(t,e){switch(this._super(t,e),t){case"handles":this._removeHandles(),this._setupHandles();break;case"aspectRatio":this._aspectRatio=!!e}},_setupHandles:function(){var t,e,i,s,n,o=this.options,h=this;if(this.handles=o.handles||(y(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this._handles=y(),this._addedHandles=y(),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),i=this.handles.split(","),this.handles={},e=0;e"),this._addClass(n,"ui-resizable-handle "+s),n.css({zIndex:o.zIndex}),this.handles[t]=".ui-resizable-"+t,this.element.children(this.handles[t]).length||(this.element.append(n),this._addedHandles=this._addedHandles.add(n));this._renderAxis=function(t){var e,i,s;for(e in t=t||this.element,this.handles)this.handles[e].constructor===String?this.handles[e]=this.element.children(this.handles[e]).first().show():(this.handles[e].jquery||this.handles[e].nodeType)&&(this.handles[e]=y(this.handles[e]),this._on(this.handles[e],{mousedown:h._mouseDown})),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)&&(i=y(this.handles[e],this.element),s=/sw|ne|nw|se|n|s/.test(e)?i.outerHeight():i.outerWidth(),i=["padding",/ne|nw|n/.test(e)?"Top":/se|sw|s/.test(e)?"Bottom":/^e$/.test(e)?"Right":"Left"].join(""),t.css(i,s),this._proportionallyResize()),this._handles=this._handles.add(this.handles[e])},this._renderAxis(this.element),this._handles=this._handles.add(this.element.find(".ui-resizable-handle")),this._handles.disableSelection(),this._handles.on("mouseover",function(){h.resizing||(this.className&&(n=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),h.axis=n&&n[1]?n[1]:"se")}),o.autoHide&&(this._handles.hide(),this._addClass("ui-resizable-autohide"))},_removeHandles:function(){this._addedHandles.remove()},_mouseCapture:function(t){var e,i,s=!1;for(e in this.handles)(i=y(this.handles[e])[0])!==t.target&&!y.contains(i,t.target)||(s=!0);return!this.options.disabled&&s},_mouseStart:function(t){var e,i,s=this.options,n=this.element;return this.resizing=!0,this._renderProxy(),e=this._num(this.helper.css("left")),i=this._num(this.helper.css("top")),s.containment&&(e+=y(s.containment).scrollLeft()||0,i+=y(s.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:e,top:i},this.size=this._helper?{width:this.helper.width(),height:this.helper.height()}:{width:n.width(),height:n.height()},this.originalSize=this._helper?{width:n.outerWidth(),height:n.outerHeight()}:{width:n.width(),height:n.height()},this.sizeDiff={width:n.outerWidth()-n.width(),height:n.outerHeight()-n.height()},this.originalPosition={left:e,top:i},this.originalMousePosition={left:t.pageX,top:t.pageY},this.aspectRatio="number"==typeof s.aspectRatio?s.aspectRatio:this.originalSize.width/this.originalSize.height||1,s=y(".ui-resizable-"+this.axis).css("cursor"),y("body").css("cursor","auto"===s?this.axis+"-resize":s),this._addClass("ui-resizable-resizing"),this._propagate("start",t),!0},_mouseDrag:function(t){var e=this.originalMousePosition,i=this.axis,s=t.pageX-e.left||0,e=t.pageY-e.top||0,i=this._change[i];return this._updatePrevProperties(),i&&(e=i.apply(this,[t,s,e]),this._updateVirtualBoundaries(t.shiftKey),(this._aspectRatio||t.shiftKey)&&(e=this._updateRatio(e,t)),e=this._respectSize(e,t),this._updateCache(e),this._propagate("resize",t),e=this._applyChanges(),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),y.isEmptyObject(e)||(this._updatePrevProperties(),this._trigger("resize",t,this.ui()),this._applyChanges())),!1},_mouseStop:function(t){this.resizing=!1;var e,i,s,n=this.options,o=this;return this._helper&&(s=(e=(i=this._proportionallyResizeElements).length&&/textarea/i.test(i[0].nodeName))&&this._hasScroll(i[0],"left")?0:o.sizeDiff.height,i=e?0:o.sizeDiff.width,e={width:o.helper.width()-i,height:o.helper.height()-s},i=parseFloat(o.element.css("left"))+(o.position.left-o.originalPosition.left)||null,s=parseFloat(o.element.css("top"))+(o.position.top-o.originalPosition.top)||null,n.animate||this.element.css(y.extend(e,{top:s,left:i})),o.helper.height(o.size.height),o.helper.width(o.size.width),this._helper&&!n.animate&&this._proportionallyResize()),y("body").css("cursor","auto"),this._removeClass("ui-resizable-resizing"),this._propagate("stop",t),this._helper&&this.helper.remove(),!1},_updatePrevProperties:function(){this.prevPosition={top:this.position.top,left:this.position.left},this.prevSize={width:this.size.width,height:this.size.height}},_applyChanges:function(){var t={};return this.position.top!==this.prevPosition.top&&(t.top=this.position.top+"px"),this.position.left!==this.prevPosition.left&&(t.left=this.position.left+"px"),this.size.width!==this.prevSize.width&&(t.width=this.size.width+"px"),this.size.height!==this.prevSize.height&&(t.height=this.size.height+"px"),this.helper.css(t),t},_updateVirtualBoundaries:function(t){var e,i,s=this.options,n={minWidth:this._isNumber(s.minWidth)?s.minWidth:0,maxWidth:this._isNumber(s.maxWidth)?s.maxWidth:1/0,minHeight:this._isNumber(s.minHeight)?s.minHeight:0,maxHeight:this._isNumber(s.maxHeight)?s.maxHeight:1/0};(this._aspectRatio||t)&&(e=n.minHeight*this.aspectRatio,i=n.minWidth/this.aspectRatio,s=n.maxHeight*this.aspectRatio,t=n.maxWidth/this.aspectRatio,e>n.minWidth&&(n.minWidth=e),i>n.minHeight&&(n.minHeight=i),st.width,h=this._isNumber(t.height)&&e.minHeight&&e.minHeight>t.height,a=this.originalPosition.left+this.originalSize.width,r=this.originalPosition.top+this.originalSize.height,l=/sw|nw|w/.test(i),i=/nw|ne|n/.test(i);return o&&(t.width=e.minWidth),h&&(t.height=e.minHeight),s&&(t.width=e.maxWidth),n&&(t.height=e.maxHeight),o&&l&&(t.left=a-e.minWidth),s&&l&&(t.left=a-e.maxWidth),h&&i&&(t.top=r-e.minHeight),n&&i&&(t.top=r-e.maxHeight),t.width||t.height||t.left||!t.top?t.width||t.height||t.top||!t.left||(t.left=null):t.top=null,t},_getPaddingPlusBorderDimensions:function(t){for(var e=0,i=[],s=[t.css("borderTopWidth"),t.css("borderRightWidth"),t.css("borderBottomWidth"),t.css("borderLeftWidth")],n=[t.css("paddingTop"),t.css("paddingRight"),t.css("paddingBottom"),t.css("paddingLeft")];e<4;e++)i[e]=parseFloat(s[e])||0,i[e]+=parseFloat(n[e])||0;return{height:i[0]+i[2],width:i[1]+i[3]}},_proportionallyResize:function(){if(this._proportionallyResizeElements.length)for(var t,e=0,i=this.helper||this.element;e").css({overflow:"hidden"}),this._addClass(this.helper,this._helper),this.helper.css({width:this.element.outerWidth(),height:this.element.outerHeight(),position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++e.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element},_change:{e:function(t,e){return{width:this.originalSize.width+e}},w:function(t,e){var i=this.originalSize;return{left:this.originalPosition.left+e,width:i.width-e}},n:function(t,e,i){var s=this.originalSize;return{top:this.originalPosition.top+i,height:s.height-i}},s:function(t,e,i){return{height:this.originalSize.height+i}},se:function(t,e,i){return y.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[t,e,i]))},sw:function(t,e,i){return y.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[t,e,i]))},ne:function(t,e,i){return y.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[t,e,i]))},nw:function(t,e,i){return y.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[t,e,i]))}},_propagate:function(t,e){y.ui.plugin.call(this,t,[e,this.ui()]),"resize"!==t&&this._trigger(t,e,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),y.ui.plugin.add("resizable","animate",{stop:function(e){var i=y(this).resizable("instance"),t=i.options,s=i._proportionallyResizeElements,n=s.length&&/textarea/i.test(s[0].nodeName),o=n&&i._hasScroll(s[0],"left")?0:i.sizeDiff.height,h=n?0:i.sizeDiff.width,n={width:i.size.width-h,height:i.size.height-o},h=parseFloat(i.element.css("left"))+(i.position.left-i.originalPosition.left)||null,o=parseFloat(i.element.css("top"))+(i.position.top-i.originalPosition.top)||null;i.element.animate(y.extend(n,o&&h?{top:o,left:h}:{}),{duration:t.animateDuration,easing:t.animateEasing,step:function(){var t={width:parseFloat(i.element.css("width")),height:parseFloat(i.element.css("height")),top:parseFloat(i.element.css("top")),left:parseFloat(i.element.css("left"))};s&&s.length&&y(s[0]).css({width:t.width,height:t.height}),i._updateCache(t),i._propagate("resize",e)}})}}),y.ui.plugin.add("resizable","containment",{start:function(){var i,s,n=y(this).resizable("instance"),t=n.options,e=n.element,o=t.containment,h=o instanceof y?o.get(0):/parent/.test(o)?e.parent().get(0):o;h&&(n.containerElement=y(h),/document/.test(o)||o===document?(n.containerOffset={left:0,top:0},n.containerPosition={left:0,top:0},n.parentData={element:y(document),left:0,top:0,width:y(document).width(),height:y(document).height()||document.body.parentNode.scrollHeight}):(i=y(h),s=[],y(["Top","Right","Left","Bottom"]).each(function(t,e){s[t]=n._num(i.css("padding"+e))}),n.containerOffset=i.offset(),n.containerPosition=i.position(),n.containerSize={height:i.innerHeight()-s[3],width:i.innerWidth()-s[1]},t=n.containerOffset,e=n.containerSize.height,o=n.containerSize.width,o=n._hasScroll(h,"left")?h.scrollWidth:o,e=n._hasScroll(h)?h.scrollHeight:e,n.parentData={element:h,left:t.left,top:t.top,width:o,height:e}))},resize:function(t){var e=y(this).resizable("instance"),i=e.options,s=e.containerOffset,n=e.position,o=e._aspectRatio||t.shiftKey,h={top:0,left:0},a=e.containerElement,t=!0;a[0]!==document&&/static/.test(a.css("position"))&&(h=s),n.left<(e._helper?s.left:0)&&(e.size.width=e.size.width+(e._helper?e.position.left-s.left:e.position.left-h.left),o&&(e.size.height=e.size.width/e.aspectRatio,t=!1),e.position.left=i.helper?s.left:0),n.top<(e._helper?s.top:0)&&(e.size.height=e.size.height+(e._helper?e.position.top-s.top:e.position.top),o&&(e.size.width=e.size.height*e.aspectRatio,t=!1),e.position.top=e._helper?s.top:0),i=e.containerElement.get(0)===e.element.parent().get(0),n=/relative|absolute/.test(e.containerElement.css("position")),i&&n?(e.offset.left=e.parentData.left+e.position.left,e.offset.top=e.parentData.top+e.position.top):(e.offset.left=e.element.offset().left,e.offset.top=e.element.offset().top),n=Math.abs(e.sizeDiff.width+(e._helper?e.offset.left-h.left:e.offset.left-s.left)),s=Math.abs(e.sizeDiff.height+(e._helper?e.offset.top-h.top:e.offset.top-s.top)),n+e.size.width>=e.parentData.width&&(e.size.width=e.parentData.width-n,o&&(e.size.height=e.size.width/e.aspectRatio,t=!1)),s+e.size.height>=e.parentData.height&&(e.size.height=e.parentData.height-s,o&&(e.size.width=e.size.height*e.aspectRatio,t=!1)),t||(e.position.left=e.prevPosition.left,e.position.top=e.prevPosition.top,e.size.width=e.prevSize.width,e.size.height=e.prevSize.height)},stop:function(){var t=y(this).resizable("instance"),e=t.options,i=t.containerOffset,s=t.containerPosition,n=t.containerElement,o=y(t.helper),h=o.offset(),a=o.outerWidth()-t.sizeDiff.width,o=o.outerHeight()-t.sizeDiff.height;t._helper&&!e.animate&&/relative/.test(n.css("position"))&&y(this).css({left:h.left-s.left-i.left,width:a,height:o}),t._helper&&!e.animate&&/static/.test(n.css("position"))&&y(this).css({left:h.left-s.left-i.left,width:a,height:o})}}),y.ui.plugin.add("resizable","alsoResize",{start:function(){var t=y(this).resizable("instance").options;y(t.alsoResize).each(function(){var t=y(this);t.data("ui-resizable-alsoresize",{width:parseFloat(t.width()),height:parseFloat(t.height()),left:parseFloat(t.css("left")),top:parseFloat(t.css("top"))})})},resize:function(t,i){var e=y(this).resizable("instance"),s=e.options,n=e.originalSize,o=e.originalPosition,h={height:e.size.height-n.height||0,width:e.size.width-n.width||0,top:e.position.top-o.top||0,left:e.position.left-o.left||0};y(s.alsoResize).each(function(){var t=y(this),s=y(this).data("ui-resizable-alsoresize"),n={},e=t.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];y.each(e,function(t,e){var i=(s[e]||0)+(h[e]||0);i&&0<=i&&(n[e]=i||null)}),t.css(n)})},stop:function(){y(this).removeData("ui-resizable-alsoresize")}}),y.ui.plugin.add("resizable","ghost",{start:function(){var t=y(this).resizable("instance"),e=t.size;t.ghost=t.originalElement.clone(),t.ghost.css({opacity:.25,display:"block",position:"relative",height:e.height,width:e.width,margin:0,left:0,top:0}),t._addClass(t.ghost,"ui-resizable-ghost"),!1!==y.uiBackCompat&&"string"==typeof t.options.ghost&&t.ghost.addClass(this.options.ghost),t.ghost.appendTo(t.helper)},resize:function(){var t=y(this).resizable("instance");t.ghost&&t.ghost.css({position:"relative",height:t.size.height,width:t.size.width})},stop:function(){var t=y(this).resizable("instance");t.ghost&&t.helper&&t.helper.get(0).removeChild(t.ghost.get(0))}}),y.ui.plugin.add("resizable","grid",{resize:function(){var t,e=y(this).resizable("instance"),i=e.options,s=e.size,n=e.originalSize,o=e.originalPosition,h=e.axis,a="number"==typeof i.grid?[i.grid,i.grid]:i.grid,r=a[0]||1,l=a[1]||1,u=Math.round((s.width-n.width)/r)*r,p=Math.round((s.height-n.height)/l)*l,d=n.width+u,c=n.height+p,f=i.maxWidth&&i.maxWidthd,s=i.minHeight&&i.minHeight>c;i.grid=a,m&&(d+=r),s&&(c+=l),f&&(d-=r),g&&(c-=l),/^(se|s|e)$/.test(h)?(e.size.width=d,e.size.height=c):/^(ne)$/.test(h)?(e.size.width=d,e.size.height=c,e.position.top=o.top-p):/^(sw)$/.test(h)?(e.size.width=d,e.size.height=c,e.position.left=o.left-u):((c-l<=0||d-r<=0)&&(t=e._getPaddingPlusBorderDimensions(this)),0=f[g]?0:Math.min(f[g],n));!a&&1-1){targetElements.on(evt+EVENT_NAMESPACE,function elementToggle(event){$.powerTip.toggle(this,event)})}else{targetElements.on(evt+EVENT_NAMESPACE,function elementOpen(event){$.powerTip.show(this,event)})}});$.each(options.closeEvents,function(idx,evt){if($.inArray(evt,options.openEvents)<0){targetElements.on(evt+EVENT_NAMESPACE,function elementClose(event){$.powerTip.hide(this,!isMouseEvent(event))})}});targetElements.on("keydown"+EVENT_NAMESPACE,function elementKeyDown(event){if(event.keyCode===27){$.powerTip.hide(this,true)}})}return targetElements};$.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",popupClass:null,intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false,openEvents:["mouseenter","focus"],closeEvents:["mouseleave","blur"]};$.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};$.powerTip={show:function apiShowTip(element,event){if(isMouseEvent(event)){trackMouse(event);session.previousX=event.pageX;session.previousY=event.pageY;$(element).data(DATA_DISPLAYCONTROLLER).show()}else{$(element).first().data(DATA_DISPLAYCONTROLLER).show(true,true)}return element},reposition:function apiResetPosition(element){$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();return element},hide:function apiCloseTip(element,immediate){var displayController;immediate=element?immediate:true;if(element){displayController=$(element).first().data(DATA_DISPLAYCONTROLLER)}else if(session.activeHover){displayController=session.activeHover.data(DATA_DISPLAYCONTROLLER)}if(displayController){displayController.hide(immediate)}return element},toggle:function apiToggle(element,event){if(session.activeHover&&session.activeHover.is(element)){$.powerTip.hide(element,!isMouseEvent(event))}else{$.powerTip.show(element,event)}return element}};$.powerTip.showTip=$.powerTip.show;$.powerTip.closeTip=$.powerTip.hide;function CSSCoordinates(){var me=this;me.top="auto";me.left="auto";me.right="auto";me.bottom="auto";me.set=function(property,value){if($.isNumeric(value)){me[property]=Math.round(value)}}}function DisplayController(element,options,tipController){var hoverTimer=null,myCloseDelay=null;function openTooltip(immediate,forceOpen){cancelTimer();if(!element.data(DATA_HASACTIVEHOVER)){if(!immediate){session.tipOpenImminent=true;hoverTimer=setTimeout(function intentDelay(){hoverTimer=null;checkForIntent()},options.intentPollInterval)}else{if(forceOpen){element.data(DATA_FORCEDOPEN,true)}closeAnyDelayed();tipController.showTip(element)}}else{cancelClose()}}function closeTooltip(disableDelay){if(myCloseDelay){myCloseDelay=session.closeDelayTimeout=clearTimeout(myCloseDelay);session.delayInProgress=false}cancelTimer();session.tipOpenImminent=false;if(element.data(DATA_HASACTIVEHOVER)){element.data(DATA_FORCEDOPEN,false);if(!disableDelay){session.delayInProgress=true;session.closeDelayTimeout=setTimeout(function closeDelay(){session.closeDelayTimeout=null;tipController.hideTip(element);session.delayInProgress=false;myCloseDelay=null},options.closeDelay);myCloseDelay=session.closeDelayTimeout}else{tipController.hideTip(element)}}}function checkForIntent(){var xDifference=Math.abs(session.previousX-session.currentX),yDifference=Math.abs(session.previousY-session.currentY),totalDifference=xDifference+yDifference;if(totalDifference",{id:options.popupId});if($body.length===0){$body=$("body")}$body.append(tipElement);session.tooltips=session.tooltips?session.tooltips.add(tipElement):tipElement}if(options.followMouse){if(!tipElement.data(DATA_HASMOUSEMOVE)){$document.on("mousemove"+EVENT_NAMESPACE,positionTipOnCursor);$window.on("scroll"+EVENT_NAMESPACE,positionTipOnCursor);tipElement.data(DATA_HASMOUSEMOVE,true)}}function beginShowTip(element){element.data(DATA_HASACTIVEHOVER,true);tipElement.queue(function queueTipInit(next){showTip(element);next()})}function showTip(element){var tipContent;if(!element.data(DATA_HASACTIVEHOVER)){return}if(session.isTipOpen){if(!session.isClosing){hideTip(session.activeHover)}tipElement.delay(100).queue(function queueTipAgain(next){showTip(element);next()});return}element.trigger("powerTipPreRender");tipContent=getTooltipContent(element);if(tipContent){tipElement.empty().append(tipContent)}else{return}element.trigger("powerTipRender");session.activeHover=element;session.isTipOpen=true;tipElement.data(DATA_MOUSEONTOTIP,options.mouseOnToPopup);tipElement.addClass(options.popupClass);if(!options.followMouse||element.data(DATA_FORCEDOPEN)){positionTipOnElement(element);session.isFixedTipOpen=true}else{positionTipOnCursor()}if(!element.data(DATA_FORCEDOPEN)&&!options.followMouse){$document.on("click"+EVENT_NAMESPACE,function documentClick(event){var target=event.target;if(target!==element[0]){if(options.mouseOnToPopup){if(target!==tipElement[0]&&!$.contains(tipElement[0],target)){$.powerTip.hide()}}else{$.powerTip.hide()}}})}if(options.mouseOnToPopup&&!options.manual){tipElement.on("mouseenter"+EVENT_NAMESPACE,function tipMouseEnter(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel()}});tipElement.on("mouseleave"+EVENT_NAMESPACE,function tipMouseLeave(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide()}})}tipElement.fadeIn(options.fadeInTime,function fadeInCallback(){if(!session.desyncTimeout){session.desyncTimeout=setInterval(closeDesyncedTip,500)}element.trigger("powerTipOpen")})}function hideTip(element){session.isClosing=true;session.isTipOpen=false;session.desyncTimeout=clearInterval(session.desyncTimeout);element.data(DATA_HASACTIVEHOVER,false);element.data(DATA_FORCEDOPEN,false);$document.off("click"+EVENT_NAMESPACE);tipElement.off(EVENT_NAMESPACE);tipElement.fadeOut(options.fadeOutTime,function fadeOutCallback(){var coords=new CSSCoordinates;session.activeHover=null;session.isClosing=false;session.isFixedTipOpen=false;tipElement.removeClass();coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);tipElement.css(coords);element.trigger("powerTipClose")})}function positionTipOnCursor(){var tipWidth,tipHeight,coords,collisions,collisionCount;if(!session.isFixedTipOpen&&(session.isTipOpen||session.tipOpenImminent&&tipElement.data(DATA_HASMOUSEMOVE))){tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=new CSSCoordinates;coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);collisions=getViewportCollisions(coords,tipWidth,tipHeight);if(collisions!==Collision.none){collisionCount=countFlags(collisions);if(collisionCount===1){if(collisions===Collision.right){coords.set("left",session.scrollLeft+session.windowWidth-tipWidth)}else if(collisions===Collision.bottom){coords.set("top",session.scrollTop+session.windowHeight-tipHeight)}}else{coords.set("left",session.currentX-tipWidth-options.offset);coords.set("top",session.currentY-tipHeight-options.offset)}}tipElement.css(coords)}}function positionTipOnElement(element){var priorityList,finalPlacement;if(options.smartPlacement||options.followMouse&&element.data(DATA_FORCEDOPEN)){priorityList=$.fn.powerTip.smartPlacementLists[options.placement];$.each(priorityList,function(idx,pos){var collisions=getViewportCollisions(placeTooltip(element,pos),tipElement.outerWidth(),tipElement.outerHeight());finalPlacement=pos;return collisions!==Collision.none})}else{placeTooltip(element,options.placement);finalPlacement=options.placement}tipElement.removeClass("w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt");tipElement.addClass(finalPlacement)}function placeTooltip(element,placement){var iterationCount=0,tipWidth,tipHeight,coords=new CSSCoordinates;coords.set("top",0);coords.set("left",0);tipElement.css(coords);do{tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=placementCalculator.compute(element,placement,tipWidth,tipHeight,options.offset);tipElement.css(coords)}while(++iterationCount<=5&&(tipWidth!==tipElement.outerWidth()||tipHeight!==tipElement.outerHeight()));return coords}function closeDesyncedTip(){var isDesynced=false,hasDesyncableCloseEvent=$.grep(["mouseleave","mouseout","blur","focusout"],function(eventType){return $.inArray(eventType,options.closeEvents)!==-1}).length>0;if(session.isTipOpen&&!session.isClosing&&!session.delayInProgress&&hasDesyncableCloseEvent){if(session.activeHover.data(DATA_HASACTIVEHOVER)===false||session.activeHover.is(":disabled")){isDesynced=true}else if(!isMouseOver(session.activeHover)&&!session.activeHover.is(":focus")&&!session.activeHover.data(DATA_FORCEDOPEN)){if(tipElement.data(DATA_MOUSEONTOTIP)){if(!isMouseOver(tipElement)){isDesynced=true}}else{isDesynced=true}}if(isDesynced){hideTip(session.activeHover)}}}this.showTip=beginShowTip;this.hideTip=hideTip;this.resetPosition=positionTipOnElement}function isSvgElement(element){return Boolean(window.SVGElement&&element[0]instanceof SVGElement)}function isMouseEvent(event){return Boolean(event&&$.inArray(event.type,MOUSE_EVENTS)>-1&&typeof event.pageX==="number")}function initTracking(){if(!session.mouseTrackingActive){session.mouseTrackingActive=true;getViewportDimensions();$(getViewportDimensions);$document.on("mousemove"+EVENT_NAMESPACE,trackMouse);$window.on("resize"+EVENT_NAMESPACE,trackResize);$window.on("scroll"+EVENT_NAMESPACE,trackScroll)}}function getViewportDimensions(){session.scrollLeft=$window.scrollLeft();session.scrollTop=$window.scrollTop();session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackResize(){session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackScroll(){var x=$window.scrollLeft(),y=$window.scrollTop();if(x!==session.scrollLeft){session.currentX+=x-session.scrollLeft;session.scrollLeft=x}if(y!==session.scrollTop){session.currentY+=y-session.scrollTop;session.scrollTop=y}}function trackMouse(event){session.currentX=event.pageX;session.currentY=event.pageY}function isMouseOver(element){var elementPosition=element.offset(),elementBox=element[0].getBoundingClientRect(),elementWidth=elementBox.right-elementBox.left,elementHeight=elementBox.bottom-elementBox.top;return session.currentX>=elementPosition.left&&session.currentX<=elementPosition.left+elementWidth&&session.currentY>=elementPosition.top&&session.currentY<=elementPosition.top+elementHeight}function getTooltipContent(element){var tipText=element.data(DATA_POWERTIP),tipObject=element.data(DATA_POWERTIPJQ),tipTarget=element.data(DATA_POWERTIPTARGET),targetElement,content;if(tipText){if($.isFunction(tipText)){tipText=tipText.call(element[0])}content=tipText}else if(tipObject){if($.isFunction(tipObject)){tipObject=tipObject.call(element[0])}if(tipObject.length>0){content=tipObject.clone(true,true)}}else if(tipTarget){targetElement=$("#"+tipTarget);if(targetElement.length>0){content=targetElement.html()}}return content}function getViewportCollisions(coords,elementWidth,elementHeight){var viewportTop=session.scrollTop,viewportLeft=session.scrollLeft,viewportBottom=viewportTop+session.windowHeight,viewportRight=viewportLeft+session.windowWidth,collisions=Collision.none;if(coords.topviewportBottom||Math.abs(coords.bottom-session.windowHeight)>viewportBottom){collisions|=Collision.bottom}if(coords.leftviewportRight){collisions|=Collision.left}if(coords.left+elementWidth>viewportRight||coords.right1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);/*! SmartMenus jQuery Plugin - v1.1.0 - September 17, 2017 + * http://www.smartmenus.org/ + * Copyright Vasil Dinkov, Vadikom Web Ltd. http://vadikom.com; Licensed MIT */(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"object"==typeof module&&"object"==typeof module.exports?module.exports=t(require("jquery")):t(jQuery)})(function($){function initMouseDetection(t){var e=".smartmenus_mouse";if(mouseDetectionEnabled||t)mouseDetectionEnabled&&t&&($(document).off(e),mouseDetectionEnabled=!1);else{var i=!0,s=null,o={mousemove:function(t){var e={x:t.pageX,y:t.pageY,timeStamp:(new Date).getTime()};if(s){var o=Math.abs(s.x-e.x),a=Math.abs(s.y-e.y);if((o>0||a>0)&&2>=o&&2>=a&&300>=e.timeStamp-s.timeStamp&&(mouse=!0,i)){var n=$(t.target).closest("a");n.is("a")&&$.each(menuTrees,function(){return $.contains(this.$root[0],n[0])?(this.itemEnter({currentTarget:n[0]}),!1):void 0}),i=!1}}s=e}};o[touchEvents?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut"]=function(t){isTouchEvent(t.originalEvent)&&(mouse=!1)},$(document).on(getEventsNS(o,e)),mouseDetectionEnabled=!0}}function isTouchEvent(t){return!/^(4|mouse)$/.test(t.pointerType)}function getEventsNS(t,e){e||(e="");var i={};for(var s in t)i[s.split(" ").join(e+" ")+e]=t[s];return i}var menuTrees=[],mouse=!1,touchEvents="ontouchstart"in window,mouseDetectionEnabled=!1,requestAnimationFrame=window.requestAnimationFrame||function(t){return setTimeout(t,1e3/60)},cancelAnimationFrame=window.cancelAnimationFrame||function(t){clearTimeout(t)},canAnimate=!!$.fn.animate;return $.SmartMenus=function(t,e){this.$root=$(t),this.opts=e,this.rootId="",this.accessIdPrefix="",this.$subArrow=null,this.activatedItems=[],this.visibleSubMenus=[],this.showTimeout=0,this.hideTimeout=0,this.scrollTimeout=0,this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.idInc=0,this.$firstLink=null,this.$firstSub=null,this.disabled=!1,this.$disableOverlay=null,this.$touchScrollingSub=null,this.cssTransforms3d="perspective"in t.style||"webkitPerspective"in t.style,this.wasCollapsible=!1,this.init()},$.extend($.SmartMenus,{hideAll:function(){$.each(menuTrees,function(){this.menuHideAll()})},destroy:function(){for(;menuTrees.length;)menuTrees[0].destroy();initMouseDetection(!0)},prototype:{init:function(t){var e=this;if(!t){menuTrees.push(this),this.rootId=((new Date).getTime()+Math.random()+"").replace(/\D/g,""),this.accessIdPrefix="sm-"+this.rootId+"-",this.$root.hasClass("sm-rtl")&&(this.opts.rightToLeftSubMenus=!0);var i=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).on(getEventsNS({"mouseover focusin":$.proxy(this.rootOver,this),"mouseout focusout":$.proxy(this.rootOut,this),keydown:$.proxy(this.rootKeyDown,this)},i)).on(getEventsNS({mouseenter:$.proxy(this.itemEnter,this),mouseleave:$.proxy(this.itemLeave,this),mousedown:$.proxy(this.itemDown,this),focus:$.proxy(this.itemFocus,this),blur:$.proxy(this.itemBlur,this),click:$.proxy(this.itemClick,this)},i),"a"),i+=this.rootId,this.opts.hideOnClick&&$(document).on(getEventsNS({touchstart:$.proxy(this.docTouchStart,this),touchmove:$.proxy(this.docTouchMove,this),touchend:$.proxy(this.docTouchEnd,this),click:$.proxy(this.docClick,this)},i)),$(window).on(getEventsNS({"resize orientationchange":$.proxy(this.winResize,this)},i)),this.opts.subIndicators&&(this.$subArrow=$("").addClass("sub-arrow"),this.opts.subIndicatorsText&&this.$subArrow.html(this.opts.subIndicatorsText)),initMouseDetection()}if(this.$firstSub=this.$root.find("ul").each(function(){e.menuInit($(this))}).eq(0),this.$firstLink=this.$root.find("a").eq(0),this.opts.markCurrentItem){var s=/(index|default)\.[^#\?\/]*/i,o=/#.*/,a=window.location.href.replace(s,""),n=a.replace(o,"");this.$root.find("a").each(function(){var t=this.href.replace(s,""),i=$(this);(t==a||t==n)&&(i.addClass("current"),e.opts.markCurrentTree&&i.parentsUntil("[data-smartmenus-id]","ul").each(function(){$(this).dataSM("parent-a").addClass("current")}))})}this.wasCollapsible=this.isCollapsible()},destroy:function(t){if(!t){var e=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").off(e),e+=this.rootId,$(document).off(e),$(window).off(e),this.opts.subIndicators&&(this.$subArrow=null)}this.menuHideAll();var i=this;this.$root.find("ul").each(function(){var t=$(this);t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.dataSM("shown-before")&&((i.opts.subMenusMinWidth||i.opts.subMenusMaxWidth)&&t.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap"),t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})),0==(t.attr("id")||"").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded"),this.$root.find("a.has-submenu").each(function(){var t=$(this);0==t.attr("id").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub"),this.opts.subIndicators&&this.$root.find("span.sub-arrow").remove(),this.opts.markCurrentItem&&this.$root.find("a.current").removeClass("current"),t||(this.$root=null,this.$firstLink=null,this.$firstSub=null,this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),menuTrees.splice($.inArray(this,menuTrees),1))},disable:function(t){if(!this.disabled){if(this.menuHideAll(),!t&&!this.opts.isPopup&&this.$root.is(":visible")){var e=this.$root.offset();this.$disableOverlay=$('
').css({position:"absolute",top:e.top,left:e.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(!0),opacity:0}).appendTo(document.body)}this.disabled=!0}},docClick:function(t){return this.$touchScrollingSub?(this.$touchScrollingSub=null,void 0):((this.visibleSubMenus.length&&!$.contains(this.$root[0],t.target)||$(t.target).closest("a").length)&&this.menuHideAll(),void 0)},docTouchEnd:function(){if(this.lastTouch){if(!(!this.visibleSubMenus.length||void 0!==this.lastTouch.x2&&this.lastTouch.x1!=this.lastTouch.x2||void 0!==this.lastTouch.y2&&this.lastTouch.y1!=this.lastTouch.y2||this.lastTouch.target&&$.contains(this.$root[0],this.lastTouch.target))){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var t=this;this.hideTimeout=setTimeout(function(){t.menuHideAll()},350)}this.lastTouch=null}},docTouchMove:function(t){if(this.lastTouch){var e=t.originalEvent.touches[0];this.lastTouch.x2=e.pageX,this.lastTouch.y2=e.pageY}},docTouchStart:function(t){var e=t.originalEvent.touches[0];this.lastTouch={x1:e.pageX,y1:e.pageY,target:e.target}},enable:function(){this.disabled&&(this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),this.disabled=!1)},getClosestMenu:function(t){for(var e=$(t).closest("ul");e.dataSM("in-mega");)e=e.parent().closest("ul");return e[0]||null},getHeight:function(t){return this.getOffset(t,!0)},getOffset:function(t,e){var i;"none"==t.css("display")&&(i={position:t[0].style.position,visibility:t[0].style.visibility},t.css({position:"absolute",visibility:"hidden"}).show());var s=t[0].getBoundingClientRect&&t[0].getBoundingClientRect(),o=s&&(e?s.height||s.bottom-s.top:s.width||s.right-s.left);return o||0===o||(o=e?t[0].offsetHeight:t[0].offsetWidth),i&&t.hide().css(i),o},getStartZIndex:function(t){var e=parseInt(this[t?"$root":"$firstSub"].css("z-index"));return!t&&isNaN(e)&&(e=parseInt(this.$root.css("z-index"))),isNaN(e)?1:e},getTouchPoint:function(t){return t.touches&&t.touches[0]||t.changedTouches&&t.changedTouches[0]||t},getViewport:function(t){var e=t?"Height":"Width",i=document.documentElement["client"+e],s=window["inner"+e];return s&&(i=Math.min(i,s)),i},getViewportHeight:function(){return this.getViewport(!0)},getViewportWidth:function(){return this.getViewport()},getWidth:function(t){return this.getOffset(t)},handleEvents:function(){return!this.disabled&&this.isCSSOn()},handleItemEvents:function(t){return this.handleEvents()&&!this.isLinkInMegaMenu(t)},isCollapsible:function(){return"static"==this.$firstSub.css("position")},isCSSOn:function(){return"inline"!=this.$firstLink.css("display")},isFixed:function(){var t="fixed"==this.$root.css("position");return t||this.$root.parentsUntil("body").each(function(){return"fixed"==$(this).css("position")?(t=!0,!1):void 0}),t},isLinkInMegaMenu:function(t){return $(this.getClosestMenu(t[0])).hasClass("mega-menu")},isTouchMode:function(){return!mouse||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(t,e){var i=t.closest("ul"),s=i.dataSM("level");if(s>1&&(!this.activatedItems[s-2]||this.activatedItems[s-2][0]!=i.dataSM("parent-a")[0])){var o=this;$(i.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(i).each(function(){o.itemActivate($(this).dataSM("parent-a"))})}if((!this.isCollapsible()||e)&&this.menuHideSubMenus(this.activatedItems[s-1]&&this.activatedItems[s-1][0]==t[0]?s:s-1),this.activatedItems[s-1]=t,this.$root.triggerHandler("activate.smapi",t[0])!==!1){var a=t.dataSM("sub");a&&(this.isTouchMode()||!this.opts.showOnClick||this.clickActivated)&&this.menuShow(a)}},itemBlur:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&this.$root.triggerHandler("blur.smapi",e[0])},itemClick:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==e.closest("ul")[0])return this.$touchScrollingSub=null,t.stopPropagation(),!1;if(this.$root.triggerHandler("click.smapi",e[0])===!1)return!1;var i=$(t.target).is(".sub-arrow"),s=e.dataSM("sub"),o=s?2==s.dataSM("level"):!1,a=this.isCollapsible(),n=/toggle$/.test(this.opts.collapsibleBehavior),r=/link$/.test(this.opts.collapsibleBehavior),h=/^accordion/.test(this.opts.collapsibleBehavior);if(s&&!s.is(":visible")){if((!r||!a||i)&&(this.opts.showOnClick&&o&&(this.clickActivated=!0),this.itemActivate(e,h),s.is(":visible")))return this.focusActivated=!0,!1}else if(a&&(n||i))return this.itemActivate(e,h),this.menuHide(s),n&&(this.focusActivated=!1),!1;return this.opts.showOnClick&&o||e.hasClass("disabled")||this.$root.triggerHandler("select.smapi",e[0])===!1?!1:void 0}},itemDown:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&e.dataSM("mousedown",!0)},itemEnter:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(!this.isTouchMode()){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);var i=this;this.showTimeout=setTimeout(function(){i.itemActivate(e)},this.opts.showOnClick&&1==e.closest("ul").dataSM("level")?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",e[0])}},itemFocus:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(!this.focusActivated||this.isTouchMode()&&e.dataSM("mousedown")||this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0]==e[0]||this.itemActivate(e,!0),this.$root.triggerHandler("focus.smapi",e[0]))},itemLeave:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(this.isTouchMode()||(e[0].blur(),this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0)),e.removeDataSM("mousedown"),this.$root.triggerHandler("mouseleave.smapi",e[0]))},menuHide:function(t){if(this.$root.triggerHandler("beforehide.smapi",t[0])!==!1&&(canAnimate&&t.stop(!0,!0),"none"!=t.css("display"))){var e=function(){t.css("z-index","")};this.isCollapsible()?canAnimate&&this.opts.collapsibleHideFunction?this.opts.collapsibleHideFunction.call(this,t,e):t.hide(this.opts.collapsibleHideDuration,e):canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,t,e):t.hide(this.opts.hideDuration,e),t.dataSM("scroll")&&(this.menuScrollStop(t),t.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).off(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()),t.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false"),t.attr({"aria-expanded":"false","aria-hidden":"true"});var i=t.dataSM("level");this.activatedItems.splice(i-1,1),this.visibleSubMenus.splice($.inArray(t,this.visibleSubMenus),1),this.$root.triggerHandler("hide.smapi",t[0])}},menuHideAll:function(){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);for(var t=this.opts.isPopup?1:0,e=this.visibleSubMenus.length-1;e>=t;e--)this.menuHide(this.visibleSubMenus[e]);this.opts.isPopup&&(canAnimate&&this.$root.stop(!0,!0),this.$root.is(":visible")&&(canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,this.$root):this.$root.hide(this.opts.hideDuration))),this.activatedItems=[],this.visibleSubMenus=[],this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(t){for(var e=this.activatedItems.length-1;e>=t;e--){var i=this.activatedItems[e].dataSM("sub");i&&this.menuHide(i)}},menuInit:function(t){if(!t.dataSM("in-mega")){t.hasClass("mega-menu")&&t.find("ul").dataSM("in-mega",!0);for(var e=2,i=t[0];(i=i.parentNode.parentNode)!=this.$root[0];)e++;var s=t.prevAll("a").eq(-1);s.length||(s=t.prevAll().find("a").eq(-1)),s.addClass("has-submenu").dataSM("sub",t),t.dataSM("parent-a",s).dataSM("level",e).parent().dataSM("sub",t);var o=s.attr("id")||this.accessIdPrefix+ ++this.idInc,a=t.attr("id")||this.accessIdPrefix+ ++this.idInc;s.attr({id:o,"aria-haspopup":"true","aria-controls":a,"aria-expanded":"false"}),t.attr({id:a,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"}),this.opts.subIndicators&&s[this.opts.subIndicatorsPos](this.$subArrow.clone())}},menuPosition:function(t){var e,i,s=t.dataSM("parent-a"),o=s.closest("li"),a=o.parent(),n=t.dataSM("level"),r=this.getWidth(t),h=this.getHeight(t),u=s.offset(),l=u.left,c=u.top,d=this.getWidth(s),m=this.getHeight(s),p=$(window),f=p.scrollLeft(),v=p.scrollTop(),b=this.getViewportWidth(),S=this.getViewportHeight(),g=a.parent().is("[data-sm-horizontal-sub]")||2==n&&!a.hasClass("sm-vertical"),M=this.opts.rightToLeftSubMenus&&!o.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&o.is("[data-sm-reverse]"),w=2==n?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,T=2==n?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY;if(g?(e=M?d-r-w:w,i=this.opts.bottomToTopSubMenus?-h-T:m+T):(e=M?w-r:d-w,i=this.opts.bottomToTopSubMenus?m-T-h:T),this.opts.keepInViewport){var y=l+e,I=c+i;if(M&&f>y?e=g?f-y+e:d-w:!M&&y+r>f+b&&(e=g?f+b-r-y+e:w-r),g||(S>h&&I+h>v+S?i+=v+S-h-I:(h>=S||v>I)&&(i+=v-I)),g&&(I+h>v+S+.49||v>I)||!g&&h>S+.49){var x=this;t.dataSM("scroll-arrows")||t.dataSM("scroll-arrows",$([$('')[0],$('')[0]]).on({mouseenter:function(){t.dataSM("scroll").up=$(this).hasClass("scroll-up"),x.menuScroll(t)},mouseleave:function(e){x.menuScrollStop(t),x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(t){t.preventDefault()}}).insertAfter(t));var A=".smartmenus_scroll";if(t.dataSM("scroll",{y:this.cssTransforms3d?0:i-m,step:1,itemH:m,subH:h,arrowDownH:this.getHeight(t.dataSM("scroll-arrows").eq(1))}).on(getEventsNS({mouseover:function(e){x.menuScrollOver(t,e)},mouseout:function(e){x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(e){x.menuScrollMousewheel(t,e)}},A)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:e+(parseInt(t.css("border-left-width"))||0),width:r-(parseInt(t.css("border-left-width"))||0)-(parseInt(t.css("border-right-width"))||0),zIndex:t.css("z-index")}).eq(g&&this.opts.bottomToTopSubMenus?0:1).show(),this.isFixed()){var C={};C[touchEvents?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp"]=function(e){x.menuScrollTouch(t,e)},t.css({"touch-action":"none","-ms-touch-action":"none"}).on(getEventsNS(C,A))}}}t.css({top:"auto",left:"0",marginLeft:e,marginTop:i-m})},menuScroll:function(t,e,i){var s,o=t.dataSM("scroll"),a=t.dataSM("scroll-arrows"),n=o.up?o.upEnd:o.downEnd;if(!e&&o.momentum){if(o.momentum*=.92,s=o.momentum,.5>s)return this.menuScrollStop(t),void 0}else s=i||(e||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(o.step));var r=t.dataSM("level");if(this.activatedItems[r-1]&&this.activatedItems[r-1].dataSM("sub")&&this.activatedItems[r-1].dataSM("sub").is(":visible")&&this.menuHideSubMenus(r-1),o.y=o.up&&o.y>=n||!o.up&&n>=o.y?o.y:Math.abs(n-o.y)>s?o.y+(o.up?s:-s):n,t.css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+o.y+"px, 0)",transform:"translate3d(0, "+o.y+"px, 0)"}:{marginTop:o.y}),mouse&&(o.up&&o.y>o.downEnd||!o.up&&o.y0;t.dataSM("scroll-arrows").eq(i?0:1).is(":visible")&&(t.dataSM("scroll").up=i,this.menuScroll(t,!0))}e.preventDefault()},menuScrollOut:function(t,e){mouse&&(/^scroll-(up|down)/.test((e.relatedTarget||"").className)||(t[0]==e.relatedTarget||$.contains(t[0],e.relatedTarget))&&this.getClosestMenu(e.relatedTarget)==t[0]||t.dataSM("scroll-arrows").css("visibility","hidden"))},menuScrollOver:function(t,e){if(mouse&&!/^scroll-(up|down)/.test(e.target.className)&&this.getClosestMenu(e.target)==t[0]){this.menuScrollRefreshData(t);var i=t.dataSM("scroll"),s=$(window).scrollTop()-t.dataSM("parent-a").offset().top-i.itemH;t.dataSM("scroll-arrows").eq(0).css("margin-top",s).end().eq(1).css("margin-top",s+this.getViewportHeight()-i.arrowDownH).end().css("visibility","visible")}},menuScrollRefreshData:function(t){var e=t.dataSM("scroll"),i=$(window).scrollTop()-t.dataSM("parent-a").offset().top-e.itemH;this.cssTransforms3d&&(i=-(parseFloat(t.css("margin-top"))-i)),$.extend(e,{upEnd:i,downEnd:i+this.getViewportHeight()-e.subH})},menuScrollStop:function(t){return this.scrollTimeout?(cancelAnimationFrame(this.scrollTimeout),this.scrollTimeout=0,t.dataSM("scroll").step=1,!0):void 0},menuScrollTouch:function(t,e){if(e=e.originalEvent,isTouchEvent(e)){var i=this.getTouchPoint(e);if(this.getClosestMenu(i.target)==t[0]){var s=t.dataSM("scroll");if(/(start|down)$/i.test(e.type))this.menuScrollStop(t)?(e.preventDefault(),this.$touchScrollingSub=t):this.$touchScrollingSub=null,this.menuScrollRefreshData(t),$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp});else if(/move$/i.test(e.type)){var o=void 0!==s.touchY?s.touchY:s.touchStartY;if(void 0!==o&&o!=i.pageY){this.$touchScrollingSub=t;var a=i.pageY>o;void 0!==s.up&&s.up!=a&&$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp}),$.extend(s,{up:a,touchY:i.pageY}),this.menuScroll(t,!0,Math.abs(i.pageY-o))}e.preventDefault()}else void 0!==s.touchY&&((s.momentum=15*Math.pow(Math.abs(i.pageY-s.touchStartY)/(e.timeStamp-s.touchStartTime),2))&&(this.menuScrollStop(t),this.menuScroll(t),e.preventDefault()),delete s.touchY)}}},menuShow:function(t){if((t.dataSM("beforefirstshowfired")||(t.dataSM("beforefirstshowfired",!0),this.$root.triggerHandler("beforefirstshow.smapi",t[0])!==!1))&&this.$root.triggerHandler("beforeshow.smapi",t[0])!==!1&&(t.dataSM("shown-before",!0),canAnimate&&t.stop(!0,!0),!t.is(":visible"))){var e=t.dataSM("parent-a"),i=this.isCollapsible();if((this.opts.keepHighlighted||i)&&e.addClass("highlighted"),i)t.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""});else{if(t.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1),(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth)&&(t.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap"),this.opts.subMenusMinWidth&&t.css("min-width",this.opts.subMenusMinWidth),this.opts.subMenusMaxWidth)){var s=this.getWidth(t);t.css("max-width",this.opts.subMenusMaxWidth),s>this.getWidth(t)&&t.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}this.menuPosition(t)}var o=function(){t.css("overflow","")};i?canAnimate&&this.opts.collapsibleShowFunction?this.opts.collapsibleShowFunction.call(this,t,o):t.show(this.opts.collapsibleShowDuration,o):canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,t,o):t.show(this.opts.showDuration,o),e.attr("aria-expanded","true"),t.attr({"aria-expanded":"true","aria-hidden":"false"}),this.visibleSubMenus.push(t),this.$root.triggerHandler("show.smapi",t[0])}},popupHide:function(t){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},t?1:this.opts.hideTimeout)},popupShow:function(t,e){if(!this.opts.isPopup)return alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.'),void 0;if(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),this.$root.dataSM("shown-before",!0),canAnimate&&this.$root.stop(!0,!0),!this.$root.is(":visible")){this.$root.css({left:t,top:e});var i=this,s=function(){i.$root.css("overflow","")};canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,this.$root,s):this.$root.show(this.opts.showDuration,s),this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(!0),this.init(!0)},rootKeyDown:function(t){if(this.handleEvents())switch(t.keyCode){case 27:var e=this.activatedItems[0];if(e){this.menuHideAll(),e[0].focus();var i=e.dataSM("sub");i&&this.menuHide(i)}break;case 32:var s=$(t.target);if(s.is("a")&&this.handleItemEvents(s)){var i=s.dataSM("sub");i&&!i.is(":visible")&&(this.itemClick({currentTarget:t.target}),t.preventDefault())}}},rootOut:function(t){if(this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),!this.opts.showOnClick||!this.opts.hideOnClick)){var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(t){this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0)},winResize:function(t){if(this.handleEvents()){if(!("onorientationchange"in window)||"orientationchange"==t.type){var e=this.isCollapsible();this.wasCollapsible&&e||(this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0].blur(),this.menuHideAll()),this.wasCollapsible=e}}else if(this.$disableOverlay){var i=this.$root.offset();this.$disableOverlay.css({top:i.top,left:i.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}}}}),$.fn.dataSM=function(t,e){return e?this.data(t+"_smartmenus",e):this.data(t+"_smartmenus")},$.fn.removeDataSM=function(t){return this.removeData(t+"_smartmenus")},$.fn.smartmenus=function(options){if("string"==typeof options){var args=arguments,method=options;return Array.prototype.shift.call(args),this.each(function(){var t=$(this).data("smartmenus");t&&t[method]&&t[method].apply(t,args)})}return this.each(function(){var dataOpts=$(this).data("sm-options")||null;if(dataOpts)try{dataOpts=eval("("+dataOpts+")")}catch(e){dataOpts=null,alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.')}new $.SmartMenus(this,$.extend({},$.fn.smartmenus.defaults,options,dataOpts))})},$.fn.smartmenus.defaults={isPopup:!1,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:!0,subIndicatorsPos:"append",subIndicatorsText:"",scrollStep:30,scrollAccelerate:!0,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(t,e){t.fadeOut(200,e)},collapsibleShowDuration:0,collapsibleShowFunction:function(t,e){t.slideDown(200,e)},collapsibleHideDuration:0,collapsibleHideFunction:function(t,e){t.slideUp(200,e)},showOnClick:!1,hideOnClick:!0,noMouseOver:!1,keepInViewport:!0,keepHighlighted:!0,markCurrentItem:!1,markCurrentTree:!0,rightToLeftSubMenus:!1,bottomToTopSubMenus:!1,collapsibleBehavior:"default"},$}); \ No newline at end of file diff --git a/main_8cpp_source.html b/main_8cpp_source.html new file mode 100644 index 00000000..c1b792fe --- /dev/null +++ b/main_8cpp_source.html @@ -0,0 +1,474 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): src/Runnables/main.cpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Energy Grid Optimization & Analysis (EGOA) 1.0 +
+
+
+ + + + + + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
main.cpp
+
+
+
1/*
+
2 * main.cpp
+
3 *
+
4 * Created on: Sep 13, 2018
+
5 * Author: Franziska Wegner
+
6 */
+
7
+
8#ifdef OPENMP_AVAILABLE
+
9 #include <omp.h>
+
10#endif // OPENMP_AVAILABLE
+
11
+
12#include <clocale>
+
13#include <iostream>
+
14#include <string>
+
15#include <set>
+
16#include <tuple>
+
17
+
18#include <QFile>
+
19#include <QStringList>
+
20
+
21#include "DataStructures/Labels/Label.hpp"
+
22#include "DataStructures/Labels/SusceptanceNormLabel.hpp"
+
23#include "DataStructures/Labels/VoltageAngleDifferenceLabel.hpp"
+
24
+
25#include "Algorithms/SpanningTree/MST.hpp"
+
26#include "Algorithms/SpanningTree/Prim.hpp"
+
27#include "Algorithms/SpanningTree/Kruskal.hpp"
+
28
+
29#include <QTimer>
+
30#include <QDebug>
+
31#include <QString>
+
32#include <QApplication>
+
33#include <QCommandLineParser>
+
34
+
35#include <cassert>
+
36#include <cmath>
+
37#include <ctime>
+
38#include <memory>
+
39#include <type_traits>
+
40
+
41#include "DataStructures/Networks/PowerGrid.hpp"
+
42
+
43#include "DataStructures/Graphs/StaticGraph.hpp"
+
44#include "DataStructures/Graphs/DynamicGraph.hpp"
+
45#include "DataStructures/Graphs/Vertices/Vertex.hpp"
+
46#include "DataStructures/Graphs/Vertices/ElectricalProperties.hpp"
+
47#include "DataStructures/Graphs/Edges/Edge.hpp"
+
48#include "DataStructures/Graphs/Edges/ElectricalProperties.hpp"
+
49
+
50// #include "MathematicalModel/DirectCurrent/DCPF.hpp"
+
51// #include "MathematicalModel/DirectCurrent/DCMPF.hpp"
+
52// #include "MathematicalModel/DirectCurrent/DCMTSF.hpp"
+
53
+
54#include "Auxiliary/Auxiliary.hpp"
+
55#include "Auxiliary/Comparators.hpp"
+
56
+
57#include "IO/PowerGridIO.hpp"
+
58#include "IO/Appearance/Color.hpp"
+
59
+
60QString inputFile(""), outputDir("");
+
61void addCommandLineOptions ( const QCoreApplication &application,
+
62 QCommandLineParser &parser )
+
63{
+
64 parser.setApplicationDescription("Power Grid Tool");
+
65 parser.addHelpOption();
+
66 parser.addVersionOption();
+
67
+
68#pragma mark COMMANDLINE_OPTIONS
+
69 QCommandLineOption algorithmOption(
+
70 "algo",
+
71 QCoreApplication::translate("main", "Algorithm for the problem (default: MILP)."),
+
72 QCoreApplication::translate("main", "algo"), "MILP"
+
73 );
+
74 parser.addOption(algorithmOption);
+
75
+
76 QCommandLineOption variantOption(
+
77 "variant",
+
78 QCoreApplication::translate("main", "Variant for the algorithm (default: ?."),
+
79 QCoreApplication::translate("main", "variant"), "?"
+
80 );
+
81 parser.addOption(variantOption);
+
82
+
83 QCommandLineOption networkSettingOption(
+
84 "networkSetting",
+
85 QCoreApplication::translate("main", "Network setting (default: exact for PF (not changeable), bounded for DCMPF and DCMTSF)."),
+
86 QCoreApplication::translate("main", "networkSetting"), "bounded"
+
87 );
+
88 parser.addOption(networkSettingOption);
+
89
+
90 QCommandLineOption solverOption(
+
91 "solver",
+
92 QCoreApplication::translate("main", "Solver if necessary (default: gurobi)."),
+
93 QCoreApplication::translate("main", "solver"), "gurobi"
+
94 );
+
95 parser.addOption(solverOption);
+
96
+
97 QCommandLineOption inputFileWarmStartOption(
+
98 QStringList() << "inputFileWarmStart",
+
99 QCoreApplication::translate("main", "Input file for the warm start (default: ../Data/windfarm-benchmarksets/testset-0-instance-1.gml)."),
+
100 QCoreApplication::translate("main", "inputFileWarmStart"), "WS-testset-0-instance-1.gml"
+
101 );
+
102 parser.addOption(inputFileWarmStartOption);
+
103
+
104 QCommandLineOption timeOption(
+
105 "time",
+
106 QCoreApplication::translate("main", "--time <time> -- specify time limit in seconds (default: 1h)."),
+
107 QCoreApplication::translate("main", "time"), "3600"
+
108 );
+
109 parser.addOption(timeOption);
+
110
+
111 QCommandLineOption traceSolutionOption(
+
112 "trace",
+
113 QCoreApplication::translate("main", "--trace <true|false> -- Trace solution. (default: false)."),
+
114 QCoreApplication::translate("main", "trace"), "false"
+
115 );
+
116 parser.addOption(traceSolutionOption);
+
117
+
118 QCommandLineOption verboseOption(
+
119 "verbose",
+
120 QCoreApplication::translate("main", "--verbose <true|false> -- Verbose mode. Prints out all information. (default: NA)."),
+
121 QCoreApplication::translate("main", "verbose"), "true"
+
122 );
+
123 parser.addOption(verboseOption);
+
124
+
125 QCommandLineOption outputTypeOption(
+
126 "outputType",
+
127 QCoreApplication::translate("main", "--outputType GML | DOT | PS | PDF | SVG -- Output type. Outputs the result in the output directory. (default: DOT)."),
+
128 QCoreApplication::translate("main", "outputType"), "DOT"
+
129 );
+
130 parser.addOption(outputTypeOption);
+
131
+
132
+
133#pragma mark COMMANDLINE_POSITIONAL_ARGUMENTS
+
134 parser.addPositionalArgument(
+
135 "inputFile",
+
136 QCoreApplication::translate("main", "The input file to open.")
+
137 );
+
138
+
139 parser.addPositionalArgument(
+
140 "outputDir",
+
141 QCoreApplication::translate("main", "The output directory to write files.")
+
142 );
+
143
+
144
+
145#pragma mark COMMANDLINE_CHECKS_AND_PROCESSING
+
146 parser.process(application);
+
147
+
148 const QStringList args = parser.optionNames();
+
149 // if (args.size() < 1) {
+
150 // fprintf(stderr, "%s\n", qPrintable(QCoreApplication::translate("main", "Error: Must specify an argument.")));
+
151 // parser.showHelp(1);
+
152 // exit(1);
+
153 // }
+
154
+
155 QStringList positionalArgs = parser.positionalArguments();
+
156 if (positionalArgs.count() == 2) {
+
157 inputFile = positionalArgs.at(0);
+
158 outputDir = positionalArgs.at(1);
+
159 } else {
+
160 fprintf(stderr, "%s\n", qPrintable(QCoreApplication::translate("main", "Error: Must specify both argument \"inputFile\" and \"outputDir\".")));
+
161 parser.showHelp(1);
+
162 exit(1);
+
163 }
+
164}
+
165
+
166// Decide which graph type to use, meaning either a static or a dynamic graph
+
167#ifndef USE_DYNAMIC_GRAPH
+
168 const bool isStaticGraph = true;
+
169#else
+
170 const bool isStaticGraph = false;
+
171#endif
+
172
+
173#ifndef USE_TYPES_REAL_WEIGHT
+
174 const bool isTypesReal = true;
+
175#else
+
176 const bool isTypesReal = false;
+
177#endif
+
178
+
179typedef std::conditional<isStaticGraph,
+
180 egoa::StaticGraph<egoa::Vertices::ElectricalProperties<>, egoa::Edges::ElectricalProperties>,
+
181 egoa::DynamicGraph<egoa::Vertices::ElectricalProperties<>, egoa::Edges::ElectricalProperties>>::type TGraph;
+
182
+
183typedef std::conditional<isTypesReal,
+
184 egoa::Types::real,
+
185 egoa::Types::posInteger>::type TWeight;
+
186
+
187#ifdef GUROBI_AVAILABLE
+
188 void printGurobiException(const GRBException & e) {
+
189 time_t t = time(nullptr); // get time now
+
190 tm* now = localtime(&t);
+
191 //
+
192 std::cerr << std::string(4*16+3*5, '-') << std::endl;
+
193 std::cerr << std::setw(16) << "Time" << " = " << (now->tm_year + 1900) << '-'
+
194 << (now->tm_mon + 1) << '-'
+
195 << now->tm_mday << " at "
+
196 << now->tm_hour << ':'
+
197 << now->tm_min << ':'
+
198 << now->tm_sec << " o'clock " << std::endl;
+
199 std::cerr << std::setw(16) << "Error code" << " = " << e.getErrorCode() << std::endl;
+
200 std::cerr << std::setw(16) << "Message" << " = " << e.getMessage() << std::endl;
+
201 }
+
202#endif
+
203
+
204void setNetworkSetting(egoa::PowerGrid<TGraph> & network, const QString & networkSetting) {
+
205 if ( networkSetting == "BOUNDED" ) { network.MakeBounded(); }
+
206 else if ( networkSetting == "PUREUNBOUNDED") { network.MakePureUnbounded(); }
+
207 else if ( networkSetting == "UNBOUNDED" ) { network.MakeUnbounded(); }
+
208 else if ( networkSetting == "EXACT" ) { network.MakeExact(); }
+
209}
+
210
+
211auto main(int argc, char * argv []) -> int {
+
212
+
213// Command line parsing
+
214 auto application = std::unique_ptr<QCoreApplication>(std::make_unique<QCoreApplication>(argc, argv));
+
215 QCoreApplication::setApplicationName("GPGT");
+
216 QCoreApplication::setApplicationVersion("Version: 1");
+
217 std::setlocale(LC_NUMERIC, "C");
+
218
+
219// Parse command line
+
220 QCommandLineParser parser;
+
221 addCommandLineOptions(*application, parser);
+
222
+
223 auto algorithm = parser.value("algo").toUpper();
+
224 auto solver = parser.value("solver").toUpper();
+
225 egoa::Types::real timeLimit = parser.value("time").toDouble();
+
226 bool traceSolution = parser.value("trace").toUpper()=="TRUE"?true:false;
+
227 bool verbose = parser.value("verbose").toUpper()=="TRUE"?true:false;;
+
228 auto networkSetting = parser.value("networkSetting").toUpper();
+
229 auto variant = parser.value("variant").toUpper();
+
230 auto outputType = parser.value("outputType").toUpper();
+
231
+
232#ifndef NDEBUG
+
233 qDebug() << Qt::endl;
+
234 qDebug() << "\tInputFile :" << inputFile;
+
235 qDebug() << "\tOutputDir :" << outputDir;
+
236 qDebug() << "\tAlgorithm :" << algorithm;
+
237 qDebug() << "\tVariant :" << variant;
+
238 qDebug() << "\tNetwork :" << networkSetting;
+
239 qDebug() << "\tSolver :" << solver;
+
240 qDebug() << "\tTime :" << QString::number(timeLimit);
+
241 qDebug() << "\tTrace Sol.:" << QString::number(traceSolution);
+
242 qDebug() << "\tVerbose :" << QString::number(verbose);
+
243 qDebug() << "\tOutput Type:" << outputType;
+
244 qDebug() << "---- OpenMP-Info ----------------------------------";
+
245 qDebug() << "\tNumber of Processors: " << egoa::Auxiliary::NumberOfProcessors();
+
246 qDebug() << "\tMaximum number of possible Threads: " << egoa::Auxiliary::MaximumNumberOfThreads();
+
247 qDebug() << "\tNumber of allowed Threads: " << egoa::Auxiliary::NumberOfThreads();
+
248#endif // NDEBUG
+
249
+
250
+
251
+
252// Read graph file
+
253 egoa::PowerGrid<TGraph> network;
+
254 std::string filename = egoa::Auxiliary::Basename( inputFile.toStdString() );
+
255 filename = egoa::Auxiliary::RemoveExtension( filename );
+
256
+
257 if (!egoa::PowerGridIO<TGraph>::read ( network, inputFile.toStdString(), egoa::PowerGridIO<TGraph>::readIeeeCdfMatlab ))
+
258 std::cerr << "Expected file " << inputFile.toStdString() << " does not exist!";
+
259
+
260// Output network
+
261 if (verbose) {
+
262 std::cout << network << std::endl;
+
263
+
264 std::cout << std::string(40, '-')
+
265 << std::endl
+
266 << "\tAlgorithm: " << algorithm.toStdString() << std::endl
+
267 << "\tVariant: " << variant.toStdString() << std::endl
+
268 << std::endl;
+
269 }
+
270
+
271 network.OutputGeneratorSnaps();
+
272 network.OutputLoadSnaps();
+
273
+
274// Decide which algorithm to use
+
275 using TNetwork = egoa::PowerGrid<TGraph>;
+
276 TNetwork resultGraph = network;
+
277 try {
+
278 // std::unique_ptr<egoa::DCPF<TNetwork>> model;
+
279 // if ( algorithm == "DCPF" ) {
+
280 // model = std::make_unique<egoa::DCPF<TNetwork>>( network, filename, timeLimit, false, traceSolution );
+
281 // model->Run();
+
282 // } else if ( algorithm == "DCMPF" ) {
+
283 // model = std::make_unique<egoa::DCMPF<TNetwork>>( network, filename, timeLimit, false, traceSolution );
+
284 // setNetworkSetting(network, networkSetting);
+
285 // model->Run();
+
286 // } else if ( algorithm == "DCMTSF" ) {
+
287 // model = std::make_unique<egoa::DCMTSF<TNetwork>>( network, filename, timeLimit, false, traceSolution );
+
288 // setNetworkSetting(network, networkSetting);
+
289
+
290 // if ( variant == "BIGM" ) { model->SetKVl2BigM(); }
+
291 // else if ( variant == "INDICATOR" ) { model->SetKVl2Indicator(); }
+
292 // else if ( variant == "QUADRATIC" ) { model->SetKVl2Quadratic(); }
+
293 // check variant here
+
294 // model->Run();
+
295 // } else
+
296 if ( algorithm == "MAXST" || algorithm == "2APPROXIMATION" ) {
+
297 auto comparator = [&network](egoa::Types::edgeId lhs, egoa::Types::edgeId rhs) {
+
298 return network.Graph().EdgeAt(lhs).Properties().ThermalLimit()
+
299 > network.Graph().EdgeAt(rhs).Properties().ThermalLimit();
+
300 };
+
301 std::unique_ptr<egoa::MST<TGraph>> mst;
+
302 if ( variant == "KRUSKAL" ) {
+
303 mst = std::make_unique<egoa::Kruskal<TGraph>>( network.Graph(), comparator );
+
304 } else if ( variant == "PRIM" ) {
+
305 mst = std::make_unique<egoa::Prim<TGraph>>( network.Graph(), comparator ); }
+
306 else {
+
307 mst = std::make_unique<egoa::Kruskal<TGraph>>( network.Graph(), comparator );
+
308 }
+
309 mst->Run();
+
310 auto result = mst->Result();
+
311 SwitchEdges(network, result);
+
312 } else if ( algorithm == "MINST" ) {
+
313 auto comparator = [&network](egoa::Types::edgeId lhs, egoa::Types::edgeId rhs) {
+
314 return network.Graph().EdgeAt(lhs).Properties().ThermalLimit()
+
315 < network.Graph().EdgeAt(rhs).Properties().ThermalLimit();
+
316 };
+
317 std::unique_ptr<egoa::MST<TGraph>> mst;
+
318 if ( variant == "KRUSKAL" ) {
+
319 mst = std::make_unique<egoa::Kruskal<TGraph>>( network.Graph(), comparator );
+
320 } else if ( variant == "PRIM" ) {
+
321 mst = std::make_unique<egoa::Prim<TGraph>>( network.Graph(), comparator ); }
+
322 else {
+
323 mst = std::make_unique<egoa::Kruskal<TGraph>>( network.Graph(), comparator );
+
324 }
+
325 mst->Run();
+
326 auto result = mst->Result();
+
327 SwitchEdges(network, result);
+
328 } else {
+
329 //code
+
330 }
+
331
+
332 // if ( verbose && model != nullptr ) {
+
333 // std::cout << "Finished "
+
334 // << algorithm.toStdString()
+
335 // << " with status "
+
336 // << model->Solver().Status()
+
337 // << std::endl;
+
338 // std::cout << *model;
+
339 // std::cout << std::endl << std::endl;
+
340 // }
+
341 // } catch (GRBException e) {
+
342 // printGurobiException(e);
+
343 } catch(...) {
+
344 std::cerr << "Unexpected exception during optimization" << std::endl;
+
345 }
+
346
+
347 // Write out original graph and result graph
+
348 std::string algoFile = filename + "-" + variant.toLower().toStdString() + "-" + algorithm.toLower().toStdString();
+
349 std::string file = filename;
+
350 if ( outputType == "GML" ) {
+
351 // qDebug() << "Output: " << outputType << "\n" << flush;
+
352 egoa::PowerGridIO<TGraph>::write( network , outputDir.toStdString() + file + ".gml", egoa::PowerGridIO<TGraph>::WriteGraphGml );
+
353 egoa::PowerGridIO<TGraph>::write( resultGraph, outputDir.toStdString() + algoFile + ".gml", egoa::PowerGridIO<TGraph>::WriteGraphGml );
+
354 } else if ( outputType == "PDF" ) {
+
355 // qDebug() << "Output: " << outputType << "\n" << flush;
+
356 egoa::PowerGridIO<TGraph>::write( network, outputDir.toStdString() + file + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
357 egoa::PowerGridIO<TGraph>::write( resultGraph, outputDir.toStdString() + algoFile + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
358 system( ("dot -Tps " + outputDir.toStdString() + file + ".dot -o " + outputDir.toStdString() + file + ".pdf").c_str() );
+
359 system( ("dot -Tps " + outputDir.toStdString() + algoFile + ".dot -o " + outputDir.toStdString() + algoFile + ".pdf").c_str() );
+
360 } else if ( outputType == "SVG" ) {
+
361 // qDebug() << "Output: " << outputType << "\n" << flush;
+
362 egoa::PowerGridIO<TGraph>::write( network, outputDir.toStdString() + file + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
363 egoa::PowerGridIO<TGraph>::write( resultGraph, outputDir.toStdString() + algoFile + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
364 system( ("dot -Tps " + outputDir.toStdString() + file + ".dot -o " + outputDir.toStdString() + file + ".svg").c_str() );
+
365 system( ("dot -Tps " + outputDir.toStdString() + algoFile + ".dot -o " + outputDir.toStdString() + algoFile + ".svg").c_str() );
+
366 } else if ( outputType == "NONE" ) {
+
367 // qDebug() << "Output: " << outputType << "\n" << flush;
+
368 } else {
+
369 // qDebug() << "Output: " << outputType << "\n" << flush;
+
370 egoa::PowerGridIO<TGraph>::write( network, outputDir.toStdString() + file + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
371 egoa::PowerGridIO<TGraph>::write( resultGraph, outputDir.toStdString() + algoFile + ".dot", egoa::PowerGridIO<TGraph>::WriteGraphDot );
+
372 system( ("dot -Tps " + outputDir.toStdString() + file + ".dot -o " + outputDir.toStdString() + file + ".ps").c_str() );
+
373 system( ("dot -Tps " + outputDir.toStdString() + algoFile + ".dot -o " + outputDir.toStdString() + algoFile + ".ps").c_str() );
+
374 }
+
375
+
376 return EXIT_SUCCESS;
+
377}
+
egoa::DynamicGraph
A graph data structure that supports adding and removing vertices and edges.
Definition DynamicGraph.hpp:50
+
egoa::Edges::ElectricalProperties
Class having all edge electrical properties (branch properties).
Definition ElectricalProperties.hpp:27
+ +
egoa::PowerGridIO
Class for power grid io.
Definition PowerGridIO.hpp:33
+
egoa::PowerGridIO::write
static bool write(PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)
Function to write a power grid.
Definition PowerGridIO.hpp:210
+
egoa::StaticGraph
A graph data structure that supports adding vertices and edges.
Definition StaticGraph.hpp:52
+
egoa::SwitchEdges
void SwitchEdges(PowerGridType &grid, Subgraph< typename PowerGridType::TGraph > remainingSubgraph)
Switches all edges that do not belong to the subgraph.
Definition PowerGrid.hpp:4363
+
+ +
+Generated by doxygen 1.9.8 +
+ + diff --git a/menu.js b/menu.js new file mode 100644 index 00000000..b0b26936 --- /dev/null +++ b/menu.js @@ -0,0 +1,136 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file + */ +function initMenu(relPath,searchEnabled,serverSide,searchPage,search) { + function makeTree(data,relPath) { + var result=''; + if ('children' in data) { + result+='
    '; + for (var i in data.children) { + var url; + var link; + link = data.children[i].url; + if (link.substring(0,1)=='^') { + url = link.substring(1); + } else { + url = relPath+link; + } + result+='
  • '+ + data.children[i].text+''+ + makeTree(data.children[i],relPath)+'
    • '; + } + result+='
'; + } + return result; + } + var searchBoxHtml; + if (searchEnabled) { + if (serverSide) { + searchBoxHtml='
'+ + '
'+ + '
 '+ + ''+ + '
'+ + '
'+ + '
'+ + '
'; + } else { + searchBoxHtml='
'+ + ''+ + ' '+ + ''+ + ''+ + ''+ + ''+ + ''+ + '
'; + } + } + + $('#main-nav').before('
'+ + ''+ + ''+ + '
'); + $('#main-nav').append(makeTree(menudata,relPath)); + $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu'); + if (searchBoxHtml) { + $('#main-menu').append('
  • '); + } + var $mainMenuState = $('#main-menu-state'); + var prevWidth = 0; + if ($mainMenuState.length) { + function initResizableIfExists() { + if (typeof initResizable==='function') initResizable(); + } + // animate mobile menu + $mainMenuState.change(function(e) { + var $menu = $('#main-menu'); + var options = { duration: 250, step: initResizableIfExists }; + if (this.checked) { + options['complete'] = function() { $menu.css('display', 'block') }; + $menu.hide().slideDown(options); + } else { + options['complete'] = function() { $menu.css('display', 'none') }; + $menu.show().slideUp(options); + } + }); + // set default menu visibility + function resetState() { + var $menu = $('#main-menu'); + var $mainMenuState = $('#main-menu-state'); + var newWidth = $(window).outerWidth(); + if (newWidth!=prevWidth) { + if ($(window).outerWidth()<768) { + $mainMenuState.prop('checked',false); $menu.hide(); + $('#searchBoxPos1').html(searchBoxHtml); + $('#searchBoxPos2').hide(); + } else { + $menu.show(); + $('#searchBoxPos1').empty(); + $('#searchBoxPos2').html(searchBoxHtml); + $('#searchBoxPos2').show(); + } + if (typeof searchBox!=='undefined') { + searchBox.CloseResultsWindow(); + } + prevWidth = newWidth; + } + } + $(window).ready(function() { resetState(); initResizableIfExists(); }); + $(window).resize(resetState); + } + $('#main-menu').smartmenus(); +} +/* @license-end */ diff --git a/menudata.js b/menudata.js new file mode 100644 index 00000000..6ca1ffb2 --- /dev/null +++ b/menudata.js @@ -0,0 +1,130 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file +*/ +var menudata={children:[ +{text:"Main Page",url:"index.html"}, +{text:"Related Pages",url:"pages.html"}, +{text:"Topics",url:"topics.html"}, +{text:"Namespaces",url:"namespaces.html",children:[ +{text:"Namespace List",url:"namespaces.html"}, +{text:"Namespace Members",url:"namespacemembers.html",children:[ +{text:"All",url:"namespacemembers.html"}, +{text:"Functions",url:"namespacemembers_func.html"}, +{text:"Enumerations",url:"namespacemembers_enum.html"}]}]}, +{text:"Classes",url:"annotated.html",children:[ +{text:"Class List",url:"annotated.html"}, +{text:"Class Index",url:"classes.html"}, +{text:"Class Hierarchy",url:"hierarchy.html"}, +{text:"Class Members",url:"functions.html",children:[ +{text:"All",url:"functions.html",children:[ +{text:"a",url:"functions.html#index_a"}, +{text:"b",url:"functions_b.html#index_b"}, +{text:"c",url:"functions_c.html#index_c"}, +{text:"d",url:"functions_d.html#index_d"}, +{text:"e",url:"functions_e.html#index_e"}, +{text:"f",url:"functions_f.html#index_f"}, +{text:"g",url:"functions_g.html#index_g"}, +{text:"h",url:"functions_h.html#index_h"}, +{text:"i",url:"functions_i.html#index_i"}, +{text:"j",url:"functions_j.html#index_j"}, +{text:"k",url:"functions_k.html#index_k"}, +{text:"l",url:"functions_l.html#index_l"}, +{text:"m",url:"functions_m.html#index_m"}, +{text:"n",url:"functions_n.html#index_n"}, +{text:"o",url:"functions_o.html#index_o"}, +{text:"p",url:"functions_p.html#index_p"}, +{text:"q",url:"functions_q.html#index_q"}, +{text:"r",url:"functions_r.html#index_r"}, +{text:"s",url:"functions_s.html#index_s"}, +{text:"t",url:"functions_t.html#index_t"}, +{text:"u",url:"functions_u.html#index_u"}, +{text:"v",url:"functions_v.html#index_v"}, +{text:"w",url:"functions_w.html#index_w"}, +{text:"x",url:"functions_x.html#index_x"}, +{text:"y",url:"functions_y.html#index_y"}, +{text:"z",url:"functions_z.html#index_z"}, +{text:"~",url:"functions_~.html#index__7E"}]}, +{text:"Functions",url:"functions_func.html",children:[ +{text:"a",url:"functions_func.html#index_a"}, +{text:"b",url:"functions_func_b.html#index_b"}, +{text:"c",url:"functions_func_c.html#index_c"}, +{text:"d",url:"functions_func_d.html#index_d"}, +{text:"e",url:"functions_func_e.html#index_e"}, +{text:"f",url:"functions_func_f.html#index_f"}, +{text:"g",url:"functions_func_g.html#index_g"}, +{text:"h",url:"functions_func_h.html#index_h"}, +{text:"i",url:"functions_func_i.html#index_i"}, +{text:"j",url:"functions_func_j.html#index_j"}, +{text:"k",url:"functions_func_k.html#index_k"}, +{text:"l",url:"functions_func_l.html#index_l"}, +{text:"m",url:"functions_func_m.html#index_m"}, +{text:"n",url:"functions_func_n.html#index_n"}, +{text:"o",url:"functions_func_o.html#index_o"}, +{text:"p",url:"functions_func_p.html#index_p"}, +{text:"q",url:"functions_func_q.html#index_q"}, +{text:"r",url:"functions_func_r.html#index_r"}, +{text:"s",url:"functions_func_s.html#index_s"}, +{text:"t",url:"functions_func_t.html#index_t"}, +{text:"u",url:"functions_func_u.html#index_u"}, +{text:"v",url:"functions_func_v.html#index_v"}, +{text:"w",url:"functions_func_w.html#index_w"}, +{text:"z",url:"functions_func_z.html#index_z"}, +{text:"~",url:"functions_func_~.html#index__7E"}]}, +{text:"Variables",url:"functions_vars.html",children:[ +{text:"a",url:"functions_vars.html#index_a"}, +{text:"b",url:"functions_vars_b.html#index_b"}, +{text:"c",url:"functions_vars_c.html#index_c"}, +{text:"d",url:"functions_vars_d.html#index_d"}, +{text:"e",url:"functions_vars_e.html#index_e"}, +{text:"f",url:"functions_vars_f.html#index_f"}, +{text:"g",url:"functions_vars_g.html#index_g"}, +{text:"i",url:"functions_vars_i.html#index_i"}, +{text:"l",url:"functions_vars_l.html#index_l"}, +{text:"m",url:"functions_vars_m.html#index_m"}, +{text:"n",url:"functions_vars_n.html#index_n"}, +{text:"o",url:"functions_vars_o.html#index_o"}, +{text:"p",url:"functions_vars_p.html#index_p"}, +{text:"q",url:"functions_vars_q.html#index_q"}, +{text:"r",url:"functions_vars_r.html#index_r"}, +{text:"s",url:"functions_vars_s.html#index_s"}, +{text:"t",url:"functions_vars_t.html#index_t"}, +{text:"u",url:"functions_vars_u.html#index_u"}, +{text:"v",url:"functions_vars_v.html#index_v"}, +{text:"x",url:"functions_vars_x.html#index_x"}, +{text:"y",url:"functions_vars_y.html#index_y"}, +{text:"z",url:"functions_vars_z.html#index_z"}]}, +{text:"Typedefs",url:"functions_type.html",children:[ +{text:"d",url:"functions_type.html#index_d"}, +{text:"i",url:"functions_type.html#index_i"}, +{text:"p",url:"functions_type.html#index_p"}, +{text:"r",url:"functions_type.html#index_r"}, +{text:"t",url:"functions_type.html#index_t"}, +{text:"v",url:"functions_type.html#index_v"}]}, +{text:"Enumerations",url:"functions_enum.html"}, +{text:"Related Symbols",url:"functions_rela.html",children:[ +{text:"e",url:"functions_rela.html#index_e"}, +{text:"o",url:"functions_rela.html#index_o"}, +{text:"s",url:"functions_rela.html#index_s"}]}]}]}, +{text:"Files",url:"files.html",children:[ +{text:"File List",url:"files.html"}]}]} diff --git a/minus.svg b/minus.svg new file mode 100644 index 00000000..f70d0c1a --- /dev/null +++ b/minus.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/minusd.svg b/minusd.svg new file mode 100644 index 00000000..5f8e8796 --- /dev/null +++ b/minusd.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/namespaceegoa.html b/namespaceegoa.html new file mode 100644 index 00000000..278320aa --- /dev/null +++ b/namespaceegoa.html @@ -0,0 +1,670 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa Namespace Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    +
    +Classes | +Typedefs | +Enumerations | +Functions | +Variables
    +
    egoa Namespace Reference
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Classes

    class  ArticulationVertexDetection
     Class to find articulation vertices. More...
     
    class  BetweennessCentrality
     Class for betweenness centrality. More...
     
    class  BFS
     Class for the Breadth-First Search (BFS). More...
     
    class  BinaryHeap
     Class for binary heap data structure. More...
     
    class  BlockCutTree
     A block-cut tree. More...
     
    class  BlockCutTreeTraversal
     Traverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited. More...
     
    class  Bound
     Class for bounds. More...
     
    class  BoundMismatch
     
    class  Bucket
     Class for bucket data structure. More...
     
    class  BucketElement
     Class representing the minimal bucket element. More...
     
    class  CallbackEmpty
     
    class  Color
     
    class  DepthFirstSearch
     Class for the Depth-First Search (DFS). More...
     
    class  DominatingThetaPath
     Class for dominating theta path. More...
     
    class  DynamicGraph
     A graph data structure that supports adding and removing vertices and edges. More...
     
    class  GurobiSolver
     
    class  IeeeCdfMatlabParser
     
    class  Kruskal
     An implementation of Kruskal's algorithm for finding minimum spanning trees. More...
     
    class  Label
     Interface for label. More...
     
    class  MappingBinaryHeap
     Class for binary heap data structure, in which elements are sorted by keys. More...
     
    class  MST
     Base class for minimum spanning tree algorithms. More...
     
    class  OmittingIterator
     An iterator that omits elements of a range if another range of bool indicates that the element is invalid. More...
     
    class  PowerGrid
     
    class  PowerGridIO
     Class for power grid io. More...
     
    class  Prim
     An implementation of Prim's algorithm for finding minimum spanning trees. More...
     
    class  PriorityQueue
     
    class  PyPsaParser
     
    class  Queue
     
    class  StaticGraph
     A graph data structure that supports adding vertices and edges. More...
     
    class  StdQueue
     
    class  Stroke
     
    class  Subgraph
     A subgraph of an existing graph. More...
     
    class  SusceptanceNormLabel
     Class for Susceptance norm label. More...
     
    class  Traversal
     Interface for graph traversal. More...
     
    class  UnionFind
     This class describes an union find. More...
     
    class  VectorBasedComparator
     A comparator that compares based on elements in the vector. More...
     
    class  VectorView
     Provides a restricted view on a vector. More...
     
    class  VoltageAngleDifferenceLabel
     Class for Voltage Angle Difference label. More...
     
    + + + + + +

    +Typedefs

    using ubyte_array = std::array< Types::ubyte, 3 >
     
    using float_array = std::array< Types::real, 3 >
     
    + + + + + + + + + + + +

    +Enumerations

    enum class  CentralityCounter { counterAtEdges = 0 +, counterAtVertices = 1 + }
     
    enum class  DfsEdgeType {
    +  tree = 0 +, backward = 1 +, forward = 2 +, cross = 3 +,
    +  none = 99 +
    + }
     
    enum class  ExecutionPolicy { sequential +, parallel +, breakable + }
     Execution policies for for loops. More...
     
    enum class  DominationCriterion { weak = 0 +, strict = 1 +, none = 2 + }
     Domination criterion. More...
     
    + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    template<typename GraphType >
    BlockCutTree< GraphType > buildBlockCutTree (GraphType const &graph)
     Builds a block-cut tree.
     
    template<typename GraphType >
    std::ostream & operator<< (std::ostream &os, Subgraph< GraphType > const &subgraph)
     
    template<typename PowerGridType >
    void SwitchEdges (PowerGridType &grid, Subgraph< typename PowerGridType::TGraph > remainingSubgraph)
     Switches all edges that do not belong to the subgraph.
     
    template<typename ElementType , bool Const>
    std::ostream & operator<< (std::ostream &os, VectorView< ElementType, Const > const &view)
     Prints a VectorView.
     
    template<typename T >
    void my_exception (T arg1, T arg2, const char *file, const char *func, size_t line)
     
    Power grid conversion methods
    Types::string BoundTypeToString (Vertices::BoundType const &boundType)
     
    + + + + + +

    +Variables

    std::array RGB
     
    std::array ArithmeticRGB
     
    +

    Detailed Description

    +

    Subgraph.hpp

    +

    Created on: May 8, 2019 Author: Franziska Wegner, Matthias Wolf

    +

    VectorView.hpp

    +

    Created on: May 8, 2019 Author: Matthias Wolf

    +

    Typedef Documentation

    + +

    ◆ float_array

    + +
    +
    + + + + +
    using egoa::float_array = typedef std::array<Types::real,3>
    +
    + +

    Definition at line 18 of file Color.cpp.

    + +
    +
    + +

    ◆ ubyte_array

    + +
    +
    + + + + +
    using egoa::ubyte_array = typedef std::array<Types::ubyte,3>
    +
    + +

    Definition at line 17 of file Color.cpp.

    + +
    +
    +

    Enumeration Type Documentation

    + +

    ◆ CentralityCounter

    + +
    +
    + + + + + +
    + + + + +
    enum class egoa::CentralityCounter
    +     		+strong
    +
    + +

    Definition at line 20 of file BetweennessCentrality.hpp.

    + +
    +
    + +

    ◆ DfsEdgeType

    + +
    +
    + + + + + +
    + + + + +
    enum class egoa::DfsEdgeType
    +     		+strong
    +
    + +

    Definition at line 16 of file DepthFirstSearch.hpp.

    + +
    +
    + +

    ◆ DominationCriterion

    + +
    +
    + + + + + +
    + + + + +
    enum class egoa::DominationCriterion
    +     		+strong
    +
    + +

    Domination criterion.

    +

    Classification of different possible dominations for different kinds of bucket usages, where

    +

    weak means either <= or >=, strict means either < or >, and none means no domination criterion, and thus no element filter.

    +

    The sign depends on the comparator.

    + +

    Definition at line 24 of file DominationCriterion.hpp.

    + +
    +
    + +

    ◆ ExecutionPolicy

    + +
    +
    + + + + + +
    + + + + +
    enum class egoa::ExecutionPolicy
    +     		+strong
    +
    + +

    Execution policies for for loops.

    + + + + +
    Enumerator
    sequential 

    The loop is run sequentially.

    +
    parallel 

    The loop is run in parallel using OpenMP.

    +
    breakable 

    The loop is run sequentially until the function returns false.

    +
    + +

    Definition at line 15 of file ExecutionPolicy.hpp.

    + +
    +
    +

    Function Documentation

    + +

    ◆ BoundTypeToString()

    + +
    +
    + + + + + +
    + + + + + + + + +
    Types::string egoa::BoundTypeToString (Vertices::BoundType const & boundType)
    +     		+inline
    +
    + +

    Definition at line 19 of file Type.hpp.

    + +
    +
    + +

    ◆ my_exception()

    + +
    +
    +
    +template<typename T >
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    void egoa::my_exception (T arg1,
    T arg2,
    const char * file,
    const char * func,
    size_t line 
    )
    +
    + +

    Definition at line 23 of file Exceptions.hpp.

    + +
    +
    + +

    ◆ operator<<() [1/2]

    + +
    +
    +
    +template<typename GraphType >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    std::ostream & egoa::operator<< (std::ostream & os,
    Subgraph< GraphType > const & subgraph 
    )
    +     		+inline
    +
    + +

    Definition at line 134 of file Subgraph.hpp.

    + +
    +
    + +

    ◆ operator<<() [2/2]

    + +
    +
    +
    +template<typename ElementType , bool Const>
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    std::ostream & egoa::operator<< (std::ostream & os,
    VectorView< ElementType, Const > const & view 
    )
    +     		+inline
    +
    + +

    Prints a VectorView.

    +
    Parameters
    + + + +
    osThe output stream.
    viewThe view.
    +
    +
    +
    Returns
    os
    + +

    Definition at line 67 of file VectorView.hpp.

    + +
    +
    + +

    ◆ SwitchEdges()

    + +
    +
    +
    +template<typename PowerGridType >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    void egoa::SwitchEdges (PowerGridType & grid,
    Subgraph< typename PowerGridType::TGraph > remainingSubgraph 
    )
    +     		+inline
    +
    + +

    Switches all edges that do not belong to the subgraph.

    +

    For all edges in the subgraph set edge.Properties().Status() = false and edge.Properties().Type() = Edges::ElectricalEdgeType::standard .

    +

    For all other edges set edge.Properties().Status() = true and edge.Properties().Type() = Edges::ElectricalEdgeType::switched .

    +
    Parameters
    + + + +
    gridThe grid
    [in]remainingSubgraphThe subgraph whose edges are not switched.
    +
    +
    +
    Template Parameters
    + + +
    PowerGridTypeThe type of the power grid.
    +
    +
    + +

    Definition at line 4363 of file PowerGrid.hpp.

    + +
    +
    +

    Variable Documentation

    + +

    ◆ ArithmeticRGB

    + +
    +
    + + + + +
    std::array egoa::ArithmeticRGB
    +
    + +

    Definition at line 243 of file Color.cpp.

    + +
    +
    + +

    ◆ RGB

    + +
    +
    + + + + +
    std::array egoa::RGB
    +
    + +

    Definition at line 20 of file Color.cpp.

    + +
    +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/namespacemembers.html b/namespacemembers.html new file mode 100644 index 00000000..e341f388 --- /dev/null +++ b/namespacemembers.html @@ -0,0 +1,85 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Namespace Members + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Here is a list of all documented namespace members with links to the namespaces they belong to:
      +
    • buildBlockCutTree() : egoa
      • +
    • DominationCriterion : egoa
      • +
    • ExecutionPolicy : egoa
      • +
    • operator<<() : egoa
      • +
    • SwitchEdges() : egoa
      • +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/namespacemembers_enum.html b/namespacemembers_enum.html new file mode 100644 index 00000000..ce3bc713 --- /dev/null +++ b/namespacemembers_enum.html @@ -0,0 +1,82 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Namespace Members + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Here is a list of all documented namespace enums with links to the namespaces they belong to:
      +
    • DominationCriterion : egoa
      • +
    • ExecutionPolicy : egoa
      • +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/namespacemembers_func.html b/namespacemembers_func.html new file mode 100644 index 00000000..d18cdc51 --- /dev/null +++ b/namespacemembers_func.html @@ -0,0 +1,83 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Namespace Members + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Here is a list of all documented namespace functions with links to the namespaces they belong to:
      +
    • buildBlockCutTree() : egoa
      • +
    • operator<<() : egoa
      • +
    • SwitchEdges() : egoa
      • +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/namespaces.html b/namespaces.html new file mode 100644 index 00000000..508ea4b7 --- /dev/null +++ b/namespaces.html @@ -0,0 +1,128 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Namespace List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Namespace List
    +
    +
    +
    Here is a list of all documented namespaces with brief descriptions:
    +
    [detail level 123]
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
     ▼Negoa
     CArticulationVertexDetectionClass to find articulation vertices
     CBetweennessCentralityClass for betweenness centrality
     CBFSClass for the Breadth-First Search (BFS)
     ▼CBinaryHeapClass for binary heap data structure
     CHeapIteratorClass for a heap iterator
     ▼CBlockCutTreeA block-cut tree
     CBlockA block
     CCutVertexClass for cut-vertices
     CBlockCutTreeTraversalTraverses a block-cut tree in a post-order traversal, i.e., a node of the tree is visited directly after all its child nodes have been visited
     CBoundClass for bounds
     CBoundMismatch
     CBucketClass for bucket data structure
     CBucketElementClass representing the minimal bucket element
     CCallbackEmpty
     CColor
     CDepthFirstSearchClass for the Depth-First Search (DFS)
     CDominatingThetaPathClass for dominating theta path
     ▼CDynamicGraphA graph data structure that supports adding and removing vertices and edges
     COmittingVectorViewA view on a vector, in which some elements are invalid
     CGurobiSolver
     CIeeeCdfMatlabParser
     CKruskalAn implementation of Kruskal's algorithm for finding minimum spanning trees
     CLabelInterface for label
     CMappingBinaryHeapClass for binary heap data structure, in which elements are sorted by keys
     CMSTBase class for minimum spanning tree algorithms
     COmittingIteratorAn iterator that omits elements of a range if another range of bool indicates that the element is invalid
     CPowerGrid
     CPowerGridIOClass for power grid io
     CPrimAn implementation of Prim's algorithm for finding minimum spanning trees
     CPriorityQueue
     CPyPsaParser
     CQueue
     CStaticGraphA graph data structure that supports adding vertices and edges
     CStdQueue
     CStroke
     CSubgraphA subgraph of an existing graph
     CSusceptanceNormLabelClass for Susceptance norm label
     CTraversalInterface for graph traversal
     CUnionFindThis class describes an union find
     CVectorBasedComparatorA comparator that compares based on elements in the vector
     CVectorViewProvides a restricted view on a vector
     CVoltageAngleDifferenceLabelClass for Voltage Angle Difference label
    +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/nav_f.png b/nav_f.png new file mode 100644 index 00000000..72a58a52 Binary files /dev/null and b/nav_f.png differ diff --git a/nav_fd.png b/nav_fd.png new file mode 100644 index 00000000..032fbdd4 Binary files /dev/null and b/nav_fd.png differ diff --git a/nav_g.png b/nav_g.png new file mode 100644 index 00000000..2093a237 Binary files /dev/null and b/nav_g.png differ diff --git a/nav_h.png b/nav_h.png new file mode 100644 index 00000000..33389b10 Binary files /dev/null and b/nav_h.png differ diff --git a/nav_hd.png b/nav_hd.png new file mode 100644 index 00000000..de80f18a Binary files /dev/null and b/nav_hd.png differ diff --git a/open.png b/open.png new file mode 100644 index 00000000..30f75c7e Binary files /dev/null and b/open.png differ diff --git a/pages.html b/pages.html new file mode 100644 index 00000000..2d27f2f1 --- /dev/null +++ b/pages.html @@ -0,0 +1,86 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Related Pages + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Related Pages
    +
    +
    +
    Here is a list of all related documentation pages:
    + + +
     Todo List
    +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/plus.svg b/plus.svg new file mode 100644 index 00000000..07520165 --- /dev/null +++ b/plus.svg @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plusd.svg b/plusd.svg new file mode 100644 index 00000000..0c65bfe9 --- /dev/null +++ b/plusd.svg @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/search/all_0.js b/search/all_0.js new file mode 100644 index 00000000..59fe0990 --- /dev/null +++ b/search/all_0.js @@ -0,0 +1,118 @@ +var searchData= +[ + ['addbusname_0',['AddBusName',['../classegoa_1_1_py_psa_parser.html#a3445016279bc2b5d0139e6e6a3af31d7',1,'egoa::PyPsaParser']]], + ['addbustypetovertexproperty_1',['AddBusTypeToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a267b6c68d44045136157fc575bb8e9e4',1,'egoa::PyPsaParser']]], + ['addcapitalcosttoedge_2',['AddCapitalCostToEdge',['../classegoa_1_1_py_psa_parser.html#a8a3ab49107b8ac190e2dc8098645ee53',1,'egoa::PyPsaParser']]], + ['addcapitalcosttogenerator_3',['AddCapitalCostToGenerator',['../classegoa_1_1_py_psa_parser.html#af3b8f72c1af8b46de2e2b0ed0f03e4c7',1,'egoa::PyPsaParser']]], + ['addcarriertogenerator_4',['AddCarrierToGenerator',['../classegoa_1_1_py_psa_parser.html#a89eef36bf9edca65b06ea02e523d3538',1,'egoa::PyPsaParser']]], + ['addcarriertovertexproperty_5',['AddCarrierToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a5a3d4c37488ede00304bf274cca4bde5',1,'egoa::PyPsaParser']]], + ['addcommittabilitytogenerator_6',['AddCommittabilityToGenerator',['../classegoa_1_1_py_psa_parser.html#a5959ade2e11c2968eb8ac1c25fba8139',1,'egoa::PyPsaParser']]], + ['addconductanceputoedge_7',['AddConductancePuToEdge',['../classegoa_1_1_py_psa_parser.html#adf9f3ae85d25a714155930753e3db4cf',1,'egoa::PyPsaParser']]], + ['addconductancetoedge_8',['AddConductanceToEdge',['../classegoa_1_1_py_psa_parser.html#af933482c7f2b6bcb702438bef55914ca',1,'egoa::PyPsaParser']]], + ['addcontroltypetogenerator_9',['AddControlTypeToGenerator',['../classegoa_1_1_py_psa_parser.html#a5f75742ec279b9cb8d35abeb0bb39401',1,'egoa::PyPsaParser']]], + ['addcontroltypetovertexproperty_10',['AddControlTypeToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a9fca664987df8bf47cdbf82e4ca373f7',1,'egoa::PyPsaParser']]], + ['addcountrytovertexproperty_11',['AddCountryToVertexProperty',['../classegoa_1_1_py_psa_parser.html#adffe09c74ce9767c0fa01193d9bee719',1,'egoa::PyPsaParser']]], + ['addedge_12',['addedge',['../classegoa_1_1_dynamic_graph.html#a5435904379c51b02d70aa860aa6b92f5',1,'egoa::DynamicGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)'],['../classegoa_1_1_dynamic_graph.html#a6d8011dbc01c7a4b165c2e9f4106128e',1,'egoa::DynamicGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)'],['../classegoa_1_1_static_graph.html#ab11e90bbb1a1ecb5150f6d9c6c952eb5',1,'egoa::StaticGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)'],['../classegoa_1_1_static_graph.html#af526a9476c1329be5b972fd0df7cf16f',1,'egoa::StaticGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)'],['../classegoa_1_1_py_psa_parser.html#af4e9ee451975f96d88c9ed78fb794581',1,'egoa::PyPsaParser::AddEdge()'],['../classegoa_1_1_dynamic_graph.html#adabca8848d02cae2543fdb670dda8704',1,'egoa::DynamicGraph::AddEdge()']]], + ['addedgetocurrentblock_13',['AddEdgeToCurrentBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#af65e7c2bfd5561fd25f1fc02fc0faa78',1,'egoa::internal::BlockCutTreeBuilder']]], + ['addeffectivereactanceputoedge_14',['AddEffectiveReactancePuToEdge',['../classegoa_1_1_py_psa_parser.html#ae552905f45d584bbda5b32df6a5fe965',1,'egoa::PyPsaParser']]], + ['addeffectiveresistanceputoedge_15',['AddEffectiveResistancePuToEdge',['../classegoa_1_1_py_psa_parser.html#abad2b2546156ff3d1c381df68ca4bfd2',1,'egoa::PyPsaParser']]], + ['addgeneratorat_16',['addgeneratorat',['../classegoa_1_1_power_grid.html#af4f06ba244cb4a872d90358547151435',1,'egoa::PowerGrid::AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties const &generatorProperty)'],['../classegoa_1_1_power_grid.html#afd5f83de414a797957b7a23af63d0c9b',1,'egoa::PowerGrid::AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &&generatorProperty)'],['../classegoa_1_1_power_grid.html#add1dda403c34d4716e7a009d48032d20',1,'egoa::PowerGrid::AddGeneratorAt(TVertex const &vertex, TGeneratorProperties const &generatorProperty)'],['../classegoa_1_1_power_grid.html#ab8e76feffea66ff5bddbf04e95115637',1,'egoa::PowerGrid::AddGeneratorAt(TVertex const &vertex, TGeneratorProperties &&generatorProperty)']]], + ['addgeneratorefficiencytogenerator_17',['AddGeneratorEfficiencyToGenerator',['../classegoa_1_1_py_psa_parser.html#a27e5608532759d924c50e51f0acbbe6e',1,'egoa::PyPsaParser']]], + ['addgeneratorrealpowersnapshotat_18',['AddGeneratorRealPowerSnapshotAt',['../classegoa_1_1_power_grid.html#a5ccae8fc77cb3e2499cb6d38b8920ab1',1,'egoa::PowerGrid']]], + ['addgeneratorsigntogenerator_19',['AddGeneratorSignToGenerator',['../classegoa_1_1_py_psa_parser.html#a500bbb72a57cf596507cc9aa5be8d435',1,'egoa::PyPsaParser']]], + ['addinitialstatustogenerator_20',['AddInitialStatusToGenerator',['../classegoa_1_1_py_psa_parser.html#a55f213f4f4ff15d3719cec888e8b606f',1,'egoa::PyPsaParser']]], + ['addlengthtoedge_21',['AddLengthToEdge',['../classegoa_1_1_py_psa_parser.html#ad1146569450485e0d914f2768db623a1',1,'egoa::PyPsaParser']]], + ['addlinetypetoedge_22',['AddLineTypeToEdge',['../classegoa_1_1_py_psa_parser.html#a5ae1fccec5f6144151c0af1e17690512',1,'egoa::PyPsaParser']]], + ['addloadat_23',['addloadat',['../classegoa_1_1_power_grid.html#ab8c968ca493b8ae790ebd2a37ccbe1d5',1,'egoa::PowerGrid::AddLoadAt(Types::vertexId vertexId, TLoadProperties load)'],['../classegoa_1_1_power_grid.html#abc5e24c98548509f9c4d704dcb212646',1,'egoa::PowerGrid::AddLoadAt(TVertex const &vertex, TLoadProperties const &load)'],['../classegoa_1_1_power_grid.html#ad2a4a48ed221fc2e0b29a4b51470ebaf',1,'egoa::PowerGrid::AddLoadAt(TVertex const &vertex, TLoadProperties &&load)']]], + ['addloadsnapshotat_24',['AddLoadSnapshotAt',['../classegoa_1_1_power_grid.html#ab7430a1550c051dea28013b52dfe2ba5',1,'egoa::PowerGrid']]], + ['addloadtimestampname_25',['AddLoadTimestampName',['../classegoa_1_1_py_psa_parser.html#a4cf1c63e979e2b34d3ddf8747d6189f0',1,'egoa::PyPsaParser']]], + ['addmarginalcosttogenerator_26',['AddMarginalCostToGenerator',['../classegoa_1_1_py_psa_parser.html#aaf663ec9428365d50be86ee96186316f',1,'egoa::PyPsaParser']]], + ['addmarginalpricetovertexproperty_27',['AddMarginalPriceToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a1f2c18588d754ec9a35fc62cbd687515',1,'egoa::PyPsaParser']]], + ['addmaximalnominalapparentpowertoedge_28',['AddMaximalNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a3af9200e6a2cbe47c5db559d9eafe9a5',1,'egoa::PyPsaParser']]], + ['addmaximumapparentpowerputoedge_29',['AddMaximumApparentPowerPuToEdge',['../classegoa_1_1_py_psa_parser.html#ac61ba5042bf0ed39be8ed6cc083f74c8',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowerputogenerator_30',['AddMaximumRealPowerPuToGenerator',['../classegoa_1_1_py_psa_parser.html#abbf462aaafc602afdd096f50a40df63d',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowersnapshotputogenerator_31',['AddMaximumRealPowerSnapshotPuToGenerator',['../classegoa_1_1_py_psa_parser.html#ab4fa84d0c2103dfff6db038b6ba02d56',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowersnapshotputoload_32',['AddMaximumRealPowerSnapshotPuToLoad',['../classegoa_1_1_py_psa_parser.html#ae74d4506eb14af74aa9684dc6539e436',1,'egoa::PyPsaParser']]], + ['addmaximumvoltageangletoedge_33',['AddMaximumVoltageAngleToEdge',['../classegoa_1_1_py_psa_parser.html#a0029747b2df51dc934d72b431a579d8a',1,'egoa::PyPsaParser']]], + ['addmaximumvoltagemagnitudeputovertexproperty_34',['AddMaximumVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a95aeb7455ea5567fcfcede5b8c77e76f',1,'egoa::PyPsaParser']]], + ['addminimumdowntimetogenerator_35',['AddMinimumDownTimeToGenerator',['../classegoa_1_1_py_psa_parser.html#a59636265bf2177685bf40d9ad8b7d8ac',1,'egoa::PyPsaParser']]], + ['addminimumnominalapparentpowertoedge_36',['AddMinimumNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a328bbbf60111118f39182052d8012af2',1,'egoa::PyPsaParser']]], + ['addminimumrealpowerputogenerator_37',['AddMinimumRealPowerPuToGenerator',['../classegoa_1_1_py_psa_parser.html#a78461a34d2f35f0d1614e7e248896dc6',1,'egoa::PyPsaParser']]], + ['addminimumuptimetogenerator_38',['AddMinimumUpTimeToGenerator',['../classegoa_1_1_py_psa_parser.html#a9ca5064ef4d41c25650275fd87d3c921',1,'egoa::PyPsaParser']]], + ['addminimumvoltageangletoedge_39',['AddMinimumVoltageAngleToEdge',['../classegoa_1_1_py_psa_parser.html#ac13bd228023a22570721e72aff72643e',1,'egoa::PyPsaParser']]], + ['addminimumvoltagemagnitudeputovertexproperty_40',['AddMinimumVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#aa6c6b530808a2adbfac8c3c0a00ae722',1,'egoa::PyPsaParser']]], + ['addmulowertoedge_41',['AddMuLowerToEdge',['../classegoa_1_1_py_psa_parser.html#a00aa91dd90ee03f156f7b8e507bc0d42',1,'egoa::PyPsaParser']]], + ['addmuuppertoedge_42',['AddMuUpperToEdge',['../classegoa_1_1_py_psa_parser.html#a7adf777fefad31730ada3227475cb598',1,'egoa::PyPsaParser']]], + ['addnametoedge_43',['AddNameToEdge',['../classegoa_1_1_py_psa_parser.html#acb81c15c7f1babff4f76cddc194c4b20',1,'egoa::PyPsaParser']]], + ['addnametogenerator_44',['AddNameToGenerator',['../classegoa_1_1_py_psa_parser.html#a654232a8589378058746994983876c6c',1,'egoa::PyPsaParser']]], + ['addnametoload_45',['AddNameToLoad',['../classegoa_1_1_py_psa_parser.html#a6200d5d2384df18d859fe14d7715641e',1,'egoa::PyPsaParser']]], + ['addnominalapparentpowertoedge_46',['AddNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a3749f6dcbc1a6eb0327857541da8ba3b',1,'egoa::PyPsaParser']]], + ['addnominalextendableapparentpowertoedge_47',['AddNominalExtendableApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#ac9e2fedfdd421ceac8586b4b111d5e6b',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogenerator_48',['AddNominalRealPowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a528d9a8b071397539c0eaff65a23dbe6',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratorextendable_49',['AddNominalRealPowerToGeneratorExtendable',['../classegoa_1_1_py_psa_parser.html#ae85ae02a32544fe4e92317ed1e6b857b',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratormax_50',['AddNominalRealPowerToGeneratorMax',['../classegoa_1_1_py_psa_parser.html#ad696d7c972812e61bcf5db4560156105',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratormin_51',['AddNominalRealPowerToGeneratorMin',['../classegoa_1_1_py_psa_parser.html#a6affd1ff402423f3478853eb0713ff79',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratoropt_52',['AddNominalRealPowerToGeneratorOpt',['../classegoa_1_1_py_psa_parser.html#a1bea8fa187445da489d2ce3839d47e0e',1,'egoa::PyPsaParser']]], + ['addnominalvoltagetoedge_53',['AddNominalVoltageToEdge',['../classegoa_1_1_py_psa_parser.html#a5b7bb16c8d32386e26e6584674558e3f',1,'egoa::PyPsaParser']]], + ['addnominalvoltagetovertexproperty_54',['AddNominalVoltageToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a75ae9723dbf9cb5cbc1462699e79bfba',1,'egoa::PyPsaParser']]], + ['addnumberofparallellinestoedge_55',['AddNumberOfParallelLinesToEdge',['../classegoa_1_1_py_psa_parser.html#aee9c0e8ea3779a38f18fe9f21feca1cd',1,'egoa::PyPsaParser']]], + ['addoptimalnominalapparentpowertoedge_56',['AddOptimalNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a7f5db2c7f17b7cb20a60800e48e53bb4',1,'egoa::PyPsaParser']]], + ['addp0toedge_57',['AddP0ToEdge',['../classegoa_1_1_py_psa_parser.html#a49a2fce6db4f4b8e537bc6e80ff43e40',1,'egoa::PyPsaParser']]], + ['addp1toedge_58',['AddP1ToEdge',['../classegoa_1_1_py_psa_parser.html#ae7be1c269bfd4f3bb57b7f8b05202def',1,'egoa::PyPsaParser']]], + ['addq0toedge_59',['AddQ0ToEdge',['../classegoa_1_1_py_psa_parser.html#a5698989ef63c2f0134228e0a3a368c3f',1,'egoa::PyPsaParser']]], + ['addq1toedge_60',['AddQ1ToEdge',['../classegoa_1_1_py_psa_parser.html#a9a73cd4e3263564fb0f7b41dba8e19b4',1,'egoa::PyPsaParser']]], + ['addramplimitdowntogenerator_61',['AddRampLimitDownToGenerator',['../classegoa_1_1_py_psa_parser.html#aa6bc287a8d396d4966a4cf63e8a78137',1,'egoa::PyPsaParser']]], + ['addramplimitshutdowntogenerator_62',['AddRampLimitShutDownToGenerator',['../classegoa_1_1_py_psa_parser.html#a2447ed28cc087517ba5146cd88c73d80',1,'egoa::PyPsaParser']]], + ['addramplimitstartuptogenerator_63',['AddRampLimitStartUpToGenerator',['../classegoa_1_1_py_psa_parser.html#aa7f182b89cabce6fd56c00ddc85e8f01',1,'egoa::PyPsaParser']]], + ['addramplimituptogenerator_64',['AddRampLimitUpToGenerator',['../classegoa_1_1_py_psa_parser.html#a467aa671e02046c19b58abe7668c02b0',1,'egoa::PyPsaParser']]], + ['addreactanceputoedge_65',['AddReactancePuToEdge',['../classegoa_1_1_py_psa_parser.html#a75b3a79b14f82449457b91153a9af4a6',1,'egoa::PyPsaParser']]], + ['addreactancetoedge_66',['AddReactanceToEdge',['../classegoa_1_1_py_psa_parser.html#a92f246728777b798029405d570755f82',1,'egoa::PyPsaParser']]], + ['addreactivepowersetpointtogenerator_67',['AddReactivePowerSetPointToGenerator',['../classegoa_1_1_py_psa_parser.html#a3a320502f9aa2ca1498638ef4710636f',1,'egoa::PyPsaParser']]], + ['addreactivepowersetpointtoload_68',['AddReactivePowerSetPointToLoad',['../classegoa_1_1_py_psa_parser.html#a9d396a453ab25b94d4339f1ae5281c2e',1,'egoa::PyPsaParser']]], + ['addreactivepowertogenerator_69',['AddReactivePowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a554183d1c3dda989bfc7385b4fa11481',1,'egoa::PyPsaParser']]], + ['addreactivepowertoload_70',['AddReactivePowerToLoad',['../classegoa_1_1_py_psa_parser.html#ab7ef70610a7ca8570176955102d87e48',1,'egoa::PyPsaParser']]], + ['addreactivepowertovertexproperty_71',['AddReactivePowerToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a49918356dff806452257bfeaabfdcde3',1,'egoa::PyPsaParser']]], + ['addrealpowersetpointtogenerator_72',['AddRealPowerSetPointToGenerator',['../classegoa_1_1_py_psa_parser.html#a6ff64b521042388bd26aa89c061626f1',1,'egoa::PyPsaParser']]], + ['addrealpowersetpointtoload_73',['AddRealPowerSetPointToLoad',['../classegoa_1_1_py_psa_parser.html#aff8fdf549c004d8fd0819f5ad16593f8',1,'egoa::PyPsaParser']]], + ['addrealpowertogenerator_74',['AddRealPowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a1eecef897a21752551db7c8d8a1d7e9e',1,'egoa::PyPsaParser']]], + ['addrealpowertoload_75',['AddRealPowerToLoad',['../classegoa_1_1_py_psa_parser.html#a15e28022605aa4bdfa0432d2978d2594',1,'egoa::PyPsaParser']]], + ['addrealpowertovertexproperty_76',['AddRealPowerToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a0f06ef0fd22dbd0b5e9447053220c209',1,'egoa::PyPsaParser']]], + ['addresistanceputoedge_77',['AddResistancePuToEdge',['../classegoa_1_1_py_psa_parser.html#afd773348d59e2b09a7e35b28ecb07d36',1,'egoa::PyPsaParser']]], + ['addresistancetoedge_78',['AddResistanceToEdge',['../classegoa_1_1_py_psa_parser.html#aefd7779c64c8efb97949c56a4fcc2549',1,'egoa::PyPsaParser']]], + ['addshutdowncosttogenerator_79',['AddShutDownCostToGenerator',['../classegoa_1_1_py_psa_parser.html#a33ef74f205ebb6ce472be63878ce2e00',1,'egoa::PyPsaParser']]], + ['addsigntoload_80',['AddSignToLoad',['../classegoa_1_1_py_psa_parser.html#aab6985a24f772074a7e5d13dc0281695',1,'egoa::PyPsaParser']]], + ['addsnapshottimestamp_81',['AddSnapshotTimestamp',['../classegoa_1_1_power_grid.html#aac315c4caad0e761a489d33aae8945ae',1,'egoa::PowerGrid']]], + ['addsnapshotweighting_82',['AddSnapshotWeighting',['../classegoa_1_1_power_grid.html#ad82909d39614c8a4421a662267928a3b',1,'egoa::PowerGrid']]], + ['addsourcevertextoedge_83',['AddSourceVertexToEdge',['../classegoa_1_1_py_psa_parser.html#a8f5f01567a2f2e8db338b15d52f07cc2',1,'egoa::PyPsaParser']]], + ['addstartupcosttogenerator_84',['AddStartUpCostToGenerator',['../classegoa_1_1_py_psa_parser.html#a27211926b5e9be1b0be1713a4052f333',1,'egoa::PyPsaParser']]], + ['addstatustogenerator_85',['AddStatusToGenerator',['../classegoa_1_1_py_psa_parser.html#a1d7b852dd0d6a202ce32f78b31486e32',1,'egoa::PyPsaParser']]], + ['addsubnetworktoedge_86',['AddSubnetworkToEdge',['../classegoa_1_1_py_psa_parser.html#a0011a70723b8c8bcd65add93545a9f3f',1,'egoa::PyPsaParser']]], + ['addsubnetworktovertexproperty_87',['AddSubnetworkToVertexProperty',['../classegoa_1_1_py_psa_parser.html#abf059d71bb8543b0f06a995d9f758c63',1,'egoa::PyPsaParser']]], + ['addsusceptanceputoedge_88',['AddSusceptancePuToEdge',['../classegoa_1_1_py_psa_parser.html#a9a43a85bbdeb4cd756a64df4eaa9fa57',1,'egoa::PyPsaParser']]], + ['addsusceptancetoedge_89',['AddSusceptanceToEdge',['../classegoa_1_1_py_psa_parser.html#ad0001244f15f85e4f9d1716470f2db28',1,'egoa::PyPsaParser']]], + ['addtargetvertextoedge_90',['AddTargetVertexToEdge',['../classegoa_1_1_py_psa_parser.html#ab09280ee3271fa5ddc1990b4b8a939b0',1,'egoa::PyPsaParser']]], + ['addterrainfactortoedge_91',['AddTerrainFactorToEdge',['../classegoa_1_1_py_psa_parser.html#a858468364914a03e1efd793e1873e670',1,'egoa::PyPsaParser']]], + ['addtimestampofgenerator_92',['AddTimestampOfGenerator',['../classegoa_1_1_py_psa_parser.html#a3c8df9c7f7f81217165e8b55c248e412',1,'egoa::PyPsaParser']]], + ['addtypetogenerator_93',['AddTypeToGenerator',['../classegoa_1_1_py_psa_parser.html#aa8b3363a453ee05b1b8ca65de0f98be4',1,'egoa::PyPsaParser']]], + ['addtypetoload_94',['AddTypeToLoad',['../classegoa_1_1_py_psa_parser.html#abc00a92a8db93792260d690657e599c1',1,'egoa::PyPsaParser']]], + ['addvertex_95',['addvertex',['../classegoa_1_1_static_graph.html#af3ef46db810c3affbf125b6bebe28f42',1,'egoa::StaticGraph::AddVertex()'],['../classegoa_1_1_dynamic_graph.html#a6c86a1e253d1df5abbafa919f51bdbfc',1,'egoa::DynamicGraph::AddVertex()'],['../classegoa_1_1_static_graph.html#ad480d6a773c928c2c93f292ec5352b26',1,'egoa::StaticGraph::AddVertex()'],['../classegoa_1_1_dynamic_graph.html#a95407d696b80b5bdf06170b6d37b3994',1,'egoa::DynamicGraph::AddVertex(TVertexProperties const &properties)'],['../classegoa_1_1_dynamic_graph.html#af2fcdca888289c2aaa9a90ef506a33e5',1,'egoa::DynamicGraph::AddVertex(TVertexProperties &properties)'],['../classegoa_1_1_py_psa_parser.html#aafc76b33a5ddd9fd3cef2ab36e33a5b7',1,'egoa::PyPsaParser::AddVertex()']]], + ['addvertextocurrentblock_96',['AddVertexToCurrentBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#af4df260da8c36657f63907cc84bd24c8',1,'egoa::internal::BlockCutTreeBuilder']]], + ['addvoltageangletovertexproperty_97',['AddVoltageAngleToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a8a4a373d318646adefb51d0d19e125c3',1,'egoa::PyPsaParser']]], + ['addvoltagemagnitudepusetpointtovertexproperty_98',['AddVoltageMagnitudePuSetPointToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a7750d668c3d227d5dd84f6b3905b4d1a',1,'egoa::PyPsaParser']]], + ['addvoltagemagnitudeputovertexproperty_99',['AddVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a33ba1ef1e1ed48b166a1427c94abd9c7',1,'egoa::PyPsaParser']]], + ['addweighttogenerator_100',['AddWeightToGenerator',['../classegoa_1_1_py_psa_parser.html#a8ee58d638aca31409e5221ac34eba752',1,'egoa::PyPsaParser']]], + ['addxcoordinatetovertexproperty_101',['AddXcoordinateToVertexProperty',['../classegoa_1_1_py_psa_parser.html#abb7c70692c13dd42eab7e81568ba4588',1,'egoa::PyPsaParser']]], + ['addycoordinatetovertexproperty_102',['AddYcoordinateToVertexProperty',['../classegoa_1_1_py_psa_parser.html#ab6306a46c3512737760c87ad60a85dea',1,'egoa::PyPsaParser']]], + ['algo_5f_103',['algo_',['../classegoa_1_1_betweenness_centrality.html#a0e369f6d2dfbd88b4a1f5a67ed5f7b0c',1,'egoa::BetweennessCentrality']]], + ['algorithm_104',['algorithm',['../classegoa_1_1_betweenness_centrality.html#aeaababaccedb091ec99c3374a3c023f0',1,'egoa::BetweennessCentrality::Algorithm()'],['../classegoa_1_1_betweenness_centrality.html#a3a786cdf4fd7f3ec530eb6754e125d08',1,'egoa::BetweennessCentrality::Algorithm() const']]], + ['and_20functions_105',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['angleshift_5f_106',['angleShift_',['../classegoa_1_1_edges_1_1_electrical_properties.html#ae603826f29e604edf3d8f85b2704f0f3',1,'egoa::Edges::ElectricalProperties']]], + ['apf_107',['apf',['../classegoa_1_1_vertices_1_1_generator_properties.html#a42ec385b8d1dd14bf270fa64862c715b',1,'egoa::Vertices::GeneratorProperties::Apf() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2b6a862388168431cd64652cb51f1a7b',1,'egoa::Vertices::GeneratorProperties::Apf()']]], + ['apf_5f_108',['apf_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a3addc036600e18a8fa498c05ec2e8f6d',1,'egoa::Vertices::GeneratorProperties']]], + ['area_109',['area',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4b8b9a433956953145d67bab0969ef5d',1,'egoa::Vertices::ElectricalProperties::Area() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a1aa339af06301ec17619b525689adf3b',1,'egoa::Vertices::ElectricalProperties::Area()']]], + ['area_5f_110',['area_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a50d0fd8d3038db07a0ec2acf620b7de3',1,'egoa::Vertices::ElectricalProperties']]], + ['articulationvertexdetection_111',['ArticulationVertexDetection',['../classegoa_1_1_articulation_vertex_detection.html',1,'egoa']]], + ['articulationvertexdetection_3c_20graphtype_2c_20false_20_3e_112',['ArticulationVertexDetection< GraphType, false >',['../classegoa_1_1_articulation_vertex_detection.html',1,'egoa']]], + ['associategeneratorwithbus_113',['AssociateGeneratorWithBus',['../classegoa_1_1_py_psa_parser.html#a7459411be4145d39566609a33daef74f',1,'egoa::PyPsaParser']]], + ['associateloadwithvertex_114',['AssociateLoadWithVertex',['../classegoa_1_1_py_psa_parser.html#a66ae1ccdb5f5c017f65424e734c549b6',1,'egoa::PyPsaParser']]] +]; diff --git a/search/all_1.js b/search/all_1.js new file mode 100644 index 00000000..45b46c48 --- /dev/null +++ b/search/all_1.js @@ -0,0 +1,50 @@ +var searchData= +[ + ['back_0',['back',['../classegoa_1_1_binary_heap.html#a7147b7725db2104890631797df129d21',1,'egoa::BinaryHeap::Back() const'],['../classegoa_1_1_binary_heap.html#af4e3c696496fdce5f9083fbfa227e080',1,'egoa::BinaryHeap::Back()']]], + ['basemva_1',['basemva',['../classegoa_1_1_power_grid.html#adf506f99b8484ade676d5fccf391ed85',1,'egoa::PowerGrid::BaseMva()'],['../classegoa_1_1_power_grid.html#acd2fd791ef9c602d0641cd64d21fed75',1,'egoa::PowerGrid::BaseMva() const']]], + ['basemva_5f_2',['baseMva_',['../classegoa_1_1_power_grid.html#aee077f52470c0202aadd59160171de1c',1,'egoa::PowerGrid']]], + ['begin_3',['begin',['../classegoa_1_1_binary_heap.html#a41608cd5b4174c68dfa0724a829580a5',1,'egoa::BinaryHeap']]], + ['begin_5f_4',['begin_',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a4d7ca6d2f83251dd6dbb376609cf6f16',1,'egoa::BinaryHeap::HeapIterator']]], + ['betweennesscentrality_5',['betweennesscentrality',['../classegoa_1_1_betweenness_centrality.html',1,'egoa::BetweennessCentrality< GraphType, PathFindingAlgorithm, MeasurementCollection, CentralityCounterType >'],['../classegoa_1_1_betweenness_centrality.html#a219fa47c10a5c4b753869a2380ac1c62',1,'egoa::BetweennessCentrality::BetweennessCentrality()']]], + ['bfs_6',['BFS',['../classegoa_1_1_b_f_s.html',1,'egoa']]], + ['binaryheap_7',['binaryheap',['../classegoa_1_1_binary_heap.html#aba83b6ec8280405111f4a7017d30539b',1,'egoa::BinaryHeap::BinaryHeap(std::vector< TElement > const &elements)'],['../classegoa_1_1_binary_heap.html#aed6d9f5c7953ac8a5396f57a4808c6d8',1,'egoa::BinaryHeap::BinaryHeap()'],['../classegoa_1_1_binary_heap.html',1,'egoa::BinaryHeap< ElementType >']]], + ['binaryheap_3c_20voltageangledifferencelabel_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_20_3e_20_3e_8',['BinaryHeap< VoltageAngleDifferenceLabel< Edges::Edge< Edges::ElectricalProperties > > >',['../classegoa_1_1_binary_heap.html',1,'egoa']]], + ['binaryheapcheck_9',['BinaryHeapCheck',['../classegoa_1_1internal_1_1_binary_heap_check.html',1,'egoa::internal']]], + ['binaryheapcheck_3c_20type_2c_20false_20_3e_10',['BinaryHeapCheck< Type, false >',['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html',1,'egoa::internal']]], + ['binaryheapcheck_3c_20type_2c_20true_20_3e_11',['BinaryHeapCheck< Type, true >',['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_12',['BinaryHeapLoopDifferentiation',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_20const_2c_20executionpolicy_3a_3abreakable_20_3e_13',['BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_20const_2c_20executionpolicy_3a_3asequential_20_3e_14',['BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3abreakable_20_3e_15',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3aparallel_20_3e_16',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3asequential_20_3e_17',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['block_18',['Block',['../classegoa_1_1_block_cut_tree_1_1_block.html',1,'egoa::BlockCutTree']]], + ['block_20cut_20tree_20related_20classes_20and_20functions_19',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['blockat_20',['BlockAt',['../classegoa_1_1_block_cut_tree.html#a874dcff7204e23eb06b656b1aa0a2c8a',1,'egoa::BlockCutTree']]], + ['blockcuttree_21',['BlockCutTree',['../classegoa_1_1_block_cut_tree.html',1,'egoa']]], + ['blockcuttree_3c_20tgraph_20_3e_22',['BlockCutTree< TGraph >',['../classegoa_1_1_block_cut_tree.html',1,'egoa']]], + ['blockcuttreebuilder_23',['blockcuttreebuilder',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#adde87192716b708b9471deebf5d5c224',1,'egoa::internal::BlockCutTreeBuilder::BlockCutTreeBuilder()'],['../classegoa_1_1internal_1_1_block_cut_tree_builder.html',1,'egoa::internal::BlockCutTreeBuilder< GraphType >']]], + ['blockcuttreetraversal_24',['blockcuttreetraversal',['../classegoa_1_1_block_cut_tree_traversal.html#ac487550340394894511662124d4afff5',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, CutVertex const &root)'],['../classegoa_1_1_block_cut_tree_traversal.html#a04f97c0ddaa770310aed3f419185652b',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, TNode root)'],['../classegoa_1_1_block_cut_tree_traversal.html#a5814d7135026368eb8cfd890ef5cebf9',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree)'],['../classegoa_1_1_block_cut_tree_traversal.html',1,'egoa::BlockCutTreeTraversal< GraphType >']]], + ['blockofedge_25',['BlockOfEdge',['../classegoa_1_1_block_cut_tree.html#a401278536936af4febd2c969cbe1ca75',1,'egoa::BlockCutTree']]], + ['blockofedge_5f_26',['blockOfEdge_',['../classegoa_1_1_block_cut_tree.html#a2718f96e5443d39aee127cd9dc2d9853',1,'egoa::BlockCutTree']]], + ['blocks_27',['Blocks',['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html#a7b18ad7af34c6cc15740442af6c4546d',1,'egoa::BlockCutTree::CutVertex']]], + ['blocks_5f_28',['blocks_',['../classegoa_1_1_block_cut_tree.html#aa39630251d548a200e701540495995df',1,'egoa::BlockCutTree']]], + ['blocksofvertex_29',['BlocksOfVertex',['../classegoa_1_1_block_cut_tree.html#a4fa6e7ab1b7adb4569f547e393b5104c',1,'egoa::BlockCutTree']]], + ['blocksofvertex_5f_30',['blocksOfVertex_',['../classegoa_1_1_block_cut_tree.html#a77f9d5cdec2009bc76e2b7bb357d77b3',1,'egoa::BlockCutTree']]], + ['blockunderconstruction_31',['BlockUnderConstruction',['../structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction.html',1,'egoa::internal::BlockCutTreeBuilder']]], + ['bound_32',['bound',['../classegoa_1_1_bound.html',1,'egoa::Bound< BoundType >'],['../classegoa_1_1_bound.html#a0f3a93cd13fa2be64dc86e9c795cf984',1,'egoa::Bound::Bound()']]], + ['bound_3c_20types_3a_3areal_20_3e_33',['Bound< Types::real >',['../classegoa_1_1_bound.html',1,'egoa']]], + ['boundmismatch_34',['boundmismatch',['../classegoa_1_1_bound_mismatch.html#aea104d9f29cf77ddb37bd1a67d74763e',1,'egoa::BoundMismatch::BoundMismatch()'],['../classegoa_1_1_bound_mismatch.html',1,'egoa::BoundMismatch']]], + ['breakable_35',['breakable',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a29ec0ca77cfb897451dceae1cde2e9e8',1,'egoa']]], + ['breakable_5ffor_5fall_5fedges_5fat_36',['breakable_for_all_edges_at',['../classegoa_1_1_traversal.html#a0de63cb32b6f954f3e8d30b4af8c2bb9',1,'egoa::Traversal']]], + ['bucket_37',['bucket',['../classegoa_1_1_bucket.html',1,'egoa::Bucket< PriorityQueue >'],['../classegoa_1_1_bucket.html#a9a615b2348db1435db53d42caae51c3d',1,'egoa::Bucket::Bucket()']]], + ['bucketelement_38',['bucketelement',['../classegoa_1_1_bucket_element.html#a35453483cbc516788738758d21b9e8a5',1,'egoa::BucketElement::BucketElement(TElement value, bool valid)'],['../classegoa_1_1_bucket_element.html#a6b56d8f5e486789136563256d5614093',1,'egoa::BucketElement::BucketElement(TElement element)'],['../classegoa_1_1_bucket_element.html',1,'egoa::BucketElement< ElementType >']]], + ['bucketloopdifferentiation_39',['BucketLoopDifferentiation',['../classegoa_1_1internal_1_1_bucket_loop_differentiation.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3abreakable_20_3e_40',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3aparallel_20_3e_41',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3asequential_20_3e_42',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['build_43',['build',['../classegoa_1_1_block_cut_tree.html#a7349ba96044deedda9bccf07f631ceb4',1,'egoa::BlockCutTree::Build()'],['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#ae76c6aca56d8f920d976e1a9dc2dac7d',1,'egoa::internal::BlockCutTreeBuilder::Build()']]], + ['buildblockcuttree_44',['buildBlockCutTree',['../group__bctree.html#gac2b3e1c1f521eca70968599a7d50d3e2',1,'egoa']]], + ['buildingruntimeseconds_45',['BuildingRuntimeSeconds',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a74f7c93e4370e8b065c50d92c300e9ff',1,'egoa::IO::SolverRuntimeRow']]], + ['buildwith_46',['buildwith',['../classegoa_1_1_binary_heap.html#ac2edbdf1dc2971c2c507c085e63f0e72',1,'egoa::BinaryHeap::BuildWith()'],['../classegoa_1_1_priority_queue.html#a94d54d6e5b9ba377ed95cbe3fa3d4e7f',1,'egoa::PriorityQueue::BuildWith()']]] +]; diff --git a/search/all_10.js b/search/all_10.js new file mode 100644 index 00000000..4e2b725a --- /dev/null +++ b/search/all_10.js @@ -0,0 +1,11 @@ +var searchData= +[ + ['qc1bound_0',['qc1bound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a014a858b61cc46d290aea2709a60b65f',1,'egoa::Vertices::GeneratorProperties::Qc1Bound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a723c05f065705dc9e98fa338c0ec4aec',1,'egoa::Vertices::GeneratorProperties::Qc1Bound()']]], + ['qc1bound_5f_1',['qc1Bound_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a3b7527ab7cf18528b3b0507ea07ac9fb',1,'egoa::Vertices::GeneratorProperties']]], + ['qc2bound_2',['qc2bound',['../classegoa_1_1_vertices_1_1_generator_properties.html#af05a082df8fc2c2940c3785723dbb8a0',1,'egoa::Vertices::GeneratorProperties::Qc2Bound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#adb4182ed6efe1c13915150c4c4e56c09',1,'egoa::Vertices::GeneratorProperties::Qc2Bound()']]], + ['qc2bound_5f_3',['qc2Bound_',['../classegoa_1_1_vertices_1_1_generator_properties.html#ad147a28db24c637dd09722ef87188879',1,'egoa::Vertices::GeneratorProperties']]], + ['queue_4',['Queue',['../classegoa_1_1_queue.html',1,'egoa']]], + ['queue_5f_5',['queue_',['../classegoa_1_1_b_f_s.html#aec0bd71e2e23861a1e07f134e947c27e',1,'egoa::BFS::queue_'],['../classegoa_1_1_dominating_theta_path.html#ac178df4334c4a2cd17a26dbd76895185',1,'egoa::DominatingThetaPath::queue_']]], + ['queuedeleteminimum_6',['QueueDeleteMinimum',['../classegoa_1_1_dominating_theta_path.html#ae4b44e835c6123fb83d1cd1696a31579',1,'egoa::DominatingThetaPath']]], + ['queueempty_7',['QueueEmpty',['../classegoa_1_1_dominating_theta_path.html#abb76294b3c10fb5fc56394a66b57d554',1,'egoa::DominatingThetaPath']]] +]; diff --git a/search/all_11.js b/search/all_11.js new file mode 100644 index 00000000..a77d03b3 --- /dev/null +++ b/search/all_11.js @@ -0,0 +1,76 @@ +var searchData= +[ + ['ramp10_0',['ramp10',['../classegoa_1_1_vertices_1_1_generator_properties.html#af4b142757e3410920306713d595a75d9',1,'egoa::Vertices::GeneratorProperties::Ramp10()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2b9e3ef3b94a13691de4700270a0b9ff',1,'egoa::Vertices::GeneratorProperties::Ramp10() const']]], + ['ramp10_5f_1',['ramp10_',['../classegoa_1_1_vertices_1_1_generator_properties.html#aeb0b158d90d8e2f5bcfadfa04733f254',1,'egoa::Vertices::GeneratorProperties']]], + ['ramp30_2',['ramp30',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0d5c17f4dbf4afd36b0c8b3bfbc9d95f',1,'egoa::Vertices::GeneratorProperties::Ramp30() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#abf8fc3420ac6a9b7e63a3f5d5fd9de37',1,'egoa::Vertices::GeneratorProperties::Ramp30()']]], + ['ramp30_5f_3',['ramp30_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a37e07db76d7537ce3217c59a67ca5c22',1,'egoa::Vertices::GeneratorProperties']]], + ['rampagc_4',['rampagc',['../classegoa_1_1_vertices_1_1_generator_properties.html#a53f32577000a34f41f72b42a373b055b',1,'egoa::Vertices::GeneratorProperties::RampAgc() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a27280374423f01d45115110519ad451f',1,'egoa::Vertices::GeneratorProperties::RampAgc()']]], + ['rampagc_5f_5',['rampAgc_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5e17929c9573f7e2e1940d73e006ac46',1,'egoa::Vertices::GeneratorProperties']]], + ['ramplimitdown_6',['ramplimitdown',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa41b37f35b5a43fb93326481dbb8eb7e',1,'egoa::Vertices::GeneratorProperties::RampLimitDown() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8762430d9fc121a39d4eb8dae42d4120',1,'egoa::Vertices::GeneratorProperties::RampLimitDown()']]], + ['ramplimitdown_5f_7',['rampLimitDown_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0633b699635081eaecfd3e8e16b7a568',1,'egoa::Vertices::GeneratorProperties']]], + ['ramplimitshutdown_8',['ramplimitshutdown',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5b9eb7d984a3cc1dc9c1ddaecc4ff4d2',1,'egoa::Vertices::GeneratorProperties::RampLimitShutDown() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8e244ba49628a8fae46fb2eb968ab578',1,'egoa::Vertices::GeneratorProperties::RampLimitShutDown()']]], + ['ramplimitshutdown_5f_9',['rampLimitShutDown_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a32f4f0f5916f0ca68da30f641d1fdd04',1,'egoa::Vertices::GeneratorProperties']]], + ['ramplimitstartup_10',['ramplimitstartup',['../classegoa_1_1_vertices_1_1_generator_properties.html#af1e033f5e2afe770f805c3e6cf130453',1,'egoa::Vertices::GeneratorProperties::RampLimitStartUp() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ae76bd6acfee87cb7f0448933d3f70df3',1,'egoa::Vertices::GeneratorProperties::RampLimitStartUp()']]], + ['ramplimitstartup_5f_11',['rampLimitStartUp_',['../classegoa_1_1_vertices_1_1_generator_properties.html#ad91c9c7998c3c0a4ae0fc732e1499dc6',1,'egoa::Vertices::GeneratorProperties']]], + ['ramplimitup_12',['ramplimitup',['../classegoa_1_1_vertices_1_1_generator_properties.html#a6b7c85c77b3c510ce0dd9c711be521bd',1,'egoa::Vertices::GeneratorProperties::RampLimitUp() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ad652a617a102ea8e411d69f0f582354a',1,'egoa::Vertices::GeneratorProperties::RampLimitUp()']]], + ['ramplimitup_5f_13',['rampLimitUp_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a83998c650ae4f8b4b51a18efded3919e',1,'egoa::Vertices::GeneratorProperties']]], + ['rampq_14',['rampq',['../classegoa_1_1_vertices_1_1_generator_properties.html#a6c83113062e7ebf59d4e8ae5c9e2b656',1,'egoa::Vertices::GeneratorProperties::RampQ() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a9727ceba91f0c1368acde06c83da1be1',1,'egoa::Vertices::GeneratorProperties::RampQ()']]], + ['rampq_5f_15',['rampQ_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a7d1de3e67044c75313cd69747d3ed50a',1,'egoa::Vertices::GeneratorProperties']]], + ['range_16',['Range',['../classegoa_1_1_bound.html#a1b784093b7f3f93e40fde7ebe0ffb157',1,'egoa::Bound']]], + ['reactance_5f_17',['reactance_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a3904d5c1c0ececacb9087a1bd9593360',1,'egoa::Edges::ElectricalProperties']]], + ['reactivepower_18',['reactivepower',['../classegoa_1_1_vertices_1_1_generator_properties.html#af761e8418a57b1b49d1f988a4704d9cf',1,'egoa::Vertices::GeneratorProperties::ReactivePower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2638096b1f58a70af684ac4122739862',1,'egoa::Vertices::GeneratorProperties::ReactivePower()']]], + ['reactivepower_5f_19',['reactivePower_',['../classegoa_1_1_vertices_1_1_generator_properties.html#abf2055994c73c916bab1c000f3f186eb',1,'egoa::Vertices::GeneratorProperties']]], + ['reactivepowerbound_20',['reactivepowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa4440d418ec103efecb9e0372f75534c',1,'egoa::Vertices::GeneratorProperties::ReactivePowerBound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2debdf69d9a0eb109ba6a68bdf14516e',1,'egoa::Vertices::GeneratorProperties::ReactivePowerBound()']]], + ['reactivepowerbound_5f_21',['reactivePowerBound_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8bd1eaaffa84c273938ae4484d2121cf',1,'egoa::Vertices::GeneratorProperties']]], + ['reactivepowerload_22',['reactivepowerload',['../classegoa_1_1_vertices_1_1_load_properties.html#ab87c60ebbb19607f300f6daf87351621',1,'egoa::Vertices::LoadProperties::ReactivePowerLoad() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#a469a7d86b06b8904f078d1b9061b9c8b',1,'egoa::Vertices::LoadProperties::ReactivePowerLoad()']]], + ['reactivepowerload_5f_23',['reactivePowerLoad_',['../classegoa_1_1_vertices_1_1_load_properties.html#aa25c82ef656fb269d972ea5a168859c7',1,'egoa::Vertices::LoadProperties']]], + ['reactivepowerloadbound_24',['reactivepowerloadbound',['../classegoa_1_1_vertices_1_1_load_properties.html#a40cb4d1e9a1cd0399827c3e87ab1f661',1,'egoa::Vertices::LoadProperties::ReactivePowerLoadBound() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#a1aabf52802f8d2386c07db037b6ef2a0',1,'egoa::Vertices::LoadProperties::ReactivePowerLoadBound()']]], + ['reactivepowerloadbound_5f_25',['reactivePowerLoadBound_',['../classegoa_1_1_vertices_1_1_load_properties.html#a60ce200dea1291b3c00d06357f6bcee6',1,'egoa::Vertices::LoadProperties']]], + ['read_26',['read',['../classegoa_1_1_power_grid_i_o.html#a1ddb7b91a3789094587c4359457ddcae',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStringBased reader=PowerGridIO< GraphType >::read)'],['../classegoa_1_1_power_grid_i_o.html#ab6c7b284f94ff047853fd4c7f6ffeeda',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename, ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader=PowerGridIO< GraphType >::read)'],['../classegoa_1_1_power_grid_i_o.html#a2948d89a83f9ea8368068f18149905c2',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStreamBased reader=PowerGridIO< GraphType >::read)'],['../classegoa_1_1_power_grid_i_o.html#a5ef60b5da88230f9f18baf295cb61ae4',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#a1473163c2bf05490fca49ff87c4ef042',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::istream &input_stream)'],['../classegoa_1_1_py_psa_parser.html#a3e83cd88ca4fdb401efb0a05a098fe5a',1,'egoa::PyPsaParser::read(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)'],['../classegoa_1_1_py_psa_parser.html#a2f8cd295e12fc19ff512f5f8a1d7b83a',1,'egoa::PyPsaParser::read(TNetwork &network, std::string const &filename)']]], + ['readable_27',['Readable',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ab27e0b1a7ea5bf91bcfc7e79deccf844',1,'egoa::IO::GeoJsonWriter']]], + ['readbasemva_28',['readBaseMva',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a6a8fb203082a3704e912f879af6b1da3',1,'egoa::IeeeCdfMatlabParser']]], + ['readbranchmatrix_29',['readBranchMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#aab179d28aae1e1f8beae96f823ea2492',1,'egoa::IeeeCdfMatlabParser']]], + ['readbuses_30',['ReadBuses',['../classegoa_1_1_py_psa_parser.html#aaa1b7b4395e7c4bc137eecbc5c0b8335',1,'egoa::PyPsaParser']]], + ['readbusmatrix_31',['readBusMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#aeb931c8dea794813f2eef7072407fdb4',1,'egoa::IeeeCdfMatlabParser']]], + ['readcarriers_32',['ReadCarriers',['../classegoa_1_1_py_psa_parser.html#a82090f1864e8027c223264297a32346b',1,'egoa::PyPsaParser']]], + ['readcasename_33',['readCaseName',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a1fbea31b2ed5715a5b16da2ced9c8754',1,'egoa::IeeeCdfMatlabParser']]], + ['readcompletenetwork_34',['readcompletenetwork',['../classegoa_1_1_py_psa_parser.html#a120aa4bca295b0dfc6a5c29707d8e55b',1,'egoa::PyPsaParser::ReadCompleteNetwork(TNetwork &network, std::string const &filename)'],['../classegoa_1_1_py_psa_parser.html#a1ad8bf82ea077f9cff68234045ad928b',1,'egoa::PyPsaParser::ReadCompleteNetwork(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)']]], + ['readgeneratormatrix_35',['readGeneratorMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#add80c979e0e2b2bbb1c84ce237072117',1,'egoa::IeeeCdfMatlabParser']]], + ['readgenerators_36',['ReadGenerators',['../classegoa_1_1_py_psa_parser.html#a55de696ad6ab7a55b663a9811baf830e',1,'egoa::PyPsaParser']]], + ['readgeneratorsrealpowermaxpu_37',['ReadGeneratorsRealPowerMaxPu',['../classegoa_1_1_py_psa_parser.html#a8f322c88e239f52e1ec6d53b006e6f74',1,'egoa::PyPsaParser']]], + ['readglobalconstraints_38',['ReadGlobalConstraints',['../classegoa_1_1_py_psa_parser.html#abfe41edb56a3f8683ecdc0f767e77a04',1,'egoa::PyPsaParser']]], + ['readgraphgml_39',['ReadGraphGml',['../classegoa_1_1_power_grid_i_o.html#a2259a05ec96e90ac30e957b732a6efcd',1,'egoa::PowerGridIO']]], + ['readieeecdfmatlab_40',['readIeeeCdfMatlab',['../classegoa_1_1_power_grid_i_o.html#a359196094df5704c21eb9b2829ba5f0e',1,'egoa::PowerGridIO']]], + ['readline_41',['ReadLine',['../classegoa_1_1_py_psa_parser.html#a3613605957f4afdfccf915081fdd9c6f',1,'egoa::PyPsaParser']]], + ['readlines_42',['ReadLines',['../classegoa_1_1_py_psa_parser.html#a1da3a5940b5ddbc8872f0f95080bb457',1,'egoa::PyPsaParser']]], + ['readloads_43',['ReadLoads',['../classegoa_1_1_py_psa_parser.html#a5cb9f55ee9149d457ab74a1b85e43de1',1,'egoa::PyPsaParser']]], + ['readloadspset_44',['ReadLoadsPset',['../classegoa_1_1_py_psa_parser.html#a8db656a77a1d4986cb1a7d91f820fcac',1,'egoa::PyPsaParser']]], + ['readnetwork_45',['readnetwork',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a399b96926adc854193983e680cea41c8',1,'egoa::IeeeCdfMatlabParser::readNetwork()'],['../classegoa_1_1_py_psa_parser.html#a672874174d008c35709d19c00aba5696',1,'egoa::PyPsaParser::ReadNetwork()']]], + ['readpypsa_46',['readpypsa',['../classegoa_1_1_power_grid_i_o.html#ac0b7db858e4106bd471df6303d1f3699',1,'egoa::PowerGridIO::ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#ad10b09c3c60c127139ad4168a0201c06',1,'egoa::PowerGridIO::ReadPyPsa(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)']]], + ['readsnapshots_47',['ReadSnapshots',['../classegoa_1_1_py_psa_parser.html#ac8665942230fce5984f6434af811393a',1,'egoa::PyPsaParser']]], + ['readstorageunits_48',['ReadStorageUnits',['../classegoa_1_1_py_psa_parser.html#a02c857ac281a2dec0f9cc1116370162f',1,'egoa::PyPsaParser']]], + ['readstorageunitsinflows_49',['ReadStorageUnitsInflows',['../classegoa_1_1_py_psa_parser.html#ab1cf13fa8f9696f02ff45df060cdd919',1,'egoa::PyPsaParser']]], + ['realpower_50',['realpower',['../classegoa_1_1_vertices_1_1_generator_properties.html#adb1e7db4440b9446b0e2ce01a4a30d4f',1,'egoa::Vertices::GeneratorProperties::RealPower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a39fa5dcca4166228d8a607e8f214e8cf',1,'egoa::Vertices::GeneratorProperties::RealPower()']]], + ['realpower_5f_51',['realPower_',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa7f0c5900748ff1779c12f9201135c52',1,'egoa::Vertices::GeneratorProperties']]], + ['realpowerbound_52',['realpowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0c1e9f8fa3a94009b5a11f86ceb505bd',1,'egoa::Vertices::GeneratorProperties::RealPowerBound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac686597506b9d29e519b22d1042f8d82',1,'egoa::Vertices::GeneratorProperties::RealPowerBound()']]], + ['realpowerbound_5f_53',['realPowerBound_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a07f7f1bb1f30bb2ed0f662f5c9ff6735',1,'egoa::Vertices::GeneratorProperties']]], + ['realpowerload_54',['realpowerload',['../classegoa_1_1_vertices_1_1_load_properties.html#a239e5d037bde34f96e69af4a1b9a7316',1,'egoa::Vertices::LoadProperties::RealPowerLoad() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#afbd2d143bee082c5d57aef63a358b6a1',1,'egoa::Vertices::LoadProperties::RealPowerLoad()']]], + ['realpowerload_5f_55',['realPowerLoad_',['../classegoa_1_1_vertices_1_1_load_properties.html#aecf63bfaa63bef904b5ff520e3b7a6cd',1,'egoa::Vertices::LoadProperties']]], + ['realpowerloadat_56',['realpowerloadat',['../classegoa_1_1_power_grid.html#a0ad99b8b6aaccbf57ad5f6e1d6d9aa02',1,'egoa::PowerGrid::RealPowerLoadAt(Types::vertexId vertexId, Types::index snapshotId=0) const'],['../classegoa_1_1_power_grid.html#a76e6636f4ae50b5e614d32443ce319ef',1,'egoa::PowerGrid::RealPowerLoadAt(TVertex const &vertex, Types::index snapshotId=0) const']]], + ['realpowerloadbound_57',['realpowerloadbound',['../classegoa_1_1_vertices_1_1_load_properties.html#acf0e443a793fe5957d58cba4933b9fe8',1,'egoa::Vertices::LoadProperties::RealPowerLoadBound()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a4d6868d16ae3e643bdcce8a1a57d2763',1,'egoa::Vertices::LoadProperties::RealPowerLoadBound() const']]], + ['realpowerloadbound_5f_58',['realPowerLoadBound_',['../classegoa_1_1_vertices_1_1_load_properties.html#a58362f06c1a1d1557a0044c595d846ce',1,'egoa::Vertices::LoadProperties']]], + ['red_59',['red',['../classegoa_1_1_color.html#ac0262a754506952f2cd35c85a8590bc7',1,'egoa::Color::red() const'],['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aee38e4d5dd68c4e440825018d549cb47',1,'egoa::Color::Red']]], + ['reference_60',['reference',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a7429bbc88acab7e19d15d8b8c838cfe5',1,'egoa::BinaryHeap::HeapIterator']]], + ['related_20classes_20and_20functions_61',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['removeallincidentedgesat_62',['RemoveAllIncidentEdgesAt',['../classegoa_1_1_dynamic_graph.html#af4cf9dec17d8d8f508a19f095aa763fa',1,'egoa::DynamicGraph']]], + ['removeedgeat_63',['RemoveEdgeAt',['../classegoa_1_1_dynamic_graph.html#a1439eb482da86aee51f6e9fcd2b5fd28',1,'egoa::DynamicGraph']]], + ['removegeneratorat_64',['removegeneratorat',['../classegoa_1_1_power_grid.html#a007252fb0f9458101504bee62aded0b4',1,'egoa::PowerGrid::RemoveGeneratorAt(Types::vertexId vertexId, Types::generatorId generatorId)'],['../classegoa_1_1_power_grid.html#a27d896fe872fb31bff7f747b022efef0',1,'egoa::PowerGrid::RemoveGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &generatorProperty)']]], + ['removeloadat_65',['removeloadat',['../classegoa_1_1_power_grid.html#aaa2cba96d7337ae301867e2681b907bd',1,'egoa::PowerGrid::RemoveLoadAt(Types::vertexId vertexId, TLoadProperties &load)'],['../classegoa_1_1_power_grid.html#a0d6b7dbfcc56ae904ea92d95ec25ade0',1,'egoa::PowerGrid::RemoveLoadAt(Types::vertexId vertexId, Types::loadId loadId)']]], + ['removevertexat_66',['RemoveVertexAt',['../classegoa_1_1_dynamic_graph.html#a4016f2a89fddac9b1a600d81a1e668f8',1,'egoa::DynamicGraph']]], + ['reset_67',['reset',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5ca0740b13b4f37e0e0bda37fb29f86a',1,'egoa::Vertices::ElectricalProperties::Reset()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a4961e722fef1b1436f4785e6adc40f4f',1,'egoa::Vertices::GeneratorProperties::Reset()']]], + ['resistance_5f_68',['resistance_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a047ad49c5a26adb0574737c6e7990d2f',1,'egoa::Edges::ElectricalProperties']]], + ['result_69',['result',['../classegoa_1_1_dominating_theta_path.html#a818ba50c2bedadcdc9cfb79d45258699',1,'egoa::DominatingThetaPath::Result(Subgraph< TGraph const > &resultSubgraph, TVertexId const target)'],['../classegoa_1_1_dominating_theta_path.html#ab2d6f458076d6c113987bd242649ecd8',1,'egoa::DominatingThetaPath::Result(std::vector< std::vector< TVertexId > > &parent, TVertexId const target)'],['../classegoa_1_1_m_s_t.html#a32bf7e31a800597a41cb6872e947890b',1,'egoa::MST::Result()']]], + ['rosybrown_70',['Rosybrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3eedcd0326719e4f934807a6b85c8fb0',1,'egoa::Color']]], + ['royalblue_71',['Royalblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeb4caa9c7ef309310a5b00acbba3324b',1,'egoa::Color']]], + ['run_72',['run',['../classegoa_1_1_block_cut_tree_traversal.html#a325c650ca820a35a79a7f9e7a858166f',1,'egoa::BlockCutTreeTraversal::Run()'],['../classegoa_1_1_betweenness_centrality.html#a5f364f7a1f44eb9716d9a49f618fde12',1,'egoa::BetweennessCentrality::Run()'],['../classegoa_1_1_b_f_s.html#acd9ea3faefd2cd2c59b49f86784d924b',1,'egoa::BFS::Run()'],['../classegoa_1_1_dominating_theta_path.html#a8255dba72b52f5875bb2eea79d37f3e8',1,'egoa::DominatingThetaPath::Run()'],['../classegoa_1_1_kruskal.html#aebe2686432729619f7851cca2e943696',1,'egoa::Kruskal::Run()'],['../classegoa_1_1_prim.html#aa1860e37400c3f34111edb86ddd10807',1,'egoa::Prim::Run()']]] +]; diff --git a/search/all_12.js b/search/all_12.js new file mode 100644 index 00000000..85a30a29 --- /dev/null +++ b/search/all_12.js @@ -0,0 +1,71 @@ +var searchData= +[ + ['saddlebrown_0',['Saddlebrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1141cab5c534a37e23dd7f5f3ac853ed',1,'egoa::Color']]], + ['salmon_1',['Salmon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae30d211c66fe9025efb79b79e4244fd0',1,'egoa::Color']]], + ['sandybrown_2',['Sandybrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8e3623c1a82fb0036faa1f51cd7b2b16',1,'egoa::Color']]], + ['seagreen_3',['Seagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa34ce0ea9d774680ddf2d32af085cd14',1,'egoa::Color']]], + ['search_4',['Search',['../classegoa_1_1_binary_heap.html#a393e558559b9c1ac7f9ac955d9adf5b3',1,'egoa::BinaryHeap']]], + ['seashell_5',['Seashell',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad3027eff8d2b1e45c8357151581d6a2d',1,'egoa::Color']]], + ['selectswappablechildat_6',['selectswappablechildat',['../classegoa_1_1_binary_heap.html#a74506ce29cf79cd27be29aba345c14cd',1,'egoa::BinaryHeap::SelectSwappableChildAt()'],['../classegoa_1_1_mapping_binary_heap.html#a4d5d1a132db65d579ce0232fcd0f96b3',1,'egoa::MappingBinaryHeap::SelectSwappableChildAt()']]], + ['sequential_7',['sequential',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a6ec7489017b25b5fff20d353b6d2162e',1,'egoa']]], + ['setlinedefaultvalues_8',['SetLineDefaultValues',['../classegoa_1_1_py_psa_parser.html#a6f4ba696bb8766842c2185d6ab8faad1',1,'egoa::PyPsaParser']]], + ['setloaddefaultvalues_9',['SetLoadDefaultValues',['../classegoa_1_1_py_psa_parser.html#a0f6161489581546388b5885f3f6b9391',1,'egoa::PyPsaParser']]], + ['setparentof_10',['SetParentOf',['../classegoa_1_1_dominating_theta_path.html#a7032884e83c902935483cd76efc85832',1,'egoa::DominatingThetaPath']]], + ['setresult_11',['SetResult',['../classegoa_1_1_m_s_t.html#a4577ac689018e9fce16775a744f52a2c',1,'egoa::MST']]], + ['setvertexprocessedat_12',['SetVertexProcessedAt',['../classegoa_1_1_traversal.html#a33188b59efd9736defff871d4f2597f2',1,'egoa::Traversal']]], + ['setvertexvisitedat_13',['SetVertexVisitedAt',['../classegoa_1_1_traversal.html#ab9d5522bc200837e76015a3c31ae09c5',1,'egoa::Traversal']]], + ['shuntconductance_14',['shuntconductance',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4d5034eca7eaef9c231905aed6ae89b2',1,'egoa::Vertices::ElectricalProperties::ShuntConductance()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a798428fa53b0f7fd7abdd9becf85b2f2',1,'egoa::Vertices::ElectricalProperties::ShuntConductance() const']]], + ['shuntconductance_5f_15',['shuntConductance_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a1dad50a2083ced2d40097f5fe4ea1a46',1,'egoa::Vertices::ElectricalProperties']]], + ['shuntsusceptance_16',['shuntsusceptance',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6001cea3db65dfcd0c5947e4652772be',1,'egoa::Vertices::ElectricalProperties::ShuntSusceptance() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5bdcac2c2fb15a1a9775f25c0fb292a5',1,'egoa::Vertices::ElectricalProperties::ShuntSusceptance()']]], + ['shuntsusceptance_5f_17',['shuntSusceptance_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5393b008525f1ebb79c86d0844563cb2',1,'egoa::Vertices::ElectricalProperties']]], + ['shutdowncost_18',['shutdowncost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a1f059f93a66d4884736d277bcd788a1a',1,'egoa::Vertices::GeneratorProperties::ShutDownCost() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a816377edafb113204d9f5fcca4cde414',1,'egoa::Vertices::GeneratorProperties::ShutDownCost()']]], + ['shutdowncost_5f_19',['shutDownCost_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a86fe823ffd7d817efd2800a81a141f82',1,'egoa::Vertices::GeneratorProperties']]], + ['sienna_20',['Sienna',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3bfd0cce8e9cda754a5b78d85be622ed',1,'egoa::Color']]], + ['siftdown_21',['siftdown',['../classegoa_1_1_binary_heap.html#a9fe572daa5c381d1e4354d37afb93fc6',1,'egoa::BinaryHeap::SiftDown()'],['../classegoa_1_1_binary_heap.html#aec5dc2b7fc30e9829e31c102f96f7f2e',1,'egoa::BinaryHeap::SiftDown(Types::index index)'],['../classegoa_1_1_mapping_binary_heap.html#ad35c2ccc90f8f806ed616855050bf16a',1,'egoa::MappingBinaryHeap::SiftDown()'],['../classegoa_1_1_mapping_binary_heap.html#a8e6d7f27cfee63887d1e5cc9896a118a',1,'egoa::MappingBinaryHeap::SiftDown(Types::index index)']]], + ['siftup_22',['siftup',['../classegoa_1_1_binary_heap.html#af4bc7523cdba5c6c9defbdc523759f9e',1,'egoa::BinaryHeap::SiftUp(Types::index index)'],['../classegoa_1_1_binary_heap.html#afc629079dded733d1ad41410fc23f5b5',1,'egoa::BinaryHeap::SiftUp()'],['../classegoa_1_1_mapping_binary_heap.html#a9d56cbcba39fcbe4afdc2e1322596dbb',1,'egoa::MappingBinaryHeap::SiftUp()'],['../classegoa_1_1_mapping_binary_heap.html#a78f608e8fbb685b7f490efc528c018e1',1,'egoa::MappingBinaryHeap::SiftUp(Types::index index)']]], + ['sign_5f_23',['sign_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a606d548b1571a39566557945d84f4cf3',1,'egoa::Vertices::GeneratorProperties']]], + ['silver_24',['Silver',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af96e345fdc19cbd4cf15256c251a39a0',1,'egoa::Color']]], + ['size_25',['size',['../classegoa_1_1_binary_heap.html#a78f5d8380001a14caee95f4e18004c7a',1,'egoa::BinaryHeap::Size()'],['../classegoa_1_1_mapping_binary_heap.html#a74dd4cd4319e565a2bc6b51d8ca8f60e',1,'egoa::MappingBinaryHeap::Size()']]], + ['skyblue_26',['Skyblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7138173edd0fee059ebc0ab05b8c5009',1,'egoa::Color']]], + ['slateblue_27',['Slateblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab82f8bfdc1b9e5917139b05522a5550e',1,'egoa::Color']]], + ['slategray_28',['Slategray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab73e0c558d263b98e856248b3f211135',1,'egoa::Color']]], + ['slategrey_29',['Slategrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af2ea39d82a9de82be1eb49bfee258272',1,'egoa::Color']]], + ['snapshotweights_5f_30',['snapshotWeights_',['../classegoa_1_1_power_grid.html#ad9871f4d72b93ac45ce70b59b5a3d579',1,'egoa::PowerGrid']]], + ['snow_31',['Snow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab46d3c8ee8032551c011745d587705cc',1,'egoa::Color']]], + ['solution_32',['Solution',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a1351d0c8688e6b24d2be342eec28dd65',1,'egoa::IO::SolverRuntimeRow']]], + ['solverruntimecollection_33',['SolverRuntimeCollection',['../classegoa_1_1_i_o_1_1_solver_runtime_collection.html',1,'egoa::IO']]], + ['solverruntimerow_34',['SolverRuntimeRow',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html',1,'egoa::IO']]], + ['sortblocks_35',['SortBlocks',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#a8c9acf4004b3ddacf2af4bed234ba639',1,'egoa::internal::BlockCutTreeBuilder']]], + ['source_36',['source',['../classegoa_1_1_dominating_theta_path.html#a443ddb1cc3f347672b0cc1e5f37bdb89',1,'egoa::DominatingThetaPath::Source()'],['../classegoa_1_1_traversal.html#adb62b9f9c152287d375c7769dbf63703',1,'egoa::Traversal::Source()']]], + ['source_5f_37',['source_',['../classegoa_1_1io_1_1_edge.html#aa9dde6d9c9e18faf5af9d195a97a0c86',1,'egoa::io::Edge::source_'],['../classegoa_1_1_edges_1_1_edge.html#a56115d3e611f6c5bb7e0c57954b6fec6',1,'egoa::Edges::Edge::source_'],['../classegoa_1_1_traversal.html#ad27bb92b88f980cf259ec0e1d72a8d17',1,'egoa::Traversal::source_']]], + ['sourceid_38',['SourceId',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a146af5698af567bb0dbfc42ebca7d509',1,'egoa::IO::DtpRuntimeRow']]], + ['sourcelabel_39',['sourcelabel',['../classegoa_1_1_voltage_angle_difference_label.html#a7a0e242e8d62d2d295aa45b2cd5614a1',1,'egoa::VoltageAngleDifferenceLabel::SourceLabel()'],['../classegoa_1_1_susceptance_norm_label.html#a89e65d3fcf4e74ef3337c0ef1d9bae12',1,'egoa::SusceptanceNormLabel::SourceLabel()']]], + ['springgreen_40',['Springgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a53f5b0070628492f9dd44e3094012eca',1,'egoa::Color']]], + ['startupcost_41',['startupcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#ac8e1fe3da5b23a0b20d25a4f42593ef2',1,'egoa::Vertices::GeneratorProperties::StartUpCost()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a5e2faaadf35a6097bdb0b5a802867ca9',1,'egoa::Vertices::GeneratorProperties::StartUpCost() const']]], + ['startupcost_5f_42',['startUpCost_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a27e2747a74c1551adadb529d149c984a',1,'egoa::Vertices::GeneratorProperties']]], + ['staticgraph_43',['StaticGraph',['../classegoa_1_1_static_graph.html',1,'egoa']]], + ['staticgraph_3c_20vertices_3a_3aelectricalproperties_3c_20vertices_3a_3aieeebustype_20_3e_2c_20edges_3a_3aelectricalproperties_20_3e_44',['StaticGraph< Vertices::ElectricalProperties< Vertices::IeeeBusType >, Edges::ElectricalProperties >',['../classegoa_1_1_static_graph.html',1,'egoa']]], + ['staticgraphloopdifferentiation_45',['StaticGraphLoopDifferentiation',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3abreakable_20_3e_46',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_47',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_48',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['statistic_49',['statistic',['../classegoa_1_1_dominating_theta_path.html#a58b4cc1f54142f7b53303b8ddf14f0b0',1,'egoa::DominatingThetaPath::Statistic() const'],['../classegoa_1_1_dominating_theta_path.html#ab7cd27a921da2599eefd595710723780',1,'egoa::DominatingThetaPath::Statistic()']]], + ['status_50',['status',['../classegoa_1_1_vertices_1_1_generator_properties.html#af2c8123994f05dfc21d47e1da04bf0db',1,'egoa::Vertices::GeneratorProperties::Status()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a9fb4e4998e0e1d4e27655c46a965f780',1,'egoa::Vertices::GeneratorProperties::Status() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#abd8898fc56caa29533cd1096832ab3d0',1,'egoa::Vertices::ElectricalProperties::Status() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#acda4e5d8f5acdc2621ad46f8bceadc1d',1,'egoa::Vertices::ElectricalProperties::Status()'],['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a0e2822b17bbd4a0fb939031c592416ec',1,'egoa::IO::SolverRuntimeRow::Status']]], + ['status_5f_51',['status_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a4b049126dffebb24074b6b69d28ea29e',1,'egoa::Edges::ElectricalProperties::status_'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a23025daf6197bfa01ef9a5c0d87045e1',1,'egoa::Vertices::ElectricalProperties::status_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ab6b2743fe3266fe08ed3074202a362d1',1,'egoa::Vertices::GeneratorProperties::status_']]], + ['stdqueue_52',['StdQueue',['../classegoa_1_1_std_queue.html',1,'egoa']]], + ['stdqueue_3c_20graphtype_3a_3atvertexid_20_3e_53',['StdQueue< GraphType::TVertexId >',['../classegoa_1_1_std_queue.html',1,'egoa']]], + ['steelblue_54',['Steelblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a79691ec0a05553d1cb46f94e538232de',1,'egoa::Color']]], + ['stroke_55',['stroke',['../classegoa_1_1_stroke.html',1,'egoa::Stroke'],['../classegoa_1_1_stroke.html#ab133a8a3397294d5c8aa7f137502c269',1,'egoa::Stroke::Stroke(Stroke::Name name)'],['../classegoa_1_1_stroke.html#a1608ce0c134b7096cfd6bce7a4dc36c3',1,'egoa::Stroke::Stroke()']]], + ['stroke2dotstyle_56',['Stroke2DotStyle',['../classegoa_1_1_power_grid_i_o.html#a2fc9f5440c89b3a0d5d8c6844a040ba2',1,'egoa::PowerGridIO']]], + ['subgraph_57',['subgraph',['../classegoa_1_1_subgraph.html#af3b6b33a7a3c3303fcdb8208f8febc66',1,'egoa::Subgraph::Subgraph()'],['../classegoa_1_1_subgraph.html',1,'egoa::Subgraph< GraphType >'],['../classegoa_1_1_block_cut_tree_1_1_block.html#afdca5da105664f9bfc1b7923937aacc3',1,'egoa::BlockCutTree::Block::Subgraph()']]], + ['subgraph_3c_20tgraph_20_3e_58',['Subgraph< TGraph >',['../classegoa_1_1_subgraph.html',1,'egoa']]], + ['subgraph_3c_20tgraph_20const_20_3e_59',['Subgraph< TGraph const >',['../classegoa_1_1_subgraph.html',1,'egoa']]], + ['susceptance_60',['susceptance',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html#a6be29eaeb310002c28da022825053bf7',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Susceptance()'],['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html#a5292c6be0796d950be8a9015f2ead88b',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Susceptance()']]], + ['susceptance_5f_61',['susceptance_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a88cc900cbc18f399bb336d93475c81d8',1,'egoa::Edges::ElectricalProperties']]], + ['susceptancenorm_62',['susceptancenorm',['../classegoa_1_1_susceptance_norm_label.html#a5cff82dc79b1923534c8012b1c5c1240',1,'egoa::SusceptanceNormLabel::SusceptanceNorm() const'],['../classegoa_1_1_susceptance_norm_label.html#ac6c5dd6aeed74137fee8f3bc1c25821c',1,'egoa::SusceptanceNormLabel::SusceptanceNorm()']]], + ['susceptancenorm_5f_63',['susceptanceNorm_',['../classegoa_1_1_susceptance_norm_label.html#addb5fd85c9b7c6c4f94f0b25a1706384',1,'egoa::SusceptanceNormLabel']]], + ['susceptancenormlabel_64',['susceptancenormlabel',['../classegoa_1_1_susceptance_norm_label.html',1,'egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >'],['../classegoa_1_1_susceptance_norm_label.html#a377c2280a34c1b90191674bebfbf552a',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(SusceptanceNormLabel const &label)=default'],['../classegoa_1_1_susceptance_norm_label.html#ac4528bda06f4b8562de0f49aa6a02188',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)'],['../classegoa_1_1_susceptance_norm_label.html#a743eb1b6f202e51cddc3ccebe00ab26c',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm)'],['../classegoa_1_1_susceptance_norm_label.html#a2be7a8d041abc7599d9ffcd93db5ba0e',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId)'],['../classegoa_1_1_susceptance_norm_label.html#a4ea696004da32beace96dba84c01698d',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel()']]], + ['susceptancenormlabel_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_2c_20std_3a_3aunordered_5fset_3c_20types_3a_3avertexid_20_3e_2c_20types_3a_3avertexid_20_3e_65',['SusceptanceNormLabel< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId >',['../classegoa_1_1_susceptance_norm_label.html',1,'egoa']]], + ['swap_66',['swap',['../classegoa_1_1_binary_heap.html#a6b765f7e17e0416215f9a66427fdda8e',1,'egoa::BinaryHeap::swap'],['../classegoa_1_1_mapping_binary_heap.html#ad21567eb64c048ce5065fcd52139e266',1,'egoa::MappingBinaryHeap::swap'],['../classegoa_1_1_edges_1_1_edge.html#ae5b6888770eed42df9d62f5c9aa710e7',1,'egoa::Edges::Edge::swap'],['../classegoa_1_1_edges_1_1_electrical_properties.html#af9b76f49462f0aa711df9812c9940adb',1,'egoa::Edges::ElectricalProperties::swap'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#af9b76f49462f0aa711df9812c9940adb',1,'egoa::Vertices::ElectricalProperties::swap'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aac5b0bf3a5bfb0101377c7fd1dc6a474',1,'egoa::Vertices::GeneratorProperties::swap'],['../classegoa_1_1_vertices_1_1_vertex.html#a5a4381592f43687e475c7bc94621229c',1,'egoa::Vertices::Vertex::swap'],['../classegoa_1_1_mapping_binary_heap.html#a5980fbdcaaffeed3abbaab27d450188c',1,'egoa::MappingBinaryHeap::Swap()']]], + ['switchedges_67',['SwitchEdges',['../namespaceegoa.html#a28ffaa4f98802617d5c12c75771d4a5c',1,'egoa']]] +]; diff --git a/search/all_13.js b/search/all_13.js new file mode 100644 index 00000000..40c600c2 --- /dev/null +++ b/search/all_13.js @@ -0,0 +1,98 @@ +var searchData= +[ + ['talgorithm_0',['TAlgorithm',['../classegoa_1_1_betweenness_centrality.html#a81cd680a10bbd8b0a4699f0b78086fc6',1,'egoa::BetweennessCentrality']]], + ['tan_1',['Tan',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1266b4e6f81e60733ec6c717e0181f60',1,'egoa::Color']]], + ['tapratio_5f_2',['tapRatio_',['../classegoa_1_1_edges_1_1_electrical_properties.html#aae90e3e6fa8809ac624063b6bc0bbcc5',1,'egoa::Edges::ElectricalProperties']]], + ['tapratiocosthetashift_5f_3',['tapRatioCosThetaShift_',['../classegoa_1_1_edges_1_1_electrical_properties.html#accbe049b165d0438d5208103c3f880c6',1,'egoa::Edges::ElectricalProperties']]], + ['tapratiosinthetashift_5f_4',['tapRatioSinThetaShift_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a9397eb9611fac52187a1f3198c303835',1,'egoa::Edges::ElectricalProperties']]], + ['target_5f_5',['target_',['../classegoa_1_1_edges_1_1_edge.html#ae466af3254632fb12f512225ff76262e',1,'egoa::Edges::Edge::target_'],['../classegoa_1_1io_1_1_edge.html#af16d348e0a47fb36006ea9521d989ed3',1,'egoa::io::Edge::target_']]], + ['tbound_6',['TBound',['../classegoa_1_1_bound.html#a527749530ae4f31ee8ce43332e2efde4',1,'egoa::Bound']]], + ['tcomparator_7',['TComparator',['../classegoa_1_1_mapping_binary_heap.html#ab29d795a7d789ed26de2d035074de962',1,'egoa::MappingBinaryHeap']]], + ['teal_8',['Teal',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae20385a2b41df1743f787ebef18222b8',1,'egoa::Color']]], + ['tedge_9',['tedge',['../classegoa_1_1_dominating_theta_path.html#af08a63afb799f82afcd89b520ab92ce9',1,'egoa::DominatingThetaPath::TEdge'],['../classegoa_1_1_betweenness_centrality.html#a332bd579f71279cf619f9b460327a083',1,'egoa::BetweennessCentrality::TEdge']]], + ['tedgeid_10',['tedgeid',['../classegoa_1_1_betweenness_centrality.html#ad036f7467a524b04e479004ab2dcb3ca',1,'egoa::BetweennessCentrality::TEdgeId'],['../classegoa_1_1_dominating_theta_path.html#a32be43cd94bd7e92da7ccd9cc43b9ae3',1,'egoa::DominatingThetaPath::TEdgeId']]], + ['telement_11',['telement',['../classegoa_1_1_binary_heap.html#a070c68933fe920def25b85d35b7b74b8',1,'egoa::BinaryHeap::TElement'],['../classegoa_1_1_mapping_binary_heap.html#af72ceae144bc883b16f502701fcc5455',1,'egoa::MappingBinaryHeap::TElement'],['../classegoa_1_1_label.html#a7394e9dac1d2470f015f17423e6581fb',1,'egoa::Label::TElement'],['../classegoa_1_1_susceptance_norm_label.html#a7394e9dac1d2470f015f17423e6581fb',1,'egoa::SusceptanceNormLabel::TElement'],['../classegoa_1_1_voltage_angle_difference_label.html#a7394e9dac1d2470f015f17423e6581fb',1,'egoa::VoltageAngleDifferenceLabel::TElement']]], + ['terminate_12',['Terminate',['../classegoa_1_1_depth_first_search.html#af5af476811704fcc85bdfc68725686e5',1,'egoa::DepthFirstSearch']]], + ['terminate_5f_13',['terminate_',['../classegoa_1_1_depth_first_search.html#af90bad51fc87634f7e48fb5299abb355',1,'egoa::DepthFirstSearch']]], + ['terrainfactor_5f_14',['terrainFactor_',['../classegoa_1_1_edges_1_1_electrical_properties.html#ac2d17824ec7a6951b2bad65109b48e0e',1,'egoa::Edges::ElectricalProperties']]], + ['tgraph_15',['tgraph',['../classegoa_1_1_betweenness_centrality.html#ab79d6a6c5f97d7feba9484ebe722c51c',1,'egoa::BetweennessCentrality::TGraph'],['../classegoa_1_1_dominating_theta_path.html#a7f15942de393e78503dff4fb788fd2fd',1,'egoa::DominatingThetaPath::TGraph']]], + ['thermallimita_5f_16',['thermalLimitA_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a909557f5cf8c25dedf6f3e59daf62c1b',1,'egoa::Edges::ElectricalProperties']]], + ['thermallimitb_5f_17',['thermalLimitB_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a527c7eb38d05be09f1c658493f4ab22e',1,'egoa::Edges::ElectricalProperties']]], + ['thermallimitc_5f_18',['thermalLimitC_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a80225f5434cb39fba440fe12082794f0',1,'egoa::Edges::ElectricalProperties']]], + ['thesisblack_19',['THESISblack',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5e6b63c7024130fcb63c4b4489fde631',1,'egoa::Color']]], + ['thesisblack15_20',['THESISblack15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a52d090d7833129c47b2f6d847d7e3a06',1,'egoa::Color']]], + ['thesisblack30_21',['THESISblack30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a97246c55afd5d6dfecbfd74caa8b49a6',1,'egoa::Color']]], + ['thesisblack50_22',['THESISblack50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a92e03351157d9213614fa82dc9fcd171',1,'egoa::Color']]], + ['thesisblack7_23',['THESISblack7',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0af2bf5b95916636ece52b9d26b4ed6f',1,'egoa::Color']]], + ['thesisblack70_24',['THESISblack70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a985fc47c9f35651101d04deda6cf4092',1,'egoa::Color']]], + ['thesisblue_25',['THESISblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4b13fd198900aaebc1bff85222a2701b',1,'egoa::Color']]], + ['thesisblue_5fdark_26',['THESISblue_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a98735aaa15b8677b72f9d9275fb19f33',1,'egoa::Color']]], + ['thesisblue_5flight_27',['THESISblue_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0a0cfae62dad21bc2d094aca19b9fdc6',1,'egoa::Color']]], + ['thesisblue_5fvlight_28',['THESISblue_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a580c4fecb9d67729c1a9957ead03fefd',1,'egoa::Color']]], + ['thesisgreen_29',['THESISgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5668553cc9266629dea6f15650c08e8d',1,'egoa::Color']]], + ['thesisgreen_5fdark_30',['THESISgreen_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1fca7973cc2907b86178687947ab7cba',1,'egoa::Color']]], + ['thesisgreen_5flight_31',['THESISgreen_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab26aee35a786c150ba7610327d504aa5',1,'egoa::Color']]], + ['thesisgreen_5fvlight_32',['THESISgreen_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa51ecf4c00d73f4366ab82632b10ea56',1,'egoa::Color']]], + ['thesisred_33',['THESISred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1fa454490e6a131d18344d53123b0ad3',1,'egoa::Color']]], + ['thesisred_5fdark_34',['THESISred_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3bab1b783ed772bd518e5f4e3fc45391',1,'egoa::Color']]], + ['thesisred_5flight_35',['THESISred_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adf0acb483bda17df346fc313e441d4db',1,'egoa::Color']]], + ['thesisred_5fvlight_36',['THESISred_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5eab00519bded83b195131a77a0afb58',1,'egoa::Color']]], + ['thesisyellow_37',['THESISyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8a3c2a48ba29ad1ea8d88f7abdd78487',1,'egoa::Color']]], + ['thesisyellow_5fdark_38',['THESISyellow_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a655a20860d84d45d794f0c86f8cd9191',1,'egoa::Color']]], + ['thesisyellow_5flight_39',['THESISyellow_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab481b26ff40776f83160152a20553a05',1,'egoa::Color']]], + ['thesisyellow_5fvlight_40',['THESISyellow_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac177ff56d4f83243cdf29a78ae2be3aa',1,'egoa::Color']]], + ['thetabound_41',['thetabound',['../classegoa_1_1_power_grid.html#ab92be7dd2ca99b9d450beb04f3b525fd',1,'egoa::PowerGrid::ThetaBound() const'],['../classegoa_1_1_power_grid.html#a1097ce9dc78ab883a7a53319e9f2c778',1,'egoa::PowerGrid::ThetaBound()']]], + ['thetabound_5f_42',['thetabound_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a22276dae219d3a8309c573abfd4e255a',1,'egoa::Edges::ElectricalProperties::thetaBound_'],['../classegoa_1_1_power_grid.html#aded2217a7c7dfdde1a48d6b66508e93d',1,'egoa::PowerGrid::thetaBound_']]], + ['thistle_43',['Thistle',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a58849bbd6b4fb8844f01c2ebf7e59c36',1,'egoa::Color']]], + ['time_44',['Time',['../classegoa_1_1_depth_first_search.html#a2852f7950d64bb54d76826e9dbe08cff',1,'egoa::DepthFirstSearch']]], + ['time_5f_45',['time_',['../classegoa_1_1_depth_first_search.html#a51e78c13e736bae992a006d81a2b515f',1,'egoa::DepthFirstSearch']]], + ['timeofoldestreachableancestor_5f_46',['timeOfOldestReachableAncestor_',['../classegoa_1_1_articulation_vertex_detection.html#ab23c11719f0b0a855400ef16b9c525bc',1,'egoa::ArticulationVertexDetection']]], + ['timer_47',['Timer',['../classegoa_1_1_auxiliary_1_1_timer.html',1,'egoa::Auxiliary']]], + ['timestampat_48',['TimestampAt',['../classegoa_1_1_power_grid.html#a752fd2b23d778f2ac4766c8d22e66cc9',1,'egoa::PowerGrid']]], + ['timestamps_5f_49',['timestamps_',['../classegoa_1_1_power_grid.html#ab3c5e6ab3faa1f42d9f0d8a24096f044',1,'egoa::PowerGrid']]], + ['titerator_50',['titerator',['../classegoa_1_1_mapping_binary_heap.html#abe348d7ffeb62d27fcf0b9de846e3990',1,'egoa::MappingBinaryHeap::TIterator'],['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a795a09d4adf6ee155eb721214dcc639f',1,'egoa::DynamicGraph::OmittingVectorView::TIterator']]], + ['tkey_51',['TKey',['../classegoa_1_1_mapping_binary_heap.html#ac62301b358c69bfa513396d1a64c2a76',1,'egoa::MappingBinaryHeap']]], + ['tlabel_52',['tlabel',['../classegoa_1_1_dominating_theta_path.html#a9edb56ab8cfa2c64e20b97a3b0b27e0a',1,'egoa::DominatingThetaPath::TLabel'],['../classegoa_1_1_label.html#ac08cd3815a262abdfbab3125cd04ad56',1,'egoa::Label::TLabel']]], + ['tlabelset_53',['TLabelSet',['../classegoa_1_1_dominating_theta_path.html#a2b7023980b390498a946a1881d7e0c2b',1,'egoa::DominatingThetaPath']]], + ['tmap_54',['TMap',['../classegoa_1_1_mapping_binary_heap.html#a68b4ed47dc417e628b1ef55f71d98aed',1,'egoa::MappingBinaryHeap']]], + ['tmeasurementcollection_55',['TMeasurementCollection',['../classegoa_1_1_betweenness_centrality.html#aedc26ba6fce3153f050543216bb7255a',1,'egoa::BetweennessCentrality']]], + ['tmeasurementrow_56',['TMeasurementRow',['../classegoa_1_1_betweenness_centrality.html#ad187f89bbf147903f400511624a1cb96',1,'egoa::BetweennessCentrality']]], + ['todo_20list_57',['Todo List',['../todo.html',1,'']]], + ['tomato_58',['Tomato',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a77bd79b3dca1f49815655b6f2df760ba',1,'egoa::Color']]], + ['top_59',['top',['../classegoa_1_1_binary_heap.html#a1b20c7366d0799764ce000b8af1e7333',1,'egoa::BinaryHeap::Top()'],['../classegoa_1_1_bucket.html#a815f103723d4d2ff76d63c0e70cefb78',1,'egoa::Bucket::Top()'],['../classegoa_1_1_mapping_binary_heap.html#a0316b89af5cd4dc4befce15fe280be0c',1,'egoa::MappingBinaryHeap::Top()'],['../classegoa_1_1_priority_queue.html#aee4c96105bd1f6fbc77182413ef0b48b',1,'egoa::PriorityQueue::Top()'],['../classegoa_1_1_queue.html#a1e01fbe6d2caf5bc0b00936a2e73fd8f',1,'egoa::Queue::Top()'],['../classegoa_1_1_std_queue.html#a496a2732c537608dfc3c9635ceb89840',1,'egoa::StdQueue::Top()']]], + ['topelement_60',['TopElement',['../classegoa_1_1_mapping_binary_heap.html#aea256d02d2ac158db366c1b851fb20fe',1,'egoa::MappingBinaryHeap']]], + ['topkey_61',['TopKey',['../classegoa_1_1_mapping_binary_heap.html#ae43c05e95479904d4ec9be4b681b4f53',1,'egoa::MappingBinaryHeap']]], + ['totalnumberofpaths_62',['totalnumberofpaths',['../classegoa_1_1_betweenness_centrality.html#adb232cfef1d46ba2911eeadeab574665',1,'egoa::BetweennessCentrality::TotalNumberOfPaths() const'],['../classegoa_1_1_betweenness_centrality.html#a3fa665a692383b7e3141bc3fd5b39603',1,'egoa::BetweennessCentrality::TotalNumberOfPaths(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)']]], + ['totalnumberofpathsthroughedge_63',['TotalNumberOfPathsThroughEdge',['../classegoa_1_1_dominating_theta_path.html#a99e06788e2fa083610d853d3dcdd838b',1,'egoa::DominatingThetaPath']]], + ['totalnumberofpathsthroughvertex_64',['TotalNumberOfPathsThroughVertex',['../classegoa_1_1_dominating_theta_path.html#acfc28500d2c7f2d667f81d03dc70e40b',1,'egoa::DominatingThetaPath']]], + ['totalreactivepowergenerationat_65',['totalreactivepowergenerationat',['../classegoa_1_1_power_grid.html#ad339f9df12e72926a5d5187e2ee1d8c6',1,'egoa::PowerGrid::TotalReactivePowerGenerationAt()'],['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html#a581dde2106576b1eaffc0fab17e1eb96',1,'egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalReactivePowerGenerationAt()']]], + ['totalreactivepowergenerationboundat_66',['TotalReactivePowerGenerationBoundAt',['../classegoa_1_1_power_grid.html#aa1130efec62586f7a9b6ee12c7d4ca55',1,'egoa::PowerGrid']]], + ['totalreactivepowerloadboundat_67',['TotalReactivePowerLoadBoundAt',['../classegoa_1_1_power_grid.html#af3698d771b79e9fc5f682c9ed49f526b',1,'egoa::PowerGrid']]], + ['totalrealpowergenerationat_68',['totalrealpowergenerationat',['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html#a5267da62238da8eef80aba4c5d9e2e04',1,'egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalRealPowerGenerationAt()'],['../classegoa_1_1_power_grid.html#abeb8fe4e80c4fdaba71421649a541af5',1,'egoa::PowerGrid::TotalRealPowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) const']]], + ['totalrealpowergenerationboundat_69',['TotalRealPowerGenerationBoundAt',['../classegoa_1_1_power_grid.html#aaf409cf61193b8c8c44363f4a5eb3034',1,'egoa::PowerGrid']]], + ['totalrealpowerloadat_70',['TotalRealPowerLoadAt',['../classegoa_1_1_power_grid.html#aee20fc87deecdfff9736acc1be069db4',1,'egoa::PowerGrid']]], + ['totalrealpowerloadboundat_71',['TotalRealPowerLoadBoundAt',['../classegoa_1_1_power_grid.html#a6cbe3e5938981a9bdee8ffb8e88d9687',1,'egoa::PowerGrid']]], + ['totalrelativenumberofpaths_72',['TotalRelativeNumberOfPaths',['../classegoa_1_1_betweenness_centrality.html#ad8a1bd8db3c4d9f5f13d3f11fef0b953',1,'egoa::BetweennessCentrality']]], + ['tproperties_73',['TProperties',['../classegoa_1_1_vertices_1_1_vertex.html#a2fe0a348dca9071b19b3fb7bab7d5b81',1,'egoa::Vertices::Vertex']]], + ['tqueue_74',['TQueue',['../classegoa_1_1_dominating_theta_path.html#ab971c601a39ae87eb5dda4f6ea57dc79',1,'egoa::DominatingThetaPath']]], + ['traversal_75',['traversal',['../classegoa_1_1_traversal.html',1,'egoa::Traversal< GraphType, IsDirected >'],['../classegoa_1_1_traversal.html#a50d2313238e7723226d6e8a5d43b08ec',1,'egoa::Traversal::Traversal()']]], + ['traversal_3c_20false_20_3e_76',['Traversal< false >',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['traversal_3c_20graphtype_2c_20false_20_3e_77',['Traversal< GraphType, false >',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['traversal_3c_20graphtype_2c_20isdirected_20_3e_78',['Traversal< GraphType, IsDirected >',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['tree_20related_20classes_20and_20functions_79',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['treeoutdegree_80',['TreeOutDegree',['../classegoa_1_1_articulation_vertex_detection.html#a9997acc8bd99b4fb684ad191f407e368',1,'egoa::ArticulationVertexDetection']]], + ['treeoutdegree_5f_81',['treeOutDegree_',['../classegoa_1_1_articulation_vertex_detection.html#ac109d0bd10acf02d952e9e66f63cca54',1,'egoa::ArticulationVertexDetection']]], + ['treference_82',['TReference',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a3490e17b63b2296453a1deb5f8580d81',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['treverseiterator_83',['TReverseIterator',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a1336d06a7391ab76996781ee2e016106',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['tunderlyinggraph_84',['TUnderlyingGraph',['../classegoa_1_1_subgraph.html#a7ee7fa00700eb72516b78177d4204a50',1,'egoa::Subgraph']]], + ['tunderlyingiterator_85',['TUnderlyingIterator',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#afc05d6a47fde4226f6692d632ac20c45',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['tunderlyingreverseiterator_86',['TUnderlyingReverseIterator',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a2f54980e74741287069e6ea60c9887cb',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['turquoise_87',['Turquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ada3a4f0a911cebe3bc75f6e39c324696',1,'egoa::Color']]], + ['tvector_88',['TVector',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a6e9aa52845c35407ab30f913915281e7',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['tvertex_89',['tvertex',['../classegoa_1_1_dominating_theta_path.html#a3290448079a624a4666e43fd83a1a91b',1,'egoa::DominatingThetaPath::TVertex'],['../classegoa_1_1_betweenness_centrality.html#a0449fe99d902b2c168340cfcb05bb7f2',1,'egoa::BetweennessCentrality::TVertex']]], + ['tvertexid_90',['tvertexid',['../classegoa_1_1_dominating_theta_path.html#a6dbff2b71f55ffcf3a53f5be3fe0ca93',1,'egoa::DominatingThetaPath::TVertexId'],['../classegoa_1_1_label.html#a64c9818bf4718303b30bd5724a531176',1,'egoa::Label::TVertexId'],['../classegoa_1_1_susceptance_norm_label.html#a64c9818bf4718303b30bd5724a531176',1,'egoa::SusceptanceNormLabel::TVertexId'],['../classegoa_1_1_voltage_angle_difference_label.html#a64c9818bf4718303b30bd5724a531176',1,'egoa::VoltageAngleDifferenceLabel::TVertexId'],['../classegoa_1_1_betweenness_centrality.html#a449d21cce7356c65c4b75d79351a46dd',1,'egoa::BetweennessCentrality::TVertexId']]], + ['tvertexset_91',['tvertexset',['../classegoa_1_1_label.html#a47161829a212621c0f4e4d55fd9362e0',1,'egoa::Label::TVertexSet'],['../classegoa_1_1_susceptance_norm_label.html#a47161829a212621c0f4e4d55fd9362e0',1,'egoa::SusceptanceNormLabel::TVertexSet'],['../classegoa_1_1_voltage_angle_difference_label.html#a47161829a212621c0f4e4d55fd9362e0',1,'egoa::VoltageAngleDifferenceLabel::TVertexSet']]], + ['type_92',['type',['../classegoa_1_1_vertices_1_1_load_properties.html#a9fcffced8bff34d2012d0a910e021883',1,'egoa::Vertices::LoadProperties::Type()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a9f701de7719711fe0f562704402a4732',1,'egoa::Vertices::LoadProperties::Type() const']]], + ['type_5f_93',['type_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4682bbf5c0c66731a157c20d7a029c18',1,'egoa::Vertices::ElectricalProperties::type_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a7514cf6f505037bad6db3701a7826771',1,'egoa::Vertices::GeneratorProperties::type_'],['../classegoa_1_1_vertices_1_1_load_properties.html#a30fb090196b6ad5a9419e757dbbd2ae7',1,'egoa::Vertices::LoadProperties::type_']]], + ['typifyedge_94',['TypifyEdge',['../classegoa_1_1_depth_first_search.html#a6518e2333138342f23f113229c351f72',1,'egoa::DepthFirstSearch']]] +]; diff --git a/search/all_14.js b/search/all_14.js new file mode 100644 index 00000000..35e688da --- /dev/null +++ b/search/all_14.js @@ -0,0 +1,16 @@ +var searchData= +[ + ['underlyinggraph_0',['underlyinggraph',['../classegoa_1_1_subgraph.html#a04af76424e41e3a70d0aa33be626a8a0',1,'egoa::Subgraph::UnderlyingGraph()'],['../classegoa_1_1_subgraph.html#a8396d16535e875c95995f344228cb3d7',1,'egoa::Subgraph::UnderlyingGraph() const']]], + ['underlyinggraph_5f_1',['underlyingGraph_',['../classegoa_1_1_subgraph.html#a9c8e92e961b1b0fbe98235d79928a5da',1,'egoa::Subgraph']]], + ['union_2',['Union',['../classegoa_1_1_union_find.html#a470ce1c4a136137cf4e5da9f5921249d',1,'egoa::UnionFind']]], + ['unionfind_3',['UnionFind',['../classegoa_1_1_union_find.html',1,'egoa']]], + ['unprocessedelements_5f_4',['unprocessedElements_',['../classegoa_1_1_bucket.html#a86d679fb5ed377587673d3e5d6221b05',1,'egoa::Bucket']]], + ['updateedges_5',['UpdateEdges',['../classegoa_1_1_dynamic_graph.html#a7c875e9bc4f2d4dccc58d5dc4f71f3f6',1,'egoa::DynamicGraph']]], + ['updategeneratorsnapshotsize_6',['UpdateGeneratorSnapshotSize',['../classegoa_1_1_power_grid.html#a1bcc5072df02b1c7e58b2f7d944d8138',1,'egoa::PowerGrid']]], + ['updatelabelset_7',['UpdateLabelSet',['../classegoa_1_1_dominating_theta_path.html#a4fed38b29e1d5517c4f9000b76dabbf7',1,'egoa::DominatingThetaPath']]], + ['updatelabelsetat_8',['UpdateLabelSetAt',['../classegoa_1_1_dominating_theta_path.html#af8fe087c1b987749679bae66cfe56c61',1,'egoa::DominatingThetaPath']]], + ['updateloadsnapshotsize_9',['UpdateLoadSnapshotSize',['../classegoa_1_1_power_grid.html#a9dddc68fbe06d166d81a7e4cb9366858',1,'egoa::PowerGrid']]], + ['updatequeuewith_10',['UpdateQueueWith',['../classegoa_1_1_dominating_theta_path.html#ae6167bdb4f6bd2ff9acdd1dee2951b66',1,'egoa::DominatingThetaPath']]], + ['updatevertices_11',['UpdateVertices',['../classegoa_1_1_dynamic_graph.html#a9184c56f7a673fa024ff5e41bc65fcc7',1,'egoa::DynamicGraph']]], + ['upperbound_12',['UpperBound',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a104ac29ee678c72147b239172efec947',1,'egoa::IO::SolverRuntimeRow']]] +]; diff --git a/search/all_15.js b/search/all_15.js new file mode 100644 index 00000000..0e846d65 --- /dev/null +++ b/search/all_15.js @@ -0,0 +1,38 @@ +var searchData= +[ + ['valid_0',['valid',['../classegoa_1_1_bucket_element.html#a4053b4114d94b641e968ab570fcddf22',1,'egoa::BucketElement::Valid() const'],['../classegoa_1_1_bucket_element.html#aaea7a15250016675f33becf9f5507b82',1,'egoa::BucketElement::Valid()'],['../classegoa_1_1_label.html#a35da0c2e26608ea848cf88680f2008ad',1,'egoa::Label::Valid() const'],['../classegoa_1_1_label.html#a147b0a2c210ea0c7a73960793390630d',1,'egoa::Label::Valid()']]], + ['valid_5f_1',['valid_',['../classegoa_1_1_bucket_element.html#a988b832c2a3c777b0adeeb196133daf6',1,'egoa::BucketElement::valid_'],['../classegoa_1_1_label.html#aa0f1d54a563d8565bfb16b1da45a3bd0',1,'egoa::Label::valid_']]], + ['value_2',['value',['../classegoa_1_1_bucket_element.html#a4231606d36a7c5257723fcd43d82afe8',1,'egoa::BucketElement::Value() const'],['../classegoa_1_1_bucket_element.html#a285e1832cac95403d97eafb5ccaa97f0',1,'egoa::BucketElement::Value()'],['../classegoa_1_1_susceptance_norm_label.html#a25ea356ac216d1d683c4549cccde72ae',1,'egoa::SusceptanceNormLabel::Value()'],['../classegoa_1_1_voltage_angle_difference_label.html#a151040ba01cc2fdfb407aad45e80e0dd',1,'egoa::VoltageAngleDifferenceLabel::Value()']]], + ['value_5f_3',['value_',['../classegoa_1_1_bucket_element.html#adb6f34526466b324bf3ee2c5840a672f',1,'egoa::BucketElement']]], + ['value_5ftype_4',['value_type',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a5c06e323ffa55c5a5122bcb95b309039',1,'egoa::BinaryHeap::HeapIterator']]], + ['vector_5f_5',['vector_',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#abdf416dcdcb79af5564013ef0877c644',1,'egoa::BinaryHeap::HeapIterator']]], + ['vectorbasedcomparator_6',['vectorbasedcomparator',['../classegoa_1_1_vector_based_comparator.html#a82c05abbc7fdc0eed7934eb65043621f',1,'egoa::VectorBasedComparator::VectorBasedComparator()'],['../classegoa_1_1_vector_based_comparator.html',1,'egoa::VectorBasedComparator< WeightType, ComparatorType >']]], + ['vectorview_7',['VectorView',['../classegoa_1_1_vector_view.html',1,'egoa']]], + ['vertex_8',['vertex',['../classegoa_1_1_vertices_1_1_vertex.html',1,'egoa::Vertices::Vertex< PropertyType >'],['../classegoa_1_1_vertices_1_1_vertex.html#af5a0ad670948c0ebccf30cd5b6910c67',1,'egoa::Vertices::Vertex::Vertex()'],['../classegoa_1_1_label.html#a9080389c29a477c8dd68c636e4dd38b1',1,'egoa::Label::Vertex() const'],['../classegoa_1_1_label.html#a1898e8d0305d3deca7ad3090746f8ba7',1,'egoa::Label::Vertex()']]], + ['vertexat_9',['vertexat',['../classegoa_1_1_dynamic_graph.html#ade98a36f58b62b0ddf18daf57d051646',1,'egoa::DynamicGraph::VertexAt(Types::vertexId id)'],['../classegoa_1_1_dynamic_graph.html#a887f229058748393dc58e2f0437644d0',1,'egoa::DynamicGraph::VertexAt(Types::vertexId id) const'],['../classegoa_1_1_static_graph.html#a51e1aa356592e7bbe21178a4a5cfd0e7',1,'egoa::StaticGraph::VertexAt(Types::vertexId id)'],['../classegoa_1_1_static_graph.html#a54d17ec1f4026c0c356f5ce17d8713fb',1,'egoa::StaticGraph::VertexAt(Types::vertexId id) const']]], + ['vertexexists_10',['vertexexists',['../classegoa_1_1_dynamic_graph.html#a447e856c5763688544e79a5f664c3c96',1,'egoa::DynamicGraph::VertexExists()'],['../classegoa_1_1_static_graph.html#ac2d85291944c45ce4cf84618f4f0a787',1,'egoa::StaticGraph::VertexExists()']]], + ['vertexexists_5f_11',['vertexExists_',['../classegoa_1_1_dynamic_graph.html#af2435c39fff8dd62fad2becd3dce71d0',1,'egoa::DynamicGraph']]], + ['vertexid_12',['vertexid',['../classegoa_1_1_dynamic_graph.html#aeb5f893f302fe15c653d946b8d16f6ba',1,'egoa::DynamicGraph::VertexId()'],['../classegoa_1_1_static_graph.html#a3c36deb599963446310a797fb018f2e4',1,'egoa::StaticGraph::VertexId()']]], + ['vertexid_5f_13',['vertexId_',['../classegoa_1_1_label.html#a5f4184c4b99e356c447b143b9166e618',1,'egoa::Label']]], + ['vertexidof_14',['VertexIdOf',['../classegoa_1_1_dominating_theta_path.html#aa9a70d17bf52f16ebff4de1833451873',1,'egoa::DominatingThetaPath']]], + ['vertexset_15',['vertexset',['../classegoa_1_1_susceptance_norm_label.html#a0bd943685a49da7b5135c81f96f7e3e9',1,'egoa::SusceptanceNormLabel::VertexSet()'],['../classegoa_1_1_susceptance_norm_label.html#a68882a1c3a3b5cdea586db8e57aae544',1,'egoa::SusceptanceNormLabel::VertexSet() const']]], + ['vertexset_5f_16',['vertexSet_',['../classegoa_1_1_susceptance_norm_label.html#abff44626585060e7e1598dfafb4ab021',1,'egoa::SusceptanceNormLabel']]], + ['vertices_17',['vertices',['../classegoa_1_1_dynamic_graph.html#ac4d3a3fea6a51d15c7574f3e6719659b',1,'egoa::DynamicGraph::Vertices()'],['../classegoa_1_1_dynamic_graph.html#ac7e7dbb3a0c734e8619ed29cf18cbd32',1,'egoa::DynamicGraph::Vertices() const'],['../classegoa_1_1_static_graph.html#a7d7a79c898700c3d9b031609f522911a',1,'egoa::StaticGraph::Vertices()'],['../classegoa_1_1_static_graph.html#a90fa1753ac1b086664972d381679717b',1,'egoa::StaticGraph::Vertices() const'],['../classegoa_1_1_subgraph.html#affb37573ad582f0ac9ccd7dafe49c353',1,'egoa::Subgraph::Vertices() const']]], + ['vertices_5f_18',['vertices_',['../classegoa_1_1_subgraph.html#a7bd808113ef57a6d0a69f1d1d0aa7a3b',1,'egoa::Subgraph::vertices_'],['../classegoa_1_1_static_graph.html#a447fae46be9447c765c27827d6612694',1,'egoa::StaticGraph::vertices_'],['../classegoa_1_1_dynamic_graph.html#afa4a6efdf0525b9cc75e4e89c9c103d8',1,'egoa::DynamicGraph::vertices_']]], + ['verticeswithgeneratorcount_5f_19',['verticesWithGeneratorCount_',['../classegoa_1_1_power_grid.html#a924a4084c9acd201305793db77a5c9cb',1,'egoa::PowerGrid']]], + ['violet_20',['Violet',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a80f1187112e2e5e0403499147f7014b8',1,'egoa::Color']]], + ['visitblock_21',['VisitBlock',['../classegoa_1_1_block_cut_tree_traversal.html#ab4026c080e71f35c0f3fabf5d0265c10',1,'egoa::BlockCutTreeTraversal']]], + ['visitcutvertex_22',['VisitCutVertex',['../classegoa_1_1_block_cut_tree_traversal.html#a7fc647cc26f7f1e6502748d0b5f951e3',1,'egoa::BlockCutTreeTraversal']]], + ['visited_5f_23',['visited_',['../classegoa_1_1_block_cut_tree_traversal.html#a18ff7791729d018a394d6e5bbb7b86e8',1,'egoa::BlockCutTreeTraversal::visited_'],['../classegoa_1_1_traversal.html#a96e640bc0a11550e521839c4aaa84c89',1,'egoa::Traversal::visited_']]], + ['visitedvertexat_24',['VisitedVertexAt',['../classegoa_1_1_traversal.html#aabe0f0af747b5ac7f21f2972496b2b16',1,'egoa::Traversal']]], + ['visitleaf_25',['VisitLeaf',['../classegoa_1_1_block_cut_tree_traversal.html#a7c18a382b6fe7e660c0239a1380d8f31',1,'egoa::BlockCutTreeTraversal']]], + ['visitroot_26',['VisitRoot',['../classegoa_1_1_block_cut_tree_traversal.html#a3d1fa1d158452d5c4f227f0f6dfa53d1',1,'egoa::BlockCutTreeTraversal']]], + ['voltageangle_27',['voltageangle',['../classegoa_1_1_vertices_1_1_electrical_properties.html#adace8099209c1eadc7de81d59c4c0924',1,'egoa::Vertices::ElectricalProperties::VoltageAngle() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a11ed7e41aaddc1fc8a9a1ada4b1365e3',1,'egoa::Vertices::ElectricalProperties::VoltageAngle()']]], + ['voltageangle_5f_28',['voltageAngle_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#abeb98c608a27583443c74aec8c5c9a66',1,'egoa::Vertices::ElectricalProperties']]], + ['voltageangledifferencelabel_29',['voltageangledifferencelabel',['../classegoa_1_1_voltage_angle_difference_label.html#aa5f20f84e84876d44a4b75e299cc2e76',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel()'],['../classegoa_1_1_voltage_angle_difference_label.html',1,'egoa::VoltageAngleDifferenceLabel< ElementType, VertexSetContainer, PointerType >'],['../classegoa_1_1_voltage_angle_difference_label.html#af1b337329be1d8142fd52f15b814412c',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity, TVertexSet vertexSet)'],['../classegoa_1_1_voltage_angle_difference_label.html#ab46376d0b9ce897ce539d7051ab28fba',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity)'],['../classegoa_1_1_voltage_angle_difference_label.html#a3eefff44bbcb051f2780e65d175b7dfc',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId)'],['../classegoa_1_1_voltage_angle_difference_label.html#aa801eea5c8235950224994adadddd006',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel()']]], + ['voltagebound_5f_30',['voltageBound_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a1415860242edb747e283f9bd61594df3',1,'egoa::Vertices::ElectricalProperties']]], + ['voltagemagnitude_31',['voltagemagnitude',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4dfa1f2e2f6c69685991f3f37b8a8ec4',1,'egoa::Vertices::ElectricalProperties::VoltageMagnitude() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#ab7000550c6964165fd2b016d3e4553d3',1,'egoa::Vertices::ElectricalProperties::VoltageMagnitude()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a14da9854523cea434d734f3edf9c2115',1,'egoa::Vertices::GeneratorProperties::VoltageMagnitude() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a719d6a990b6cc8657b7feedb20a14b09',1,'egoa::Vertices::GeneratorProperties::VoltageMagnitude()']]], + ['voltagemagnitude_5f_32',['voltageMagnitude_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#aced2ae81b9fc46e0f592cb396add1366',1,'egoa::Vertices::ElectricalProperties']]], + ['voltagemagnitudesnapshot_5f_33',['voltageMagnitudeSnapshot_',['../classegoa_1_1_vertices_1_1_generator_properties.html#ad10f9184a99171420eff51f25b16e20f',1,'egoa::Vertices::GeneratorProperties']]], + ['voltagemagnitudesq_5f_34',['voltageMagnitudeSq_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a34e8cc5e8b72c583154fc153267100f3',1,'egoa::Vertices::ElectricalProperties']]] +]; diff --git a/search/all_16.js b/search/all_16.js new file mode 100644 index 00000000..94157049 --- /dev/null +++ b/search/all_16.js @@ -0,0 +1,34 @@ +var searchData= +[ + ['wheat_0',['Wheat',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a966d953817980d045a3538d3b8bbb468',1,'egoa::Color']]], + ['white_1',['White',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a25a81701fbfa4a1efdf660a950c1d006',1,'egoa::Color']]], + ['whitesmoke_2',['Whitesmoke',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1377f5800ab28508ba00345281d1313c',1,'egoa::Color']]], + ['write_3',['write',['../classegoa_1_1_power_grid_i_o.html#a0de2220bd3ec4fbe166f144b3dfb253c',1,'egoa::PowerGridIO::write(PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)'],['../classegoa_1_1_power_grid_i_o.html#a9d292ab44b61782b90a328e029c2fbbb',1,'egoa::PowerGridIO::write(PowerGrid< GraphType > const &network, std::string const &filename, WriterFunctionStreamBasedtionStringBased writer=PowerGridIO< GraphType >::write)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a0e763b5f751b54e099f0e6e39ce84a5f',1,'egoa::IO::GeoJsonWriter::write(TNetwork const &network, std::string const &filename)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac75fccb3c94fd9b80cfb4c5569771b62',1,'egoa::IO::GeoJsonWriter::write(TNetwork const &network, std::ostream &outputStream)']]], + ['writecollectiontofilewith_4',['WriteCollectionToFileWith',['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#afb041e19ec019ed08e7a2a28579f9a26',1,'egoa::IO::DtpRuntimeCollection']]], + ['writeedgeproperties_5',['WriteEdgeProperties',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a02adb8fcc493ce5db479752c16374d10',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturebegin_6',['WriteFeatureBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a77e7f8383c850754f8f086a534a13e53',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturecollection_7',['WriteFeatureCollection',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a75fce8973e44387a2d4f96efbb88eae1',1,'egoa::IO::GeoJsonWriter']]], + ['writefeatureend_8',['WriteFeatureEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac96da28ab1ce367560d737df061b895e',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturesbegin_9',['WriteFeaturesBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a86cc11fbd32555fd785bc079a8d0ea4f',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturesend_10',['WriteFeaturesEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a60920d4689a899f580059f23b295b0dc',1,'egoa::IO::GeoJsonWriter']]], + ['writefooter_11',['WriteFooter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a30377deec1f69334b0659d2fffc0fba2',1,'egoa::IO::GeoJsonWriter']]], + ['writegenerators_12',['WriteGenerators',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#aec1d64deff7ea1521dac6ec894f91efb',1,'egoa::IO::GeoJsonWriter']]], + ['writegeojson_13',['writegeojson',['../classegoa_1_1_power_grid_i_o.html#ae172e258427f0015acaf2c56cc8a5732',1,'egoa::PowerGridIO::WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#a7210c5493b1e1eeb422592b78f252b24',1,'egoa::PowerGridIO::WriteGeoJson(PowerGrid< GraphType > const &network, std::ostream &outputStream)']]], + ['writegeometry_14',['WriteGeometry',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a109bc62f14c3d8d93f5195cfea1c4f19',1,'egoa::IO::GeoJsonWriter']]], + ['writegraph_15',['WriteGraph',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac9c65c096f625ef9e6eda614bc72a870',1,'egoa::IO::GeoJsonWriter']]], + ['writegraphdot_16',['WriteGraphDot',['../classegoa_1_1_power_grid_i_o.html#a4ba3661e93a96d37b508de3c4d9a1b2c',1,'egoa::PowerGridIO']]], + ['writegraphgml_17',['writegraphgml',['../classegoa_1_1_power_grid_i_o.html#a37b1c87e63f0b4f135a884b4cbab218b',1,'egoa::PowerGridIO::WriteGraphGml(PowerGrid< GraphType > const &network, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#ab74ff50470deaf3ac2ef6184ea9c0795',1,'egoa::PowerGridIO::WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)']]], + ['writeheader_18',['WriteHeader',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a041233dbb750691b802118256188a7c2',1,'egoa::IO::GeoJsonWriter']]], + ['writeieeecdfmatlab_19',['writeIeeeCdfMatlab',['../classegoa_1_1_power_grid_i_o.html#a4aa74be3dcfee48668f7ca08d05be756',1,'egoa::PowerGridIO']]], + ['writelinecontent_20',['WriteLineContent',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#adc7921567c5f60122e1ac1b793fe6d8c',1,'egoa::IO::GeoJsonWriter']]], + ['writelinefooter_21',['WriteLineFooter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a67d081b57551d6f93b178544cd373236',1,'egoa::IO::GeoJsonWriter']]], + ['writelineheader_22',['WriteLineHeader',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a3dcb4176b6dc9169639fe8de3680bc32',1,'egoa::IO::GeoJsonWriter']]], + ['writelines_23',['WriteLines',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a540ebeccc60beb0fb598ba7bac904fcf',1,'egoa::IO::GeoJsonWriter']]], + ['writelinesgeometryobject_24',['WriteLinesGeometryObject',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ae5b009b3b09079bca4530c4e311dd269',1,'egoa::IO::GeoJsonWriter']]], + ['writepoint_25',['writepoint',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a84bf6a2084d762e25c5eeed5d0078c8a',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a9234cb13b3947c4d7e4e5f96d1cd33dd',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, TVertex const &vertex, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a900fd57fc0067f496e31bb66d26d72a1',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, TGraph const &graph, Types::vertexId vertexId, Types::count indent=2)']]], + ['writepointcoordinate_26',['writepointcoordinate',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a0c3b81ae05dabf37cfc8476b32f9d59a',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a494bad1941c94315ec0cdae62ffe77d8',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, TGraph const &graph, Types::vertexId vertexId)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a70369703edb90eb75964866639028d8f',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, TVertex const &vertex)']]], + ['writepropertiesbegin_27',['WritePropertiesBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a642863479b23f0e2af1493e5695d0291',1,'egoa::IO::GeoJsonWriter']]], + ['writepropertiesend_28',['WritePropertiesEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5def64f499a544c41fd15a8286ab36c1',1,'egoa::IO::GeoJsonWriter']]], + ['writevertexproperties_29',['WriteVertexProperties',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac518cb0ce7e2563acca2c1073037f269',1,'egoa::IO::GeoJsonWriter']]], + ['writevertices_30',['WriteVertices',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5fdaab77ac47fa9b4ff87bd4e5f5c6f1',1,'egoa::IO::GeoJsonWriter']]] +]; diff --git a/search/all_17.js b/search/all_17.js new file mode 100644 index 00000000..3996cd8e --- /dev/null +++ b/search/all_17.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['xcoordinate_5f_0',['xcoordinate_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#aa14a0639dd1a9f5ca9473654affdc4a1',1,'egoa::Vertices::ElectricalProperties::xCoordinate_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#afe316aaff53999ea0c1ad2b44a028846',1,'egoa::Vertices::GeneratorProperties::xCoordinate_']]] +]; diff --git a/search/all_18.js b/search/all_18.js new file mode 100644 index 00000000..9a36de74 --- /dev/null +++ b/search/all_18.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['ycoordinate_5f_0',['ycoordinate_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#aa43a0b04af68311329ba5eb86b76560c',1,'egoa::Vertices::ElectricalProperties::yCoordinate_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac39232a966200f43c51a4c0d67f88da3',1,'egoa::Vertices::GeneratorProperties::yCoordinate_']]], + ['yellow_1',['Yellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a51e6cd92b6c45f9affdc158ecca2b8b8',1,'egoa::Color']]], + ['yellowgreen_2',['Yellowgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a35f693dc6a5bbd4ba7a55ee26c591b3c',1,'egoa::Color']]] +]; diff --git a/search/all_19.js b/search/all_19.js new file mode 100644 index 00000000..c8284164 --- /dev/null +++ b/search/all_19.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['zone_0',['zone',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4748db1869c7a89935a0cf1be85e5872',1,'egoa::Vertices::ElectricalProperties::Zone() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a35bc0d019231d0e7ab9262b3aaa8903c',1,'egoa::Vertices::ElectricalProperties::Zone()']]], + ['zone_5f_1',['zone_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#ad62b64d589067385818f02345a3edddb',1,'egoa::Vertices::ElectricalProperties']]] +]; diff --git a/search/all_1a.js b/search/all_1a.js new file mode 100644 index 00000000..34808062 --- /dev/null +++ b/search/all_1a.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['_7ebetweennesscentrality_0',['~BetweennessCentrality',['../classegoa_1_1_betweenness_centrality.html#a4dea8510cece6f21a3dbb0e8be51fd81',1,'egoa::BetweennessCentrality']]], + ['_7ebucketelement_1',['~BucketElement',['../classegoa_1_1_bucket_element.html#ae6a88619a340d4ba8a657fefb2e348a3',1,'egoa::BucketElement']]], + ['_7elabel_2',['~Label',['../classegoa_1_1_label.html#a4494f59f3612cf96565681d326a83196',1,'egoa::Label']]], + ['_7esusceptancenormlabel_3',['~SusceptanceNormLabel',['../classegoa_1_1_susceptance_norm_label.html#ad3b0233d45b405ed5e54a36bd3a82692',1,'egoa::SusceptanceNormLabel']]], + ['_7evoltageangledifferencelabel_4',['~VoltageAngleDifferenceLabel',['../classegoa_1_1_voltage_angle_difference_label.html#a9520741a9e44209cd308ea3d62f64db0',1,'egoa::VoltageAngleDifferenceLabel']]] +]; diff --git a/search/all_2.js b/search/all_2.js new file mode 100644 index 00000000..633d1cf2 --- /dev/null +++ b/search/all_2.js @@ -0,0 +1,42 @@ +var searchData= +[ + ['callback_0',['callback',['../classegoa_1_1_callback_empty.html#a4e52f67483c555935413350f0be82187',1,'egoa::CallbackEmpty']]], + ['callbackempty_1',['callbackempty',['../classegoa_1_1_callback_empty.html',1,'egoa::CallbackEmpty< LoggingType >'],['../classegoa_1_1_callback_empty.html#a5e0d6546be59310b523f35b9d56ef36c',1,'egoa::CallbackEmpty::CallbackEmpty()']]], + ['capitalcost_2',['capitalcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#ac7d904efcffabd3b1fdf7e85da59324d',1,'egoa::Vertices::GeneratorProperties::CapitalCost()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a6b5b57c65f01307a95ecf4a12ef68e01',1,'egoa::Vertices::GeneratorProperties::CapitalCost() const']]], + ['capitalcost_5f_3',['capitalcost_',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa705ecde6c467735031c61426f5c0cf7',1,'egoa::Vertices::GeneratorProperties::capitalCost_'],['../classegoa_1_1_edges_1_1_electrical_properties.html#ac43b46d0cdba8211a125c8f6cc9d765d',1,'egoa::Edges::ElectricalProperties::capitalCost_']]], + ['carrier_4',['carrier',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a03064c5c65f5cc172eddb622c3691ab4',1,'egoa::Vertices::ElectricalProperties::Carrier() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a7058b1435a432f2e75e3637be42c2b97',1,'egoa::Vertices::ElectricalProperties::Carrier()']]], + ['carrier_5f_5',['carrier_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a14d54e177a2edf5c7ece16871a570bfd',1,'egoa::Vertices::ElectricalProperties']]], + ['carrierdifferentiation_6',['CarrierDifferentiation',['../classegoa_1_1_edges_1_1_carrier_differentiation.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3aac_20_3e_7',['CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3adc_20_3e_8',['CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3aunknown_20_3e_9',['CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4.html',1,'egoa::Edges']]], + ['changekey_10',['changekey',['../classegoa_1_1_binary_heap.html#a32f301375717a4abda57aeff9aa2b8d7',1,'egoa::BinaryHeap::ChangeKey()'],['../classegoa_1_1_mapping_binary_heap.html#a70b78d6ff717bdb9fdae6546264d9da2',1,'egoa::MappingBinaryHeap::ChangeKey()']]], + ['charge_5f_11',['charge_',['../classegoa_1_1_edges_1_1_electrical_properties.html#abf7f7caa374f75f7c64551ba64d7360f',1,'egoa::Edges::ElectricalProperties']]], + ['classes_20and_20functions_12',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['clear_13',['clear',['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#a6610c78a3b19bfcefa408e289dfd0bf5',1,'egoa::IO::DtpRuntimeCollection::Clear()'],['../classegoa_1_1_betweenness_centrality.html#a726a482ac4015caf4f88e636882069ca',1,'egoa::BetweennessCentrality::Clear()'],['../classegoa_1_1_betweenness_centrality.html#ad3f95270ddc70955c916bfcfcb2b32ff',1,'egoa::BetweennessCentrality::Clear(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)'],['../classegoa_1_1_traversal.html#a16a8f3d5368e56afc35166b2fc303808',1,'egoa::Traversal::Clear()'],['../classegoa_1_1_dominating_theta_path.html#aae5af8526bc9d9801b5eec759c0ea570',1,'egoa::DominatingThetaPath::Clear()'],['../classegoa_1_1_binary_heap.html#ae02a88c3d74658f65aeee90648b80e04',1,'egoa::BinaryHeap::Clear()'],['../classegoa_1_1_bucket.html#a079a770091b121c8f49847808093787e',1,'egoa::Bucket::Clear()'],['../classegoa_1_1_mapping_binary_heap.html#acbda4dfd6050c4a42e4bfe358dcf2c17',1,'egoa::MappingBinaryHeap::Clear()']]], + ['collection_14',['collection',['../classegoa_1_1_betweenness_centrality.html#ad7d0e598a45f218bdaa8cfa2b56a58f5',1,'egoa::BetweennessCentrality::Collection()'],['../classegoa_1_1_betweenness_centrality.html#a6cdf654836aae93382f109c091320c49',1,'egoa::BetweennessCentrality::Collection() const']]], + ['collection_5f_15',['collection_',['../classegoa_1_1_betweenness_centrality.html#add3a6ef33623349ea43b60e967439d1b',1,'egoa::BetweennessCentrality']]], + ['color_16',['Color',['../classegoa_1_1_color.html',1,'egoa']]], + ['committable_17',['committable',['../classegoa_1_1_vertices_1_1_generator_properties.html#a4c36abad4e60e301625934b6dcd560b2',1,'egoa::Vertices::GeneratorProperties::Committable() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1d6a8938801c4130e2cd3989a8f8673e',1,'egoa::Vertices::GeneratorProperties::Committable()']]], + ['committable_5f_18',['committable_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a91812bc2d479165eb609ca1b8a3b48e1',1,'egoa::Vertices::GeneratorProperties']]], + ['comparator_19',['comparator',['../classegoa_1_1_binary_heap.html#aad4e0b63b85863dffe5d10f9d662ac6b',1,'egoa::BinaryHeap::Comparator()'],['../classegoa_1_1_mapping_binary_heap.html#a686e4897e64991add589aacbcd1f811f',1,'egoa::MappingBinaryHeap::Comparator() const'],['../classegoa_1_1_mapping_binary_heap.html#abb772637c836e22f4a54faa6e569f7cf',1,'egoa::MappingBinaryHeap::Comparator(std::function< bool(TKey const &, TKey const &)> comparator)'],['../classegoa_1_1_binary_heap.html#ac263b671464c498a474846c992ea7be0',1,'egoa::BinaryHeap::Comparator()']]], + ['comparator_5f_20',['comparator_',['../classegoa_1_1_mapping_binary_heap.html#ad9167a6428813dbf974f22cda65de763',1,'egoa::MappingBinaryHeap']]], + ['complyheapproperty_21',['complyheapproperty',['../classegoa_1_1_binary_heap.html#a4bb0c3733563757bd2f93a21f463a760',1,'egoa::BinaryHeap::ComplyHeapProperty(Types::index index) const'],['../classegoa_1_1_binary_heap.html#abdb707e89c827b6e85e02b402f8641be',1,'egoa::BinaryHeap::ComplyHeapProperty() const'],['../classegoa_1_1_mapping_binary_heap.html#a3fc10be4cd1134c62633ae4f4485e966',1,'egoa::MappingBinaryHeap::ComplyHeapProperty() const'],['../classegoa_1_1_mapping_binary_heap.html#a4e413014e12198bdb7c0fe3b3b246832',1,'egoa::MappingBinaryHeap::ComplyHeapProperty(Types::index index) const']]], + ['compressstring_22',['CompressString',['../classegoa_1_1_py_psa_parser.html#a4a496bc83188bafb13caad13aaf19cf0',1,'egoa::PyPsaParser']]], + ['conductance_23',['conductance',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html#ad0df5cdde3487031ac2c8104b7e9e365',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Conductance()'],['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html#a530d0988b2983ee14dde99a0a1972925',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Conductance()']]], + ['conductance_5f_24',['conductance_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a27e144d78979695a75bc0b704f4e3bef',1,'egoa::Edges::ElectricalProperties']]], + ['containerloop_25',['ContainerLoop',['../structegoa_1_1internal_1_1_container_loop.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3abreakable_20_3e_26',['ContainerLoop< ExecutionPolicy::breakable >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3aparallel_20_3e_27',['ContainerLoop< ExecutionPolicy::parallel >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3asequential_20_3e_28',['ContainerLoop< ExecutionPolicy::sequential >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['control_29',['control',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a8d1579c39b1bb4bb25e4324ec5dc63a6',1,'egoa::Vertices::ElectricalProperties::Control() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a0493d7a5e96c379dc5946a58a52eea4e',1,'egoa::Vertices::ElectricalProperties::Control()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#af42b85bfea7d5434818bd34c0e3984e9',1,'egoa::Vertices::GeneratorProperties::Control() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aa5348d489ace5975cbd792772a5aff1a',1,'egoa::Vertices::GeneratorProperties::Control()']]], + ['control_5f_30',['control_',['../classegoa_1_1_vertices_1_1_electrical_properties.html#acaf8528c99cf9803c2f7bfb223197ce8',1,'egoa::Vertices::ElectricalProperties::control_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a0cef71ce759f49314432fd3fb140efb2',1,'egoa::Vertices::GeneratorProperties::control_']]], + ['counter_5f_31',['counter_',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a27f571162216f692b5a9b6060639d036',1,'egoa::BinaryHeap::HeapIterator']]], + ['country_32',['country',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a488f1c1601f980c4a1bb8f397540842d',1,'egoa::Vertices::ElectricalProperties::Country() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6480106fe6180e5e2d8706a845ea3a57',1,'egoa::Vertices::ElectricalProperties::Country()']]], + ['currentblockid_33',['CurrentBlockId',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#a0418f23a4971f0e310a005869397922c',1,'egoa::internal::BlockCutTreeBuilder']]], + ['cut_20tree_20related_20classes_20and_20functions_34',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['cutvertex_35',['CutVertex',['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html',1,'egoa::BlockCutTree']]], + ['cutvertexat_36',['CutVertexAt',['../classegoa_1_1_block_cut_tree.html#aa01116b5db1c97981955bdb543201ee3',1,'egoa::BlockCutTree']]], + ['cutvertices_37',['CutVertices',['../classegoa_1_1_block_cut_tree_1_1_block.html#abb19621690dd330e8b8ef11cb3f7ae02',1,'egoa::BlockCutTree::Block']]], + ['cutvertices_5f_38',['cutVertices_',['../classegoa_1_1_block_cut_tree.html#aa2bf707809240e92d697df458d66b6b9',1,'egoa::BlockCutTree']]] +]; diff --git a/search/all_3.js b/search/all_3.js new file mode 100644 index 00000000..f9aabadd --- /dev/null +++ b/search/all_3.js @@ -0,0 +1,28 @@ +var searchData= +[ + ['decreasekey_0',['DecreaseKey',['../classegoa_1_1_binary_heap.html#a356c3c1e41ee36b6e60e5062ce207f76',1,'egoa::BinaryHeap']]], + ['degreeat_1',['degreeat',['../classegoa_1_1_static_graph.html#af3e1e2192a82df308586cd33bcd2ba06',1,'egoa::StaticGraph::DegreeAt()'],['../classegoa_1_1_dynamic_graph.html#a2a1b9ba2254788fda5a506e7bd017be9',1,'egoa::DynamicGraph::DegreeAt()']]], + ['delete_2',['Delete',['../classegoa_1_1_mapping_binary_heap.html#a031670180172a3688c132f3c68e5cd85',1,'egoa::MappingBinaryHeap']]], + ['deletetop_3',['deletetop',['../classegoa_1_1_mapping_binary_heap.html#a4d741d83c77f4e05c506c66896efb874',1,'egoa::MappingBinaryHeap::DeleteTop()'],['../classegoa_1_1_bucket.html#aa290c3db7f4f6a2867a04a0811864cff',1,'egoa::Bucket::DeleteTop()'],['../classegoa_1_1_binary_heap.html#a0d3efd2287a24e752ab10bd69b1b7cdf',1,'egoa::BinaryHeap::DeleteTop()']]], + ['depthfirstsearch_4',['depthfirstsearch',['../classegoa_1_1_depth_first_search.html',1,'egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >'],['../classegoa_1_1_depth_first_search.html#ac4af467357c5d9343548fb0ae933e369',1,'egoa::DepthFirstSearch::DepthFirstSearch()']]], + ['depthfirstsearch_3c_20graphtype_2c_20false_20_3e_5',['DepthFirstSearch< GraphType, false >',['../classegoa_1_1_depth_first_search.html',1,'egoa']]], + ['depthfirstsearch_3c_20graphtype_2c_20isdirected_20_3e_6',['DepthFirstSearch< GraphType, IsDirected >',['../classegoa_1_1_depth_first_search.html',1,'egoa']]], + ['dequeuevertex_7',['DequeueVertex',['../classegoa_1_1_b_f_s.html#a168fd3b51fe0e1f4f5b9f28d1b513e75',1,'egoa::BFS']]], + ['difference_5ftype_8',['difference_type',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a7b05d3757af6992e9eacdd8584f666aa',1,'egoa::BinaryHeap::HeapIterator']]], + ['dominates_9',['Dominates',['../classegoa_1_1_bucket.html#a7e33691f54908fcc6530e41333f0e46e',1,'egoa::Bucket']]], + ['dominatingthetapath_10',['dominatingthetapath',['../classegoa_1_1_dominating_theta_path.html#affe6bf56c3e86b4dd5a9ec4f405c872f',1,'egoa::DominatingThetaPath::DominatingThetaPath(TGraph const &graph, TVertexId source)'],['../classegoa_1_1_dominating_theta_path.html#af8fe08362087e9c8a01875c457c2599c',1,'egoa::DominatingThetaPath::DominatingThetaPath(TGraph const &graph)'],['../classegoa_1_1_dominating_theta_path.html',1,'egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >']]], + ['dominationcriterion_11',['DominationCriterion',['../namespaceegoa.html#a8139eea6466926933882a4a21a929b52',1,'egoa']]], + ['dominationdifferentiation_12',['DominationDifferentiation',['../classegoa_1_1internal_1_1_domination_differentiation.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3anone_20_3e_13',['DominationDifferentiation< ElementType, DominationCriterion::none >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3astrict_20_3e_14',['DominationDifferentiation< ElementType, DominationCriterion::strict >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3aweak_20_3e_15',['DominationDifferentiation< ElementType, DominationCriterion::weak >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4.html',1,'egoa::internal']]], + ['dtpruntimecollection_16',['DtpRuntimeCollection',['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html',1,'egoa::IO']]], + ['dtpruntimerow_17',['DtpRuntimeRow',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html',1,'egoa::IO']]], + ['dtpruntimerow_5f_18',['dtpRuntimeRow_',['../classegoa_1_1_dominating_theta_path.html#a2b1331389971b6eabebe411f938d1dd0',1,'egoa::DominatingThetaPath']]], + ['dumpbranches_19',['DumpBranches',['../classegoa_1_1_static_graph.html#ac436ac9f1ccaf66f05bdd5db6a9207d4',1,'egoa::StaticGraph']]], + ['dumpbuses_20',['DumpBuses',['../classegoa_1_1_static_graph.html#aefcd3022d222d4c6a2dabedc73cb500f',1,'egoa::StaticGraph']]], + ['dynamicgraph_21',['dynamicgraph',['../classegoa_1_1_dynamic_graph.html#a9ee4ffd9898c33853d61c227665da257',1,'egoa::DynamicGraph::DynamicGraph()'],['../classegoa_1_1_dynamic_graph.html',1,'egoa::DynamicGraph< VertexProperties, EdgeProperties >']]], + ['dynamicgraphloopdifferentiation_22',['DynamicGraphLoopDifferentiation',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html',1,'egoa::internal']]], + ['dynamicgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_23',['DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['dynamicgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_24',['DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html',1,'egoa::internal']]] +]; diff --git a/search/all_4.js b/search/all_4.js new file mode 100644 index 00000000..ba3b8923 --- /dev/null +++ b/search/all_4.js @@ -0,0 +1,38 @@ +var searchData= +[ + ['edge_0',['edge',['../classegoa_1_1io_1_1_edge.html',1,'egoa::io::Edge< PropertiesType >'],['../classegoa_1_1_edges_1_1_edge.html',1,'egoa::Edges::Edge< PropertiesType >'],['../classegoa_1_1_dynamic_graph.html#a32b554140f95c4ac708ce8ce43171a29',1,'egoa::DynamicGraph::Edge(Types::vertexId source, Types::vertexId target)'],['../classegoa_1_1_dynamic_graph.html#abb8fea91b2be3d60fff358f01b5dc7c5',1,'egoa::DynamicGraph::Edge(Types::vertexId source, Types::vertexId target) const'],['../classegoa_1_1_static_graph.html#a0c9f6fa55ef57510c79729b99bde929f',1,'egoa::StaticGraph::Edge(Types::vertexId source, Types::vertexId target)'],['../classegoa_1_1_static_graph.html#a24aa79b734e23ec6cec7cc03e4b91e43',1,'egoa::StaticGraph::Edge(Types::vertexId source, Types::vertexId target) const']]], + ['edgeat_1',['edgeat',['../classegoa_1_1_static_graph.html#abfa8efe41c4018083b645b499d4de7e5',1,'egoa::StaticGraph::EdgeAt()'],['../classegoa_1_1_dynamic_graph.html#adc8d7afadb434fe0fbe760f0970fdf8d',1,'egoa::DynamicGraph::EdgeAt(Types::edgeId id)'],['../classegoa_1_1_dynamic_graph.html#a3244fc4ae09b639bdbd2e74c9a12aaf8',1,'egoa::DynamicGraph::EdgeAt(Types::edgeId id) const'],['../classegoa_1_1_static_graph.html#a10d486bd8274d1ce8c5ccf0cf47d26a7',1,'egoa::StaticGraph::EdgeAt(Types::edgeId id)']]], + ['edgeexists_2',['edgeexists',['../classegoa_1_1_static_graph.html#a7f2495997d905bdb52753866ac790ede',1,'egoa::StaticGraph::EdgeExists()'],['../classegoa_1_1_dynamic_graph.html#ad149f47e6565706c381c2cfafceb2b51',1,'egoa::DynamicGraph::EdgeExists(Types::edgeId id) const']]], + ['edgeexists_5f_3',['edgeExists_',['../classegoa_1_1_dynamic_graph.html#a7263e0c6e21880567a5d13572ea7416d',1,'egoa::DynamicGraph']]], + ['edgeid_4',['edgeid',['../classegoa_1_1_dynamic_graph.html#a1e438958e16b55645d58856750cbfc92',1,'egoa::DynamicGraph::EdgeId()'],['../classegoa_1_1_static_graph.html#a4ed0a34dd2b305dbc8463206972665ea',1,'egoa::StaticGraph::EdgeId()']]], + ['edgeidsat_5',['edgeidsat',['../classegoa_1_1_dynamic_graph.html#a7aa5848a1c287dde558f4135fab13517',1,'egoa::DynamicGraph::EdgeIdsAt(Types::vertexId id) const'],['../classegoa_1_1_dynamic_graph.html#aee19490a79f77a34e85958e56e8e2144',1,'egoa::DynamicGraph::EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const'],['../classegoa_1_1_static_graph.html#aa3c01ce2db959c0cd055d5b3ec6e5439',1,'egoa::StaticGraph::EdgeIdsAt(Types::vertexId id) const'],['../classegoa_1_1_static_graph.html#a0b4cdfbba3b86015e99fd81eba8766b2',1,'egoa::StaticGraph::EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const']]], + ['edges_6',['edges',['../classegoa_1_1_dynamic_graph.html#ac4d6b3c7fa7e6109040afbab966e2430',1,'egoa::DynamicGraph::Edges()'],['../classegoa_1_1_dynamic_graph.html#ae35b1600e1771a861b7ba1b9a02de89d',1,'egoa::DynamicGraph::Edges() const'],['../classegoa_1_1_static_graph.html#a38e67ce8dc03be3dba7dda765b82e87b',1,'egoa::StaticGraph::Edges()'],['../classegoa_1_1_static_graph.html#a7d8adace9442cbddf9ddacc577d49efc',1,'egoa::StaticGraph::Edges() const'],['../classegoa_1_1_subgraph.html#a88d8ecd65b4e1104b6d8b8e46d15964c',1,'egoa::Subgraph::Edges()']]], + ['edges_5f_7',['edges_',['../classegoa_1_1_static_graph.html#ab9140ed231f5fa7ffa7a81cf54a4728a',1,'egoa::StaticGraph::edges_'],['../classegoa_1_1_subgraph.html#aa3e411c0c097df8ad80ba17698263ca8',1,'egoa::Subgraph::edges_'],['../classegoa_1_1_dynamic_graph.html#a01463313296ebd7ecbe6a2e5a113e161',1,'egoa::DynamicGraph::edges_']]], + ['efficiency_8',['efficiency',['../classegoa_1_1_vertices_1_1_generator_properties.html#ae069e33e6b158f62d1e53f65436870b0',1,'egoa::Vertices::GeneratorProperties::Efficiency()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a97fbddc5183d914c53343d4e61951782',1,'egoa::Vertices::GeneratorProperties::Efficiency() const']]], + ['efficiency_5f_9',['efficiency_',['../classegoa_1_1_vertices_1_1_generator_properties.html#afee07ce895c0bb7924f45f1adaa73f43',1,'egoa::Vertices::GeneratorProperties']]], + ['egoa_10',['egoa',['../namespaceegoa.html',1,'']]], + ['egoa_3a_3adynamicgraph_11',['DynamicGraph',['../classegoa_1_1_vertices_1_1_vertex.html#a9636035b0c11f531de54e2f038a4f782',1,'egoa::Vertices::Vertex']]], + ['electricalproperties_12',['electricalproperties',['../classegoa_1_1_vertices_1_1_electrical_properties.html',1,'egoa::Vertices::ElectricalProperties< VertexType >'],['../classegoa_1_1_edges_1_1_electrical_properties.html',1,'egoa::Edges::ElectricalProperties'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a9bf6a104189abd1c9e7f46ed1bec4c98',1,'egoa::Vertices::ElectricalProperties::ElectricalProperties()']]], + ['elementat_13',['ElementAt',['../classegoa_1_1_bucket.html#a147561d4064e0ee6e9aa5c94059a4517',1,'egoa::Bucket']]], + ['elementend_5f_14',['elementEnd_',['../classegoa_1_1_omitting_iterator.html#a684d0276f49441bbcbffcb5ac67e68c5',1,'egoa::OmittingIterator']]], + ['elementiterator_5f_15',['elementIterator_',['../classegoa_1_1_omitting_iterator.html#aa5b23c3c85825fdd2a3b8537ea98cde5',1,'egoa::OmittingIterator']]], + ['elementkeypairs_5f_16',['elementKeyPairs_',['../classegoa_1_1_mapping_binary_heap.html#a14ec59c226fa2316d2b6de1d952ff20d',1,'egoa::MappingBinaryHeap']]], + ['emplace_17',['emplace',['../classegoa_1_1_binary_heap.html#a09548553ba14903bbcbdb76d65525560',1,'egoa::BinaryHeap::Emplace()'],['../classegoa_1_1_mapping_binary_heap.html#ad10dedadc40f74caa355981e6920ec0d',1,'egoa::MappingBinaryHeap::Emplace()']]], + ['empty_18',['empty',['../classegoa_1_1_std_queue.html#a7369bfe19bbd6819d4308d08bad9f521',1,'egoa::StdQueue::Empty()'],['../classegoa_1_1_queue.html#a85707412da73925d6550f1493d1c99d7',1,'egoa::Queue::Empty()'],['../classegoa_1_1_priority_queue.html#abd6d3009ac4bf71bbd07c125ccfb430f',1,'egoa::PriorityQueue::Empty()'],['../classegoa_1_1_bucket.html#a520be7a55da5c0e833c7991e28d81d9b',1,'egoa::Bucket::Empty()'],['../classegoa_1_1_binary_heap.html#a1cb3be2538725fa3507b839685bf8842',1,'egoa::BinaryHeap::Empty()'],['../classegoa_1_1_mapping_binary_heap.html#ab02fdcef7529f80eed87910f30b26a9b',1,'egoa::MappingBinaryHeap::Empty()']]], + ['emptyqueue_19',['EmptyQueue',['../classegoa_1_1_bucket.html#a366d0b9fa492768c44a96c990a970df7',1,'egoa::Bucket']]], + ['end_20',['end',['../classegoa_1_1_binary_heap.html#a99391e079755c46f1420ef4456470bab',1,'egoa::BinaryHeap']]], + ['end_5f_21',['end_',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#acfb12396c51cb3f4ac05f60e6393fe02',1,'egoa::BinaryHeap::HeapIterator']]], + ['enqueuevertexwith_22',['EnqueueVertexWith',['../classegoa_1_1_b_f_s.html#ab487b4204397892869cb9dd0d7a88e4d',1,'egoa::BFS']]], + ['entrytime_5f_23',['entryTime_',['../classegoa_1_1_depth_first_search.html#a51ec154197629ff5d16a2c95fa2d4888',1,'egoa::DepthFirstSearch']]], + ['entrytimeat_24',['EntryTimeAt',['../classegoa_1_1_depth_first_search.html#a9dce9b349b010225c162de99d367c5cf',1,'egoa::DepthFirstSearch']]], + ['executionpolicy_25',['ExecutionPolicy',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369',1,'egoa']]], + ['existsiterator_5f_26',['existsIterator_',['../classegoa_1_1_omitting_iterator.html#ae5a246c1e2055457cc7d44056affa243',1,'egoa::OmittingIterator']]], + ['exittime_5f_27',['exitTime_',['../classegoa_1_1_depth_first_search.html#a2c4bc9b765001803b9b71a3a21a142d2',1,'egoa::DepthFirstSearch']]], + ['exittimeat_28',['ExitTimeAt',['../classegoa_1_1_depth_first_search.html#a11e41dff0d8c2be6ec745f668307aa8c',1,'egoa::DepthFirstSearch']]], + ['extractbusheader_29',['ExtractBusHeader',['../classegoa_1_1_py_psa_parser.html#a32e8d95122b25ec21c03da929a693345',1,'egoa::PyPsaParser']]], + ['extractgeneratorheader_30',['ExtractGeneratorHeader',['../classegoa_1_1_py_psa_parser.html#a0054068f7f6a1907c018b43d697c2915',1,'egoa::PyPsaParser']]], + ['extractgeneratormaximumrealpowerpuheader_31',['ExtractGeneratorMaximumRealPowerPuHeader',['../classegoa_1_1_py_psa_parser.html#a5d7e5a87c8f58b94070ee9dbe3049d04',1,'egoa::PyPsaParser']]], + ['extractlineheader_32',['ExtractLineHeader',['../classegoa_1_1_py_psa_parser.html#ae759e235d270b5684268705973da0cf2',1,'egoa::PyPsaParser']]], + ['extractloadheader_33',['ExtractLoadHeader',['../classegoa_1_1_py_psa_parser.html#a15e8a2ed2af474095e31d3485e7955c5',1,'egoa::PyPsaParser']]], + ['extractloadmaximumrealpowerpuheader_34',['ExtractLoadMaximumRealPowerPuHeader',['../classegoa_1_1_py_psa_parser.html#a029ede340ed897d5084f09e772b2b0fe',1,'egoa::PyPsaParser']]] +]; diff --git a/search/all_5.js b/search/all_5.js new file mode 100644 index 00000000..10208115 --- /dev/null +++ b/search/all_5.js @@ -0,0 +1,52 @@ +var searchData= +[ + ['filenamebuses_5f_0',['filenameBuses_',['../classegoa_1_1_py_psa_parser.html#ad7b0ceb8420ea0de5534bdb3d75da442',1,'egoa::PyPsaParser']]], + ['filenamecarriers_5f_1',['filenameCarriers_',['../classegoa_1_1_py_psa_parser.html#af7dfffdfe7aefe0355bf8a0843120379',1,'egoa::PyPsaParser']]], + ['filenamegenerators_5f_2',['filenameGenerators_',['../classegoa_1_1_py_psa_parser.html#abb9f48b7b7eb08a8855d71913b9e6b94',1,'egoa::PyPsaParser']]], + ['filenamegeneratorspmaxpu_5f_3',['filenameGeneratorsPMaxPu_',['../classegoa_1_1_py_psa_parser.html#a68c2844ed9fda612c47bea8b5d66f9c1',1,'egoa::PyPsaParser']]], + ['filenameglobalconstraints_5f_4',['filenameGlobalConstraints_',['../classegoa_1_1_py_psa_parser.html#a470aad41f118222976e00327e332ee1a',1,'egoa::PyPsaParser']]], + ['filenamelines_5f_5',['filenameLines_',['../classegoa_1_1_py_psa_parser.html#a9214eb1a54c945453e369268a4e7f447',1,'egoa::PyPsaParser']]], + ['filenamelinesnew_5f_6',['filenameLinesNew_',['../classegoa_1_1_py_psa_parser.html#a733eb3a76fc426116c2546ce5dee3a9a',1,'egoa::PyPsaParser']]], + ['filenameloads_5f_7',['filenameLoads_',['../classegoa_1_1_py_psa_parser.html#af9352b1c10830d3a1c29889301045613',1,'egoa::PyPsaParser']]], + ['filenameloadspset_5f_8',['filenameLoadsPSet_',['../classegoa_1_1_py_psa_parser.html#a0e676cb08bda8c991b4b0cf8f917ade1',1,'egoa::PyPsaParser']]], + ['filenamenetwork_5f_9',['filenameNetwork_',['../classegoa_1_1_py_psa_parser.html#aa16e5d2aa13af092d7c33315bfc9e023',1,'egoa::PyPsaParser']]], + ['filenamesnapshots_5f_10',['filenameSnapshots_',['../classegoa_1_1_py_psa_parser.html#a97ae602842cd10fbe76a2f2b6a423837',1,'egoa::PyPsaParser']]], + ['filenamestorageunits_5f_11',['filenameStorageUnits_',['../classegoa_1_1_py_psa_parser.html#acd55d080eba5d5e74217934f48a32c1c',1,'egoa::PyPsaParser']]], + ['filenamestorageunitsinflow_5f_12',['filenameStorageUnitsInflow_',['../classegoa_1_1_py_psa_parser.html#af5bce4fc33131944d2986e8c4f049e8e',1,'egoa::PyPsaParser']]], + ['find_13',['Find',['../classegoa_1_1_union_find.html#afc852c1f07799b2459f724e82ef00779',1,'egoa::UnionFind']]], + ['findgenerator_14',['FindGenerator',['../classegoa_1_1_power_grid.html#a256d43c2c8befe79409f9c9fa6263e19',1,'egoa::PowerGrid']]], + ['for_5fall_5fedge_5fidentifiers_15',['for_all_edge_identifiers',['../classegoa_1_1_dynamic_graph.html#a0db535d6ce676f5cd3478d2f339e486c',1,'egoa::DynamicGraph::for_all_edge_identifiers()'],['../classegoa_1_1_static_graph.html#ab32d1f05556899ebcc6a498bad61cbf0',1,'egoa::StaticGraph::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#aab9ec6fd869cb7336854685ec286d289',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a085b9bc5c1ce4e2c869d669b31969a3a',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a46b65d677464470956399fd182be17b3',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#ae5b677549e13b241f9761819d2cefb23',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers()']]], + ['for_5fall_5fedge_5ftuples_16',['for_all_edge_tuples',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a6ff9010bb924b4bd4fab6ecd8962e9c8',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#add9f5a994ba727e88cb84db45c51a9fd',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a4466f5d1e50e54bfcfd48f33d2ae6e08',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ac285583b569683d732c970fc4c513285',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples()'],['../classegoa_1_1_static_graph.html#a704f35ddb41531e6819d8a624ba4a37a',1,'egoa::StaticGraph::for_all_edge_tuples(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#ab8c2f88068bf29e5035dbe3acc268a79',1,'egoa::StaticGraph::for_all_edge_tuples(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a85ea26e0c59adc440259c1aab98807fd',1,'egoa::DynamicGraph::for_all_edge_tuples(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a84f9eb4426920b429672bfcffe440ff8',1,'egoa::DynamicGraph::for_all_edge_tuples(FUNCTION function)']]], + ['for_5fall_5fedges_17',['for_all_edges',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#af0d6197aef75ca5163b479a5bfa8b304',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a81419fa17be4f6262394e9a3a997a3b9',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges()'],['../classegoa_1_1_static_graph.html#aefc8cf433d543a27f5370582913e9a34',1,'egoa::StaticGraph::for_all_edges(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a85558eac6502980273f8978ea2f23590',1,'egoa::StaticGraph::for_all_edges(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a87f2ba6ec2afbf45f62ae8fd02d56627',1,'egoa::DynamicGraph::for_all_edges(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a5d252f761a80d2e82ba86c5210e343bc',1,'egoa::DynamicGraph::for_all_edges(FUNCTION function)']]], + ['for_5fall_5fedges_5fat_18',['for_all_edges_at',['../classegoa_1_1_dynamic_graph.html#a4380e9e5d38e08a96d24639b4cea1202',1,'egoa::DynamicGraph::for_all_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#acd6b8abd14d663fbb5c8cc0694fe4352',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a882df05ab717cd11b0f47754f859951d',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ad61755bdc17e393bf2ea9f1f004e0240',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ac907286942ad2f6488f0475140b85898',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#aaf876b41ea6b985473670091f5c4c3ae',1,'egoa::StaticGraph::for_all_edges_at(Types::vertexId const vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a1bd5f0e1067ae1f83da797c357d3f1f3',1,'egoa::StaticGraph::for_all_edges_at(Types::vertexId const vertexId, FUNCTION function)'],['../classegoa_1_1_static_graph.html#a2cc423a3b75fbef801b91cfb73ce9e69',1,'egoa::StaticGraph::for_all_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#afac98456be676c3cd00a77dca3e89184',1,'egoa::StaticGraph::for_all_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a0675a89b27800b80ce954cdf551aa196',1,'egoa::DynamicGraph::for_all_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a836e06d876dbf323c378361d795120e3',1,'egoa::DynamicGraph::for_all_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a5962842d31b050f7d6f5566b1122c834',1,'egoa::DynamicGraph::for_all_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_traversal.html#af94c3778ec612022824238d75f5b07ea',1,'egoa::Traversal::for_all_edges_at()']]], + ['for_5fall_5felements_19',['for_all_elements',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html#a0d123607a59c7efe14fd401ccc09b1de',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >::for_all_elements()'],['../classegoa_1_1_bucket.html#a9d2ff7a391da969a584f651725c28b5f',1,'egoa::Bucket::for_all_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a123f9994802f624e4d033bdc10de563a',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_elements()'],['../classegoa_1_1_mapping_binary_heap.html#a269321aad4a6a0b3dae5247447a78e9b',1,'egoa::MappingBinaryHeap::for_all_elements()'],['../classegoa_1_1_bucket.html#aebda6283d988bd6e429a20cb2584a262',1,'egoa::Bucket::for_all_elements()'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html#a47a694df50a67aa99fd1dc702a77ea74',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >::for_all_elements()'],['../classegoa_1_1_binary_heap.html#a467eab42a0b77e307faac25b081414a3',1,'egoa::BinaryHeap::for_all_elements(FUNCTION function)'],['../classegoa_1_1_binary_heap.html#a118ad41218d536db12cf983edc8513cd',1,'egoa::BinaryHeap::for_all_elements(FUNCTION function) const'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html#a8dd010f82b1969f4466a69ced894fce6',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >::for_all_elements()'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html#a622e22c9eebb80c4288e7c4e95dd0e92',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >::for_all_elements()']]], + ['for_5fall_5fgenerator_5fidentifiers_5fat_20',['for_all_generator_identifiers_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ace15ff65ad72268ee5a91da7c59907e9',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at()'],['../classegoa_1_1_power_grid.html#af78a7e6f8681c915b7e57ca9060633dc',1,'egoa::PowerGrid::for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a7793963690cabad12caf17d462d269e1',1,'egoa::PowerGrid::for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a9f15c10128ee3f7b9fe16c43ebfe7337',1,'egoa::PowerGrid::for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#aab0e2095dee9e8d070ce324c46649153',1,'egoa::PowerGrid::for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a7072516a00a04296bde02cef9dae27d4',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)']]], + ['for_5fall_5fgenerator_5ftuple_21',['for_all_generator_tuple',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a1f124662e0784ad91c0fbc65474afcd3',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ad3b4df097d9b1011c4035e5b5585ab8a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a4bd9d6916c91b481000f8f64ef354835',1,'egoa::PowerGrid::for_all_generator_tuple(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a914604e39470bcb73c5f5d74b406a4d2',1,'egoa::PowerGrid::for_all_generator_tuple(FUNCTION function) const']]], + ['for_5fall_5fgenerators_22',['for_all_generators',['../classegoa_1_1_power_grid.html#afa5a1f61d19d6553395d86876892167b',1,'egoa::PowerGrid::for_all_generators(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a8fca0b6824734d49ccebf54faf4e5829',1,'egoa::PowerGrid::for_all_generators(FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a17635fc42b1de71ccd6b29b5533ac8ea',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a4839dfea41b399d21be7837fb508fc54',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators(TNetwork &network, FUNCTION function)']]], + ['for_5fall_5fgenerators_5fat_23',['for_all_generators_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8b53975501afff5a061c0b7ff7e8bc76',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(TVertex const &vertex, TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aab0b4332dda6591959c290b84b3a67dd',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a99376951dead16a7078189be98cec379',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a80fbee5fdd9c2dd26d7587b4d2250f14',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ae4a792ea4ffc3376dea6dcabb0d0dbda',1,'egoa::PowerGrid::for_all_generators_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a786360de24038fb411f815aed0d26252',1,'egoa::PowerGrid::for_all_generators_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#aa1f860141ac00eaeefb4685112bf489c',1,'egoa::PowerGrid::for_all_generators_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a248f9c9f9bba1ef5a77e03945ee41e96',1,'egoa::PowerGrid::for_all_generators_at(Types::vertexId vertexId, FUNCTION function) const']]], + ['for_5fall_5fgenerators_5ftuple_24',['for_all_generators_tuple',['../classegoa_1_1_power_grid.html#a9fe0ddf7c0edcac9793c052c999de4f8',1,'egoa::PowerGrid::for_all_generators_tuple()'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a9529d8e2adc6084dfcf6ab7131e82e38',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a297aa3276bfb6cf135ec140fa7c9a697',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple(TNetwork &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab8c2fa98fa9d9da849291547c58f1ca6',1,'egoa::PowerGrid::for_all_generators_tuple()']]], + ['for_5fall_5fload_5fidentifiers_5fat_25',['for_all_load_identifiers_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acbe67421dd0a657604c7adf608eb211d',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a5e8f6a100c3519d110d4e81300f4797b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#af74475869bbbe88123691e5499eece26',1,'egoa::PowerGrid::for_all_load_identifiers_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a07f32fa9850cc3a8c088afbb4cc73d6a',1,'egoa::PowerGrid::for_all_load_identifiers_at(TVertex const &vertex, FUNCTION function) const']]], + ['for_5fall_5fload_5ftuples_26',['for_all_load_tuples',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a7622762b570cbe597fe8c6982986d690',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a72559f9e00d1c9f22ccc295cad680825',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab747c5386d374121dc7c8e13a42b637a',1,'egoa::PowerGrid::for_all_load_tuples(FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac0524bf3d82bbf4e48b436d481a6715c',1,'egoa::PowerGrid::for_all_load_tuples(FUNCTION function) const']]], + ['for_5fall_5floads_27',['for_all_loads',['../classegoa_1_1_power_grid.html#ac0bd33d791239365c809dcc1f8bfdce6',1,'egoa::PowerGrid::for_all_loads(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a151de9659ceb1e7eebdb338f5d9b7a49',1,'egoa::PowerGrid::for_all_loads(FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a4ca3a16313ddc82b1c88eb4acfcc3802',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ad05db4c846174801299eed9d1ded98ac',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads(TNetwork &network, FUNCTION function)']]], + ['for_5fall_5floads_5fat_28',['for_all_loads_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aea678c72a45bcd278d7e26318d433ee9',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(TVertex const &vertex, TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a467e583d036affc5913b3e4cd8f1aea7',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af275f89cc6dbc053bd354f18b18c9356',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a10d86ac105c18a29b1347b3602451330',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a56911873b4fff331788930e50d696400',1,'egoa::PowerGrid::for_all_loads_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac9e6fe7351b505995b846a39c098ca22',1,'egoa::PowerGrid::for_all_loads_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a8b0ae62c5b93adf4a3f92781ad6d7c5c',1,'egoa::PowerGrid::for_all_loads_at(Types::vertexId const vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#aa1e39abe64701ab59a0fc9c10df304d3',1,'egoa::PowerGrid::for_all_loads_at(Types::vertexId vertexId, FUNCTION function) const']]], + ['for_5fall_5floads_5ftuple_29',['for_all_loads_tuple',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a828e84937c6ac07a2dd1236a07c48f27',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_tuple()'],['../classegoa_1_1_power_grid.html#a51d12376204605f2e6ab1ca5e93610bb',1,'egoa::PowerGrid::for_all_loads_tuple()']]], + ['for_5fall_5foptima_30',['for_all_optima',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#acb9806e18e9d6251a99f0230c93841da',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_optima()'],['../classegoa_1_1_bucket.html#a2757d42dbb9835cb82c7382b84dd6e2d',1,'egoa::Bucket::for_all_optima(FUNCTION function)'],['../classegoa_1_1_bucket.html#a455e56655e99772b31abbfd50e5a018c',1,'egoa::Bucket::for_all_optima(FUNCTION function) const']]], + ['for_5fall_5fprocessed_5felements_31',['for_all_processed_elements',['../classegoa_1_1_bucket.html#ac0ddb8197cd5c0a6c42cb21d78a3868a',1,'egoa::Bucket::for_all_processed_elements(FUNCTION function)'],['../classegoa_1_1_bucket.html#abc7d92a50a659392264bcb73a1099aa7',1,'egoa::Bucket::for_all_processed_elements(FUNCTION function) const'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a4a360a7106767d6a90ca17a5fcf6ee74',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_processed_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html#a9685c16e7f128604a0e3d64ae2952d61',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_processed_elements()']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_32',['for_all_real_power_generator_snapshots',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a26f3a9f3bbb9541c7999b7820ce7060e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots()'],['../classegoa_1_1_power_grid.html#a24bb541d6c03c6a82c2ee390886986ca',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots(FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac3939c8260d8ef2b5f06eb127fcd83c0',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots(FUNCTION function) const']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_5fat_33',['for_all_real_power_generator_snapshots_at',['../classegoa_1_1_power_grid.html#a6dc56608af4b8a66020b4bd89b6cdb25',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a6e097493c494f181ec9ee2744c1512db',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a3f2270751eae0ca52bf96d39dbd0c9e1',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab82056f632d6f654a455add5b6e61684',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a1f4d5d6490c71fd603a27ea7fbf824d8',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ae75545ac4a43eaef40717188965d72c5',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#af343164f39f28e735f7dad1454a82ceb',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a9ca374d55ea64a0afbc2346d394fced4',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#afc58d667b2000aff6451e2a229c1f04a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af5d1f55afb146f06bdf2c12331f3a72a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af04527e74bf1d595e9e6b13dd9a40155',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ae95233fd172e4ee987b18a27be64b83f',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_5fof_34',['for_all_real_power_generator_snapshots_of',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a41c71bafd9d58ce41cea8cbe11966b1e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of(TNetwork &network, Types::generatorId generatorId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acc2630455cd1dc0a92d946e10992c967',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of(TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac0b82a01f9c23816914eb2b35d5b7164',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(Types::generatorId generatorId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a9eb6bebb9c37bebdc9e06ce59ce003fd',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(Types::vertexId generatorId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a1a4c2f3af0f9083785a9d37c8fdb0124',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac5e96be0b0cca689a0759298db7bf7e4',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function) const']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_35',['for_all_real_power_load_snapshots',['../classegoa_1_1_power_grid.html#adf8c406310a64a35ec11534aa4b2dbdf',1,'egoa::PowerGrid::for_all_real_power_load_snapshots(FUNCTION function)'],['../classegoa_1_1_power_grid.html#aca5b3d7ecc1170dc4954f6103876181a',1,'egoa::PowerGrid::for_all_real_power_load_snapshots(FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8ff69ad22302da58ea0037ed97e2a40b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots(TNetwork &network, FUNCTION function)']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_5fat_36',['for_all_real_power_load_snapshots_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8dde318094247fe00105bee852add84f',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aaab0f623992d7ebe3a30ca759331ca93',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a76f3ed337cc1a58280b6c4977316d337',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#abf8087cb2c8ffe8bf3e60cf4771714fe',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ad7a4ae966fd70ecea1ed3fdcf111f354',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a338c9d791f322b63852d8d068bb160a4',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a9bad768202ef78692f47db7aa4a3dbfd',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a8d57e38322b1d67f4e86fecb1e461f3d',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a24bfc25ba0ada6d902bc0fe82fc61f63',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a88654d841924f19935cb00f3171e9002',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#aae9c104f8927551b784d8c5f58cf604c',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a24989b7a0cf456433c1be71e6a2ab034',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_5fof_37',['for_all_real_power_load_snapshots_of',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a925b3a415d978991d3e3a5c2383ece8e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of()'],['../classegoa_1_1_power_grid.html#ac5e14cb65997d0fe8d03b0242eabfdae',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(TLoadProperties const &load, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a2e04758a4e885b83a985d4e94912e106',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(TLoadProperties load, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a49a07334084839f5547c5e5e7540cc4a',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(Types::vertexId loadId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a1c8cb331193179d09d00a84b1c9b78c9',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(Types::loadId loadId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a18b00092a9e1725935c37a0afac2333b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of()']]], + ['for_5fall_5funprocessed_5felements_38',['for_all_unprocessed_elements',['../classegoa_1_1_bucket.html#a4aaa4636ef84d2964c802d38cb8f80c7',1,'egoa::Bucket::for_all_unprocessed_elements(FUNCTION function)'],['../classegoa_1_1_bucket.html#a515c8674de429d0b41f9edbd7bab9c9e',1,'egoa::Bucket::for_all_unprocessed_elements(FUNCTION function) const'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a214cd2bc84034470e6be8e0878dfe337',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_unprocessed_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html#aa4ed3c4a7ebc3387e0430867ce2b0549',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_unprocessed_elements()']]], + ['for_5fall_5fvertex_5fidentifiers_39',['for_all_vertex_identifiers',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#acd8c48ee717298518da952720c5d166c',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers()'],['../classegoa_1_1_static_graph.html#a1e49bca339e5152a73b4b1c178c45ebc',1,'egoa::StaticGraph::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#aca586b487c249c599ba3d126278fe2cb',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#af747d46980fb143b1108ef9015c044fc',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers()'],['../classegoa_1_1_dynamic_graph.html#a0d5d739e8639809ad6e915bb5ff32ed5',1,'egoa::DynamicGraph::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#af5a62d471a7a0b4a0cb8e5cdff156ba5',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers()']]], + ['for_5fall_5fvertex_5fidentifiers_5fwith_5fgenerator_40',['for_all_vertex_identifiers_with_generator',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acf452b95df9c16ce9b23e043015bd5ca',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_generator()'],['../classegoa_1_1_power_grid.html#a0738102438224b118d98700501c89555',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_generator(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a4476ae9f47608980f79d879c5aede1e9',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_generator(FUNCTION function) const']]], + ['for_5fall_5fvertex_5fidentifiers_5fwith_5fload_41',['for_all_vertex_identifiers_with_load',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a766371ed685dc01541397c586dad2341',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_load()'],['../classegoa_1_1_power_grid.html#a5d34302d052c006b38a67541b9345784',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_load()']]], + ['for_5fall_5fvertex_5ftuples_42',['for_all_vertex_tuples',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a4a61f1bab1b240c7e5df03a75a11f8b0',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a02af5d227fcc9d4ccd703fdd71a48080',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a08041035e1cdad2b1ab6ccfb62bc2d5d',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a560b34aa94508c399d248456baed557e',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples()'],['../classegoa_1_1_static_graph.html#af471cc880484ccd9568cf8c05aa66c10',1,'egoa::StaticGraph::for_all_vertex_tuples()'],['../classegoa_1_1_dynamic_graph.html#a9b21fb8633493a721dd9fd7c86d67139',1,'egoa::DynamicGraph::for_all_vertex_tuples(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a488395c40b8b1037a48085733a7f7445',1,'egoa::DynamicGraph::for_all_vertex_tuples(FUNCTION function)'],['../classegoa_1_1_static_graph.html#a96ffb6ae4f80dd2d06dd9efa2c7e1bd9',1,'egoa::StaticGraph::for_all_vertex_tuples()']]], + ['for_5fall_5fvertices_43',['for_all_vertices',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a2762f1bd7bf7e8b35d0bdbebf969eec6',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertices()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ab28f7676dd95f39989f5cc6efcac0ade',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertices()'],['../classegoa_1_1_static_graph.html#a05b98249c10ffd77c433b669d0357a3c',1,'egoa::StaticGraph::for_all_vertices(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#ab845eb5468d07073919dc1b63a19ccbb',1,'egoa::StaticGraph::for_all_vertices(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac6f1c598ba729d55012ed1dbc50afb93',1,'egoa::DynamicGraph::for_all_vertices(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#af50c64e82afb018e47bb0d1c7424e21f',1,'egoa::DynamicGraph::for_all_vertices(FUNCTION function)']]], + ['for_5feach_44',['for_each',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html#ad396264ea48693d4782f0fd50c1cd606',1,'egoa::internal::ContainerLoop< ExecutionPolicy::sequential >::for_each()'],['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html#a403cf8ee405b7262d2c6d06858baaf85',1,'egoa::internal::ContainerLoop< ExecutionPolicy::breakable >::for_each()']]], + ['for_5fin_5fedges_5fat_45',['for_in_edges_at',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#aea0ed8ffc5ecbe95f56279a444594881',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at()'],['../classegoa_1_1_dynamic_graph.html#a6e2db098461cd06550600d10df87ffce',1,'egoa::DynamicGraph::for_in_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a8cfa293a4e265927f1f263bb5d49752b',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a5b5b5aa51474c8f4b2a71235f6ad41d0',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a73ad21c23671ce859213b9648ced95f3',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ab1eda96d08c89827e306717c41c0d36a',1,'egoa::StaticGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a736fe50fc467f6211e9c99d18a197734',1,'egoa::StaticGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#ae734137b1fe18cb9210d8869799ca53d',1,'egoa::StaticGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac1548686c754c60a007ffb515dbfddb7',1,'egoa::DynamicGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a18c7e8e30eb057eb03474d0c0c723a47',1,'egoa::DynamicGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac01328b45d8f4e1fc693029f0e36043d',1,'egoa::DynamicGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ad5de34af872cade4d1a646a2f4711fa6',1,'egoa::StaticGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function)']]], + ['for_5fout_5fedges_5fat_46',['for_out_edges_at',['../classegoa_1_1_static_graph.html#ae1a29dcc02b48dbad7659efba12e3dda',1,'egoa::StaticGraph::for_out_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a4fca2d6191e681c9f71c9ef014a02561',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a96b17ac2763c900cababbb319de9c008',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#acb4e60a503b9d3173949f150a83a9f12',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#abd4abaa576ca241ed3b933326dd46010',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ad4400b6856fcdd039b829d596793f7e2',1,'egoa::StaticGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#aabc529cea06fd71b62aa8ce8e3f9ea74',1,'egoa::StaticGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_static_graph.html#a1ecc1624cc249363a90f5d3eebd90840',1,'egoa::StaticGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#aeed3e030912f13345fcc1cdc96375801',1,'egoa::DynamicGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a751b57a8917a05543e7cd68919c66885',1,'egoa::DynamicGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ace01de5597a10359bb48dcbf3f1badd6',1,'egoa::DynamicGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#ab0582ac9a7fccc42e6d64dba7a4ecb44',1,'egoa::DynamicGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function)']]], + ['front_47',['front',['../classegoa_1_1_binary_heap.html#ae73b7103ada405e1a2b46f39c5abbaf3',1,'egoa::BinaryHeap::Front()'],['../classegoa_1_1_binary_heap.html#af7f0adca99fa2e17f7027534d07405b2',1,'egoa::BinaryHeap::Front() const']]], + ['functions_48',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/all_6.js b/search/all_6.js new file mode 100644 index 00000000..0fe943c9 --- /dev/null +++ b/search/all_6.js @@ -0,0 +1,40 @@ +var searchData= +[ + ['generationstrategydifferentiation_0',['GenerationStrategyDifferentiation',['../classegoa_1_1internal_1_1_generation_strategy_differentiation.html',1,'egoa::internal']]], + ['generationstrategydifferentiation_3c_20networktype_2c_20vertices_3a_3agenerationstrategydifferentiationtype_3a_3atotalvertexpowergenerationpersnapshot_20_3e_1',['GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >',['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html',1,'egoa::internal']]], + ['generatorat_2',['generatorat',['../classegoa_1_1_power_grid.html#a4497f89b77eaff6cc5d216ee560035b7',1,'egoa::PowerGrid::GeneratorAt(Types::generatorId generatorId) const'],['../classegoa_1_1_power_grid.html#a9ea9a0d8a6e911519f0461ee28d46740',1,'egoa::PowerGrid::GeneratorAt(Types::generatorId generatorId)']]], + ['generatorboundtype_3',['generatorboundtype',['../classegoa_1_1_power_grid.html#a742c296a3edc8c6823697b5cb3e8966c',1,'egoa::PowerGrid::GeneratorBoundType()'],['../classegoa_1_1_power_grid.html#ab1e0bf2a1218aa798e1af3666e06daed',1,'egoa::PowerGrid::GeneratorBoundType() const']]], + ['generatorboundtype_5f_4',['generatorBoundType_',['../classegoa_1_1_power_grid.html#af082bf55569c66afb625f4f13756e515',1,'egoa::PowerGrid']]], + ['generatorexists_5f_5',['generatorExists_',['../classegoa_1_1_power_grid.html#a0d3106c68fad6b5a1f34f17428cf79e0',1,'egoa::PowerGrid']]], + ['generatorid_6',['GeneratorId',['../classegoa_1_1_power_grid.html#ac053e77dc06debc43a279cd38eb64f49',1,'egoa::PowerGrid']]], + ['generatorids_7',['GeneratorIds',['../classegoa_1_1_power_grid.html#adc6d8fbda08381635645711cbd081a08',1,'egoa::PowerGrid']]], + ['generatorproperties_8',['GeneratorProperties',['../classegoa_1_1_vertices_1_1_generator_properties.html',1,'egoa::Vertices']]], + ['generatorreactivepowersnapshotat_9',['generatorreactivepowersnapshotat',['../classegoa_1_1_power_grid.html#aa30259f29d5476178945e79a8d9967a8',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#ad94e0678a5dfb01bca7277607c17cd3e',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a268d1bcac149f17459a3bad7713c3a5b',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) const'],['../classegoa_1_1_power_grid.html#adc0ef5b1cc08bf55a1398e769a6ed54f',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) const']]], + ['generatorrealpowersnapshotat_10',['generatorrealpowersnapshotat',['../classegoa_1_1_power_grid.html#adf10fef395323612441590e6346fa320',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a6f6666208b518a136fe36d861fbef14a',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a346bd4aeee1e26ff7db24ca426547972',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) const'],['../classegoa_1_1_power_grid.html#a3f43bcf6230ccbd0300dcc8d8efacd27',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) const']]], + ['generatorrealpowersnapshots_5f_11',['generatorRealPowerSnapshots_',['../classegoa_1_1_power_grid.html#a09359787c34e21976d49a465da8252e4',1,'egoa::PowerGrid']]], + ['generatorrealpowersnapshotsat_12',['GeneratorRealPowerSnapshotsAt',['../classegoa_1_1_power_grid.html#abe6926c64635811bcbe916ab934f4ee0',1,'egoa::PowerGrid']]], + ['generators_5f_13',['generators_',['../classegoa_1_1_power_grid.html#a70d9c93eef8839cdc65031608eed50f9',1,'egoa::PowerGrid']]], + ['generatorsat_14',['generatorsat',['../classegoa_1_1_power_grid.html#a58ec2214967be277601c7dfd3786457a',1,'egoa::PowerGrid::GeneratorsAt(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const'],['../classegoa_1_1_power_grid.html#a0ad4b5825688ca7f02754dd5fb6aa7ca',1,'egoa::PowerGrid::GeneratorsAt(Types::vertexId vertexId, std::vector< TGeneratorProperties > &generators) const'],['../classegoa_1_1_power_grid.html#ade6fa8057ba911e08a26c121814ec93c',1,'egoa::PowerGrid::GeneratorsAt(TVertex const &vertex, std::vector< Types::generatorId > &generatorIds) const'],['../classegoa_1_1_power_grid.html#a7855270806af2620e13bf41338928e6c',1,'egoa::PowerGrid::GeneratorsAt(TVertex const &vertex, std::vector< TGeneratorProperties > &generators) const']]], + ['generatorsatvertex_5f_15',['generatorsAtVertex_',['../classegoa_1_1_power_grid.html#a6595f65a0b36d631bfedb8feaf766f76',1,'egoa::PowerGrid']]], + ['generatortype_16',['generatortype',['../classegoa_1_1_vertices_1_1_generator_properties.html#a1f709c2e8c7baf71f2784fdd6eebd5d5',1,'egoa::Vertices::GeneratorProperties::GeneratorType()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8b4a0cbc8f0baa96f078174edfd034e2',1,'egoa::Vertices::GeneratorProperties::GeneratorType() const']]], + ['generatortype_5f_17',['generatorType_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8ee4b60b26874b05884ff981df6cd385',1,'egoa::Vertices::GeneratorProperties']]], + ['geojsonwriter_18',['geojsonwriter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ace0bbb8ba7ac1833797a20b36d4109ac',1,'egoa::IO::GeoJsonWriter::GeoJsonWriter()'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html',1,'egoa::IO::GeoJsonWriter< GraphType >']]], + ['globalelapsedmilliseconds_19',['GlobalElapsedMilliseconds',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a96e1d32516abaf87561ae7a4c4f0ca03',1,'egoa::IO::DtpRuntimeRow']]], + ['goldenrod_20',['Goldenrod',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acf193ee60d2856bcefc85bdbc245ff66',1,'egoa::Color']]], + ['gotonextexistingelement_21',['GoToNextExistingElement',['../classegoa_1_1_omitting_iterator.html#ad101979a7c770516904e43845dc04880',1,'egoa::OmittingIterator']]], + ['gotopreviousexistingelement_22',['GoToPreviousExistingElement',['../classegoa_1_1_omitting_iterator.html#a178fbfd2cbaf850bee479578669f710e',1,'egoa::OmittingIterator']]], + ['graph_23',['graph',['../classegoa_1_1_block_cut_tree.html#a5d9382170f6ab487f40562acd72374cd',1,'egoa::BlockCutTree::Graph()'],['../classegoa_1_1_power_grid.html#a6e7271075a42a9b059814f94b3ae11d2',1,'egoa::PowerGrid::Graph() const'],['../classegoa_1_1_power_grid.html#a8e4e25ad797d1ea4df976068a8f38ddd',1,'egoa::PowerGrid::Graph()']]], + ['graph_5f_24',['graph_',['../classegoa_1_1_betweenness_centrality.html#a154a01fe2a7b7bf98faa661957de4e83',1,'egoa::BetweennessCentrality::graph_'],['../classegoa_1_1_traversal.html#aad8c34131f8cbf5298ba3e4d8385f9b1',1,'egoa::Traversal::graph_'],['../classegoa_1_1_dominating_theta_path.html#a6b99d54933d2c81ae4870e47435e7e89',1,'egoa::DominatingThetaPath::graph_'],['../classegoa_1_1_m_s_t.html#aa78554042b5ed4825bd9d5d17dba04cf',1,'egoa::MST::graph_'],['../classegoa_1_1_block_cut_tree.html#aae1348eec4ae4cab889fcfed806677fe',1,'egoa::BlockCutTree::graph_'],['../classegoa_1_1_power_grid.html#a709ed5172e84b67073e0d27c173b463f',1,'egoa::PowerGrid::graph_']]], + ['graphloopdifferentiation_25',['GraphLoopDifferentiation',['../classegoa_1_1internal_1_1_graph_loop_differentiation.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3abreakable_20_3e_26',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_27',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_28',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_29',['GraphTypeLoopDifferentiation',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_3c_20graphtype_2c_20false_20_3e_30',['GraphTypeLoopDifferentiation< GraphType, false >',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_3c_20graphtype_2c_20true_20_3e_31',['GraphTypeLoopDifferentiation< GraphType, true >',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4.html',1,'egoa::internal']]], + ['gray_32',['Gray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a994ae1d9731cebe455aff211bcb25b93',1,'egoa::Color']]], + ['green_33',['Green',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad382816a3cbeed082c9e216e7392eed1',1,'egoa::Color']]], + ['greenyellow_34',['Greenyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aaa7193f0b831d1a5246e2cd87a07302c',1,'egoa::Color']]], + ['grey_35',['Grey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acaf3a042a037c064b7513ed640c22f77',1,'egoa::Color']]], + ['gurobisolver_36',['GurobiSolver',['../classegoa_1_1_gurobi_solver.html',1,'egoa']]] +]; diff --git a/search/all_7.js b/search/all_7.js new file mode 100644 index 00000000..543c339b --- /dev/null +++ b/search/all_7.js @@ -0,0 +1,16 @@ +var searchData= +[ + ['hascorrectsnapshotsizes_0',['HasCorrectSnapshotSizes',['../classegoa_1_1_py_psa_parser.html#a21231a5c4387284f7c2eb499b7ed19c4',1,'egoa::PyPsaParser']]], + ['haselement_1',['HasElement',['../classegoa_1_1_bucket.html#a02384b2094ae4b7d98b6ef5ed13f79bd',1,'egoa::Bucket']]], + ['haselementat_2',['HasElementAt',['../classegoa_1_1_bucket.html#ac68424a9e54d824e1cecb2d3569df16e',1,'egoa::Bucket']]], + ['hasgenerator_3',['hasgenerator',['../classegoa_1_1_power_grid.html#aa5ded3e2eac92539ba34e5f5ad0ce3d3',1,'egoa::PowerGrid::HasGenerator(Types::generatorId generatorId) const'],['../classegoa_1_1_power_grid.html#afb53002e834398e310716788d99d539b',1,'egoa::PowerGrid::HasGenerator(TGeneratorProperties const &generatorProperty) const']]], + ['hasgeneratorat_4',['hasgeneratorat',['../classegoa_1_1_power_grid.html#adbc86848f2a4bb027f2fb80ad5a143d2',1,'egoa::PowerGrid::HasGeneratorAt(Types::vertexId vertexId) const'],['../classegoa_1_1_power_grid.html#afc916a590e65d8db4b4f50914d4a919b',1,'egoa::PowerGrid::HasGeneratorAt(TVertex const &vertex) const']]], + ['haskeyof_5',['HasKeyOf',['../classegoa_1_1_mapping_binary_heap.html#a135da274c0727028ac71a1a77ab7a0ad',1,'egoa::MappingBinaryHeap']]], + ['hasload_6',['hasload',['../classegoa_1_1_power_grid.html#aa742c4990f7183a2bb73f522f45931ca',1,'egoa::PowerGrid::HasLoad(TLoadProperties const &load) const'],['../classegoa_1_1_power_grid.html#a59dd76eb1f73fc86b0ca995c9f3b61eb',1,'egoa::PowerGrid::HasLoad(Types::loadId loadId) const']]], + ['hasloadat_7',['hasloadat',['../classegoa_1_1_power_grid.html#a50de730d9790cf379e5c70d1ed9ae25e',1,'egoa::PowerGrid::HasLoadAt(Types::vertexId vertexId) const'],['../classegoa_1_1_power_grid.html#aebcdd827b1aeee0b3359e473a5752c0c',1,'egoa::PowerGrid::HasLoadAt(TVertex const &vertex) const']]], + ['header_8',['header',['../classegoa_1_1_edges_1_1_electrical_properties.html#a8bf9e9177d3834c6155ad025c1f60a84',1,'egoa::Edges::ElectricalProperties::Header()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a23818e78fedeff768386d484bdbd8614',1,'egoa::Vertices::ElectricalProperties::Header()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a4022450ef27de5aeaaff83509da9f924',1,'egoa::Vertices::GeneratorProperties::Header()']]], + ['headerlong_9',['headerlong',['../classegoa_1_1_edges_1_1_electrical_properties.html#a61088ee88b22229f1a81af9935dea372',1,'egoa::Edges::ElectricalProperties::HeaderLong()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a09f85ee06469825faa1fb17f5462dabb',1,'egoa::Vertices::ElectricalProperties::HeaderLong()']]], + ['heapiterator_10',['HeapIterator',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html',1,'egoa::BinaryHeap']]], + ['honeydew_11',['Honeydew',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4702a340a91866eea3143f6c1c735ef4',1,'egoa::Color']]], + ['hotpink_12',['Hotpink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93cc23e594200f6388cdf73208bc5c1c',1,'egoa::Color']]] +]; diff --git a/search/all_8.js b/search/all_8.js new file mode 100644 index 00000000..5513c75a --- /dev/null +++ b/search/all_8.js @@ -0,0 +1,36 @@ +var searchData= +[ + ['identifier_0',['identifier',['../classegoa_1_1_block_cut_tree_1_1_block.html#a997edf90f2c4d171e1f7ad51b08ccced',1,'egoa::BlockCutTree::Block::Identifier()'],['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html#a4e7a0eb2be97c669e3d186324736b085',1,'egoa::BlockCutTree::CutVertex::Identifier()']]], + ['identifier_5f_1',['identifier_',['../classegoa_1_1_edges_1_1_edge.html#a2426e13688cb20d7fd4af00d004fd765',1,'egoa::Edges::Edge::identifier_'],['../classegoa_1_1_vertices_1_1_vertex.html#ad99f3c267ee48d40c905d6e3c272bfb2',1,'egoa::Vertices::Vertex::identifier_']]], + ['ieeecdfmatlabparser_2',['IeeeCdfMatlabParser',['../classegoa_1_1_ieee_cdf_matlab_parser.html',1,'egoa']]], + ['indegreeat_3',['indegreeat',['../classegoa_1_1_static_graph.html#a0411acd5fae68c32b1602b5ef0134741',1,'egoa::StaticGraph::InDegreeAt()'],['../classegoa_1_1_dynamic_graph.html#ab9747c844b0ec7e215bf65f791267134',1,'egoa::DynamicGraph::InDegreeAt()']]], + ['indent_4',['Indent',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a3ab89cd4ca93cde5412b6ad46724e83e',1,'egoa::IO::GeoJsonWriter']]], + ['indentchar_5f_5',['indentChar_',['../classegoa_1_1_power_grid_i_o.html#a3d9cbb8518b54cec9b1726ff00c8663b',1,'egoa::PowerGridIO']]], + ['indentwidth_5f_6',['indentWidth_',['../classegoa_1_1_power_grid_i_o.html#a852d7bd70c722051c6c9ca1e39776600',1,'egoa::PowerGridIO']]], + ['index_7',['index',['../classegoa_1_1_bucket_element.html#a71cd13dc3146fa8d0bc40e7145432350',1,'egoa::BucketElement::Index() const'],['../classegoa_1_1_bucket_element.html#aaf7fd7a4537ecaad1535033fd10220ef',1,'egoa::BucketElement::Index()'],['../classegoa_1_1_label.html#a9c22b92c0727ecceb9a91affbb76c070',1,'egoa::Label::Index() const'],['../classegoa_1_1_label.html#add6bbd836744f84fd17c68f7262dd164',1,'egoa::Label::Index()']]], + ['index_5f_8',['index_',['../classegoa_1_1_bucket_element.html#a20b4ca168c3f1d136f7b98573015833e',1,'egoa::BucketElement::index_'],['../classegoa_1_1_label.html#a5f7fa8334eb9e5a2bf2dc26d802d6552',1,'egoa::Label::index_']]], + ['indianred_9',['Indianred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6f2351a92fe2e42de9bdb2b1e6756d78',1,'egoa::Color']]], + ['indigo_10',['Indigo',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8b7b9806e715b01b9021912e0f86935f',1,'egoa::Color']]], + ['inedgeids_5f_11',['inedgeids_',['../classegoa_1_1_dynamic_graph.html#a6aa2dc0d3e779b07d7a5c9e50c23c6ec',1,'egoa::DynamicGraph::inEdgeIds_'],['../classegoa_1_1_static_graph.html#a2b7e45bff5759f273dfb247857163c0c',1,'egoa::StaticGraph::inEdgeIds_']]], + ['inedgeidsat_12',['inedgeidsat',['../classegoa_1_1_dynamic_graph.html#a6f3449ab60c4e5a419d5e38d3c6190d2',1,'egoa::DynamicGraph::InEdgeIdsAt()'],['../classegoa_1_1_static_graph.html#a33d8ff7630386cb00542d1449db60d7e',1,'egoa::StaticGraph::InEdgeIdsAt()']]], + ['insamecomponent_13',['InSameComponent',['../classegoa_1_1_union_find.html#ace93766c66447d2a6c2274fa8da6b227',1,'egoa::UnionFind']]], + ['insert_14',['insert',['../classegoa_1_1_mapping_binary_heap.html#afa7345a90c42597384e114f5383a3f6c',1,'egoa::MappingBinaryHeap::Insert(std::pair< TElement, TKey > pair)'],['../classegoa_1_1_mapping_binary_heap.html#ad9a8f442a5db89f3c086568624b4e8c3',1,'egoa::MappingBinaryHeap::Insert(TElement element, TKey key)'],['../classegoa_1_1_bucket.html#a6b591948f5834e45c5dabb00562c2d55',1,'egoa::Bucket::Insert()'],['../classegoa_1_1_binary_heap.html#aca3181a858ac6857a8b229ef697aad48',1,'egoa::BinaryHeap::Insert(InputIt first, InputIt last)'],['../classegoa_1_1_binary_heap.html#af4097764c5c57636f53791b9cf39395a',1,'egoa::BinaryHeap::Insert(TElement &&element)'],['../classegoa_1_1_binary_heap.html#a121a075cafffcd696057c1f6e0020008',1,'egoa::BinaryHeap::Insert(TElement const &element)'],['../classegoa_1_1_dominating_theta_path.html#ae222b087385df5fdf98a77dda157c946',1,'egoa::DominatingThetaPath::Insert()'],['../classegoa_1_1_binary_heap.html#a8acf54b49a04ab347dced13c78c12615',1,'egoa::BinaryHeap::Insert()']]], + ['isactive_15',['isactive',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a51cda5e17e4489f07b4022ae257f0ab2',1,'egoa::Vertices::ElectricalProperties::IsActive()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ab0eb427e28dc3c5c04a3235caef8717a',1,'egoa::Vertices::GeneratorProperties::IsActive()']]], + ['isarticulationvertex_5f_16',['isArticulationVertex_',['../classegoa_1_1_articulation_vertex_detection.html#a9dd0caf4bf4ca63680b764ea9243c249',1,'egoa::ArticulationVertexDetection']]], + ['isarticulationvertexat_17',['IsArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a49d34db914899881114731ee0a37d0ae',1,'egoa::ArticulationVertexDetection']]], + ['isbounded_18',['IsBounded',['../classegoa_1_1_power_grid.html#adc565569a76f8fdc9fe8d927c737de3e',1,'egoa::PowerGrid']]], + ['isbridge_19',['IsBridge',['../classegoa_1_1_block_cut_tree_1_1_block.html#af31ff57edfbc5ba6f26c06c79ee8898f',1,'egoa::BlockCutTree::Block']]], + ['isbridgearticulationvertexat_20',['IsBridgeArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a0c0a4d84b9a01876df0468b7c338db46',1,'egoa::ArticulationVertexDetection']]], + ['iscutvertex_21',['IsCutVertex',['../classegoa_1_1_block_cut_tree.html#a0f7d7567e672e533976b3c893e32db80',1,'egoa::BlockCutTree']]], + ['isequalto_22',['isequalto',['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html#afc844e115b9b61f5ad080cb9364affdc',1,'egoa::internal::BinaryHeapCheck< Type, true >::IsEqualTo()'],['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html#ad5b69c92ad7d82fe71d823d61ea1d183',1,'egoa::internal::BinaryHeapCheck< Type, false >::IsEqualTo()'],['../classegoa_1_1_binary_heap.html#a4324db70754d810d32c620b6f715012c',1,'egoa::BinaryHeap::IsEqualTo()']]], + ['isexact_23',['IsExact',['../classegoa_1_1_power_grid.html#aca8655a512c4adbc4ecd3ddd445a8e31',1,'egoa::PowerGrid']]], + ['isextendable_24',['isextendable',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5f7942765ac3788c00eeb647e699992d',1,'egoa::Vertices::GeneratorProperties::IsExtendable() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a84634dd5a9245eac61e0cb3aaae83f6b',1,'egoa::Vertices::GeneratorProperties::IsExtendable()']]], + ['isleaf_25',['IsLeaf',['../classegoa_1_1_block_cut_tree_1_1_block.html#ae426f7b266f6363ed61a0ae73e3bfb80',1,'egoa::BlockCutTree::Block']]], + ['isparentarticulationvertexat_26',['IsParentArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#abfca902ba3d3d9c3443af45272bfe920',1,'egoa::ArticulationVertexDetection']]], + ['ispureunbounded_27',['IsPureUnbounded',['../classegoa_1_1_power_grid.html#a502ed64c2c10baa47c66231391ad4d3a',1,'egoa::PowerGrid']]], + ['isroot_28',['IsRoot',['../classegoa_1_1_articulation_vertex_detection.html#a0eb4836a75b02a4a22809aa170ff85df',1,'egoa::ArticulationVertexDetection']]], + ['isrootarticulationvertexat_29',['IsRootArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a54843a91ae68787e5b9bc8d0e461b146',1,'egoa::ArticulationVertexDetection']]], + ['isunbounded_30',['IsUnbounded',['../classegoa_1_1_power_grid.html#a88b549f743a751b00b55c830579ab8d2',1,'egoa::PowerGrid']]], + ['iterator_5fcategory_31',['iterator_category',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#a9465138d191615d8c0ae66602e5abaf6',1,'egoa::BinaryHeap::HeapIterator']]], + ['ivory_32',['Ivory',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5aea7cdf0f3349ac62a04335ec1c918d',1,'egoa::Color']]] +]; diff --git a/search/all_9.js b/search/all_9.js new file mode 100644 index 00000000..748da50e --- /dev/null +++ b/search/all_9.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['jointhreadbasedresults_0',['JoinThreadBasedResults',['../classegoa_1_1_betweenness_centrality.html#a4cb3aa831da54fd5e362aaf146e9b816',1,'egoa::BetweennessCentrality']]] +]; diff --git a/search/all_a.js b/search/all_a.js new file mode 100644 index 00000000..7322dd66 --- /dev/null +++ b/search/all_a.js @@ -0,0 +1,91 @@ +var searchData= +[ + ['keyof_0',['KeyOf',['../classegoa_1_1_mapping_binary_heap.html#adb68497a6c9dce260fe1719023337726',1,'egoa::MappingBinaryHeap']]], + ['khaki_1',['Khaki',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7ec23b405c5319f55b7660569c077f41',1,'egoa::Color']]], + ['kitblack_2',['KITblack',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad04b42146d64f8f9bee8fe38567da67d',1,'egoa::Color']]], + ['kitblack01_3',['KITblack01',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af985f7b747fb5936da8e34e605f643a4',1,'egoa::Color']]], + ['kitblack02_4',['KITblack02',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93867309e7749d4825e54d9a0852806f',1,'egoa::Color']]], + ['kitblack03_5',['KITblack03',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac1a2ba5b298bfd21ec69f68af374e925',1,'egoa::Color']]], + ['kitblack04_6',['KITblack04',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a78c99dcdb6a72f9b8d86c38577171371',1,'egoa::Color']]], + ['kitblack05_7',['KITblack05',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a136ae6b2863f310cc7c1cfc9bd0d9c86',1,'egoa::Color']]], + ['kitblack06_8',['KITblack06',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae8a714111b23985d37fbee2784ac62d8',1,'egoa::Color']]], + ['kitblack07_9',['KITblack07',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a49031707a6690face30ae1f2c062bc66',1,'egoa::Color']]], + ['kitblack08_10',['KITblack08',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5fd5854de12c6b9853df10fbcc840958',1,'egoa::Color']]], + ['kitblack09_11',['KITblack09',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a04f67e44fd17062295b40a9ea0ba76a2',1,'egoa::Color']]], + ['kitblack10_12',['KITblack10',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1aa7fdbe1029a4eb0667ca036139746c',1,'egoa::Color']]], + ['kitblack11_13',['KITblack11',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac61ab4a1c093e4c854473f3aab38e507',1,'egoa::Color']]], + ['kitblack12_14',['KITblack12',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab60514a42a41f81fdbe788f281cf4c27',1,'egoa::Color']]], + ['kitblack13_15',['KITblack13',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aafbfd093bd346084a084d0165e95382b',1,'egoa::Color']]], + ['kitblack14_16',['KITblack14',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a30613fdb8310681ac8c2acd51a14b44d',1,'egoa::Color']]], + ['kitblack15_17',['KITblack15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acb3b1b190885775dc3c92dfc142bb0ab',1,'egoa::Color']]], + ['kitblack16_18',['KITblack16',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a28db8035bc28c8f918d676144988305e',1,'egoa::Color']]], + ['kitblack17_19',['KITblack17',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeecf337d540ebbd78c219ffbe43fb807',1,'egoa::Color']]], + ['kitblack18_20',['KITblack18',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac54b0f3a9fab3d025d51e7baa5d89b43',1,'egoa::Color']]], + ['kitblack19_21',['KITblack19',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3d596a45c78f186cc0c2ed9fc36704fa',1,'egoa::Color']]], + ['kitblack20_22',['KITblack20',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6f7eb731aab9631f6a6dabf902336437',1,'egoa::Color']]], + ['kitblack21_23',['KITblack21',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad28fe8d7aea9e7b232b61c69f9911b85',1,'egoa::Color']]], + ['kitblack22_24',['KITblack22',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4245a285af0ebe48d4e80740dccce3e4',1,'egoa::Color']]], + ['kitblack23_25',['KITblack23',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a87719299eb02858ad2b80a9284eb4fac',1,'egoa::Color']]], + ['kitblack24_26',['KITblack24',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0a769699e389c260d5d7766c656bdaa5',1,'egoa::Color']]], + ['kitblack25_27',['KITblack25',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1ad5d41d82af1def77b10fd92eece25f',1,'egoa::Color']]], + ['kitblack26_28',['KITblack26',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab817b6c508fcc330adde327419837bb5',1,'egoa::Color']]], + ['kitblack27_29',['KITblack27',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a67b786a7b286409cdbc68a56869bb63a',1,'egoa::Color']]], + ['kitblack28_30',['KITblack28',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae1dba20dc03c75b333500c3b1dedd198',1,'egoa::Color']]], + ['kitblack29_31',['KITblack29',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a11503e43ff3fa847db22c073f9dbc54e',1,'egoa::Color']]], + ['kitblack30_32',['KITblack30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac1c253f4da13687459426ce7f4599ffb',1,'egoa::Color']]], + ['kitblack31_33',['KITblack31',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aff4f6637d4fc4498b39e86c77edee401',1,'egoa::Color']]], + ['kitblack32_34',['KITblack32',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a73ee9cebbd782850a6acde95e0743ece',1,'egoa::Color']]], + ['kitblack50_35',['KITblack50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a777b1ebb50d01395ad15a7a2a9ca5586',1,'egoa::Color']]], + ['kitblack70_36',['KITblack70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a432452009a0fcd6f552861d8ea91f806',1,'egoa::Color']]], + ['kitblue_37',['KITblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a39f7cc9510d0e1be760ef5988a231aa1',1,'egoa::Color']]], + ['kitblue15_38',['KITblue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a63a7589152e02f4e3979ab9cfe97cb69',1,'egoa::Color']]], + ['kitblue30_39',['KITblue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aff4c82c0db801dfa22730e480cd4db1a',1,'egoa::Color']]], + ['kitblue50_40',['KITblue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93485c08064a61c413be46d9323a4053',1,'egoa::Color']]], + ['kitblue70_41',['KITblue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a63ba97f52bb8817c7273f8581aa48ff8',1,'egoa::Color']]], + ['kitbrown_42',['KITbrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0323d4e649ec14a16e8759b5342e95c1',1,'egoa::Color']]], + ['kitbrown15_43',['KITbrown15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba1633bdd789db72558bed1eaeeb8a5c',1,'egoa::Color']]], + ['kitbrown30_44',['KITbrown30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6d16c19e273ba22bbec544602a8914d3',1,'egoa::Color']]], + ['kitbrown50_45',['KITbrown50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5b20653d34b2b29659d482f087b6242f',1,'egoa::Color']]], + ['kitbrown70_46',['KITbrown70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a27063de98f067ec5b8ab82a427be4253',1,'egoa::Color']]], + ['kitcyanblue_47',['KITcyanblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad002abd1fce7b721637e3043b5b5f8b0',1,'egoa::Color']]], + ['kitcyanblue15_48',['KITcyanblue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7f3476c90c9453f60bc1c24722174961',1,'egoa::Color']]], + ['kitcyanblue30_49',['KITcyanblue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8610b95d45ed022728870d7db8abf2ee',1,'egoa::Color']]], + ['kitcyanblue50_50',['KITcyanblue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a36c31c707e7184576fc8a23662bf17fb',1,'egoa::Color']]], + ['kitcyanblue70_51',['KITcyanblue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7f0a1b587eec0d4e5576e790ee655ca9',1,'egoa::Color']]], + ['kitgreen_52',['KITgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a971d2cefb5f4717e7ec36dc008c01400',1,'egoa::Color']]], + ['kitgreen15_53',['KITgreen15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2f5ec06e71ce648205da1990e2ef81ec',1,'egoa::Color']]], + ['kitgreen30_54',['KITgreen30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aadca5eecaad051ef4e89f95381323572',1,'egoa::Color']]], + ['kitgreen50_55',['KITgreen50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adbfaa143f52f20258b02d65bf8415d19',1,'egoa::Color']]], + ['kitgreen70_56',['KITgreen70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab537e8c7d24e1a39302f596df9fb7ca9',1,'egoa::Color']]], + ['kitlilac_57',['KITlilac',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8fbc3ee3f98bc568c916db2e826f2ed9',1,'egoa::Color']]], + ['kitlilac15_58',['KITlilac15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a40027b7487b1291459494fc82a2fdae8',1,'egoa::Color']]], + ['kitlilac30_59',['KITlilac30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af8ea2ce999a0bfa0dccefe48f589972e',1,'egoa::Color']]], + ['kitlilac50_60',['KITlilac50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a80ad706c0a273ea98b56fe0d4c78ff5f',1,'egoa::Color']]], + ['kitlilac70_61',['KITlilac70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8660b35b948522dca4b311948d59bf7f',1,'egoa::Color']]], + ['kitorange_62',['KITorange',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac3685734294a38e23826a95a6ea6d03a',1,'egoa::Color']]], + ['kitorange15_63',['KITorange15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2eb0eb1e621e02b2cbd8faac80f4b552',1,'egoa::Color']]], + ['kitorange30_64',['KITorange30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae46961ef3db5d59c0aaa82d09131c356',1,'egoa::Color']]], + ['kitorange50_65',['KITorange50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac401f81efc16f69158fa49f288f2154e',1,'egoa::Color']]], + ['kitorange70_66',['KITorange70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d038565ca5e9bfacada419aa4e66218',1,'egoa::Color']]], + ['kitpalegreen_67',['KITpalegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8ea75cbe6ed3255db1a14b984b3f6035',1,'egoa::Color']]], + ['kitpalegreen15_68',['KITpalegreen15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adf3e0a36228370fd5c5bf5cc6bd75c48',1,'egoa::Color']]], + ['kitpalegreen30_69',['KITpalegreen30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09afae9ad56751f3c4ea20a2c79086610c2',1,'egoa::Color']]], + ['kitpalegreen50_70',['KITpalegreen50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2fd5f0aa1e5c14ee64948c9e4602a28b',1,'egoa::Color']]], + ['kitpalegreen70_71',['KITpalegreen70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad8023cfc76f017e60a9362f759b73b1e',1,'egoa::Color']]], + ['kitred_72',['KITred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acbdf6daeecce29e65cb750b24c9618c7',1,'egoa::Color']]], + ['kitred15_73',['KITred15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a34864ec6752719138e7df5a5e4915d6a',1,'egoa::Color']]], + ['kitred30_74',['KITred30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4ad7f140fee3fdac9fddb09a0f7bcb72',1,'egoa::Color']]], + ['kitred50_75',['KITred50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09abea49d949ed01e2212f06f68780629f8',1,'egoa::Color']]], + ['kitred70_76',['KITred70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5774875a0619e6d0047ce8204743cc58',1,'egoa::Color']]], + ['kitseablue_77',['KITseablue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2f8ad8ee518b58c8e17fc15cd0679a7d',1,'egoa::Color']]], + ['kitseablue15_78',['KITseablue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a938f1c09b5a3bfbdb737a103a9c6c9f7',1,'egoa::Color']]], + ['kitseablue30_79',['KITseablue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a56501b05496e60dd3cb2278de641693a',1,'egoa::Color']]], + ['kitseablue50_80',['KITseablue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad6994772bddd017701a302b6ce973e65',1,'egoa::Color']]], + ['kitseablue70_81',['KITseablue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d76fe3f4f70294348ad6018396e5f9f',1,'egoa::Color']]], + ['kityellow_82',['KITyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5d0ecdc2ed050d8ff49ab80743c36ec1',1,'egoa::Color']]], + ['kityellow15_83',['KITyellow15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d0a9e15b8251a5c5e43cf668205d9c9',1,'egoa::Color']]], + ['kityellow30_84',['KITyellow30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1548dbd2985e6369bdcc182a319570be',1,'egoa::Color']]], + ['kityellow50_85',['KITyellow50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4f1518f3d4fe71977697859d837b18ba',1,'egoa::Color']]], + ['kityellow70_86',['KITyellow70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa954f43ae60e07c61ba62c6a51b490a1',1,'egoa::Color']]], + ['kruskal_87',['Kruskal',['../classegoa_1_1_kruskal.html',1,'egoa']]] +]; diff --git a/search/all_b.js b/search/all_b.js new file mode 100644 index 00000000..d1e77db0 --- /dev/null +++ b/search/all_b.js @@ -0,0 +1,47 @@ +var searchData= +[ + ['label_0',['label',['../classegoa_1_1_label.html',1,'egoa::Label< ElementType, VertexSetContainer, PointerType >'],['../classegoa_1_1_label.html#a899f2c401759a354942c7af96ad54fa7',1,'egoa::Label::Label(Types::vertexId vertexId)'],['../classegoa_1_1_label.html#a3e821b3e453e91072b75c38489a3920d',1,'egoa::Label::Label(Label const &label)=default']]], + ['label_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_2c_20std_3a_3aunordered_5fset_3c_20types_3a_3avertexid_20_3e_2c_20types_3a_3avertexid_20_3e_1',['Label< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId >',['../classegoa_1_1_label.html',1,'egoa']]], + ['labelat_2',['LabelAt',['../classegoa_1_1_dominating_theta_path.html#a4f89c1d235bd7cfedd3673033cfac45c',1,'egoa::DominatingThetaPath']]], + ['labelsetat_3',['labelsetat',['../classegoa_1_1_dominating_theta_path.html#a3f7e76e52337fda7bae785ec4ac9a273',1,'egoa::DominatingThetaPath::LabelSetAt(TVertexId const vertexId) const'],['../classegoa_1_1_dominating_theta_path.html#aec826894182146841bbd1ce14bd482b3',1,'egoa::DominatingThetaPath::LabelSetAt(TVertexId const vertexId)']]], + ['labelsetemptyat_4',['labelsetemptyat',['../classegoa_1_1_dominating_theta_path.html#a3f457944c7e6ad5c8353ae06c6d5aed2',1,'egoa::DominatingThetaPath::LabelSetEmptyAt(TVertexId const vertexId) const'],['../classegoa_1_1_dominating_theta_path.html#a77831c762b0e2224f44789eb1cd6290e',1,'egoa::DominatingThetaPath::LabelSetEmptyAt(TLabel const &label) const']]], + ['labelsets_5f_5',['labelSets_',['../classegoa_1_1_dominating_theta_path.html#a7b0b9180e0816e2843e783263f831d1f',1,'egoa::DominatingThetaPath']]], + ['lavender_6',['Lavender',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae346c232ce72c429ea0995de9f63f551',1,'egoa::Color']]], + ['lavenderblush_7',['Lavenderblush',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2608628d9926a877f5557354f4c16e9f',1,'egoa::Color']]], + ['lawngreen_8',['Lawngreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3d6c544640f5a8a459cdc6f10f90dabb',1,'egoa::Color']]], + ['lemonchiffon_9',['Lemonchiffon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5c651ed90facf4bb7ddc64a4e466cad7',1,'egoa::Color']]], + ['length_5f_10',['length_',['../classegoa_1_1_edges_1_1_electrical_properties.html#aa342ebdb0af0294ac8a8e1247ad9ef11',1,'egoa::Edges::ElectricalProperties']]], + ['lightblue_11',['Lightblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeee4484ffe23236009ba4b3fc5b3b260',1,'egoa::Color']]], + ['lightcoral_12',['Lightcoral',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae854b167e568a8a8b0702ba72243efd6',1,'egoa::Color']]], + ['lightcyan_13',['Lightcyan',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5bb982b0c73416b14789c4ec00bcf201',1,'egoa::Color']]], + ['lightgoldenrodyellow_14',['Lightgoldenrodyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad7e2c8f55498c8bb1afc0919b4538d43',1,'egoa::Color']]], + ['lightgray_15',['Lightgray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af732b1b8bbfac23a09f44ac8760d155b',1,'egoa::Color']]], + ['lightgreen_16',['Lightgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4f5de044d10c971c68f5a6ca9e003944',1,'egoa::Color']]], + ['lightgrey_17',['Lightgrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba443ab182c66fef799b62d244028dde',1,'egoa::Color']]], + ['lightpink_18',['Lightpink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba5b3bbbccecc93032475b74a422c5ef',1,'egoa::Color']]], + ['lightsalmon_19',['Lightsalmon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5957441ec1336b5798202d47c4b1edc1',1,'egoa::Color']]], + ['lightseagreen_20',['Lightseagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a838adfb6f15a1d6e6e34d8bdf4780f23',1,'egoa::Color']]], + ['lightskyblue_21',['Lightskyblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adfae21840c461b684ef9033f7fee8cb0',1,'egoa::Color']]], + ['lightslategray_22',['Lightslategray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d43c707907df664518e6891bb5d7458',1,'egoa::Color']]], + ['lightslategrey_23',['Lightslategrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a91cc4dd99e26947eee42dd8f0cd18a1f',1,'egoa::Color']]], + ['lightsteelblue_24',['Lightsteelblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1d624025be2093c781e92d19cadfa0c4',1,'egoa::Color']]], + ['lightyellow_25',['Lightyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acb3655bfd6e7b23c65240a365d2e5f74',1,'egoa::Color']]], + ['lime_26',['Lime',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09afc1cebf02dc2ee68655f3e7bf1b84230',1,'egoa::Color']]], + ['limegreen_27',['Limegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a034debfe19e91356b49ed1180537d9ce',1,'egoa::Color']]], + ['line_28',['line',['../classegoa_1_1_edges_1_1_electrical_properties.html#ae0a38017dcfb972afaa8e6eb54427b7d',1,'egoa::Edges::ElectricalProperties::Line()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#aafc3b94378befb4fcef11f4c4462d76f',1,'egoa::Vertices::ElectricalProperties::Line(std::ostream &outputStream, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#ad1cf863d58d7d2e2aa90fa957940726a',1,'egoa::Vertices::ElectricalProperties::Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac9306f3c683fd6a97473d040f54c010d',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a552e1c524803efcc1074cf49b2c4f59d',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aa1fdfc955238dd72d69804f756b5f4ef',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::name busName, Types::real baseMva=1) const']]], + ['linen_29',['Linen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5ab518fc894c7438e44d9a035c2e970e',1,'egoa::Color']]], + ['list_30',['Todo List',['../todo.html',1,'']]], + ['loadat_31',['loadat',['../classegoa_1_1_power_grid.html#ae7d8eac0e03b1c59832730ffc5e3c322',1,'egoa::PowerGrid::LoadAt(Types::loadId loadId) const'],['../classegoa_1_1_power_grid.html#aef83b9d86c21284bda8fb05c0a05a1ae',1,'egoa::PowerGrid::LoadAt(Types::loadId loadId)']]], + ['loadboundtype_32',['loadboundtype',['../classegoa_1_1_power_grid.html#aec50a4e84a7d09f1ae89641b63a8bfa6',1,'egoa::PowerGrid::LoadBoundType() const'],['../classegoa_1_1_power_grid.html#aeb9a94f222be17d6866e2af688bdb633',1,'egoa::PowerGrid::LoadBoundType()']]], + ['loadboundtype_5f_33',['loadBoundType_',['../classegoa_1_1_power_grid.html#ac28c9303b516a11b7884088483942188',1,'egoa::PowerGrid']]], + ['loadexists_5f_34',['loadExists_',['../classegoa_1_1_power_grid.html#a3eb274400925b392471bda280dcf38eb',1,'egoa::PowerGrid']]], + ['loadid_35',['LoadId',['../classegoa_1_1_power_grid.html#a68b50b4872350c4953c53a9ee7765990',1,'egoa::PowerGrid']]], + ['loadids_36',['loadids',['../classegoa_1_1_power_grid.html#aa42587664cc370be9c268d96aedb3b2a',1,'egoa::PowerGrid::LoadIds(Types::vertexId vertexId, std::vector< Types::loadId > &loadIds) const'],['../classegoa_1_1_power_grid.html#a6878aab3f14e36a8b3aafc2c05b63b3a',1,'egoa::PowerGrid::LoadIds(TVertex const &vertex, std::vector< Types::loadId > &loadIds) const']]], + ['loadproperties_37',['loadproperties',['../classegoa_1_1_vertices_1_1_load_properties.html',1,'egoa::Vertices::LoadProperties< VertexType >'],['../classegoa_1_1_vertices_1_1_load_properties.html#a9150f032edad146b14aad7aae5335d55',1,'egoa::Vertices::LoadProperties::LoadProperties(Types::name name)'],['../classegoa_1_1_vertices_1_1_load_properties.html#a93b0229a945f84ab873855a5d9345469',1,'egoa::Vertices::LoadProperties::LoadProperties()']]], + ['loads_5f_38',['loads_',['../classegoa_1_1_power_grid.html#aaf58b2f4c8609c1977180d7d0ee334e5',1,'egoa::PowerGrid']]], + ['loadsat_39',['loadsat',['../classegoa_1_1_power_grid.html#a78120e692bcc0cc0ba601bdc31b05ee6',1,'egoa::PowerGrid::LoadsAt(Types::vertexId vertexId, std::vector< TLoadProperties > &loads) const'],['../classegoa_1_1_power_grid.html#a499bfe653734b72950d6e4ba5a7a5c86',1,'egoa::PowerGrid::LoadsAt(TVertex const &vertex, std::vector< TLoadProperties > &loads) const']]], + ['loadsnapshotof_40',['loadsnapshotof',['../classegoa_1_1_power_grid.html#aa1fb9b83cd4f9aab099d7730b1f9c386',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp)'],['../classegoa_1_1_power_grid.html#a0034e456379bf5342773ad14f2fe4308',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a7014febddeee4d7d11253b214dfc7d57',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition)'],['../classegoa_1_1_power_grid.html#ae3a4745b8534e3edbf04806d2bfbff74',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition) const']]], + ['loadsnapshots_5f_41',['loadSnapshots_',['../classegoa_1_1_power_grid.html#a6acf8d980196c3cedad81d57f9c3e9b2',1,'egoa::PowerGrid']]], + ['loadsnapshotsat_42',['loadsnapshotsat',['../classegoa_1_1_power_grid.html#a315d38a57b3940063135582fab01082a',1,'egoa::PowerGrid::LoadSnapshotsAt(Types::vertexId vertexId, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)'],['../classegoa_1_1_power_grid.html#ad526d933caea7fbbe155de87814e4021',1,'egoa::PowerGrid::LoadSnapshotsAt(TVertex const &vertex, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)'],['../classegoa_1_1_power_grid.html#ac693ae02a22c940e108ea9e928a52a06',1,'egoa::PowerGrid::LoadSnapshotsAt(Types::timestampSnapshot timestamp, std::vector< Types::loadSnapshot > &loadSnapshotsAtTimestamp)']]], + ['lowerbound_43',['LowerBound',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#ab31113d60b5ffac028fd721bf7105605',1,'egoa::IO::SolverRuntimeRow']]] +]; diff --git a/search/all_c.js b/search/all_c.js new file mode 100644 index 00000000..5562d6b7 --- /dev/null +++ b/search/all_c.js @@ -0,0 +1,57 @@ +var searchData= +[ + ['magenta_0',['Magenta',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab91cc2c1416fcca942b61c7ac5b1a9ac',1,'egoa::Color']]], + ['makebounded_1',['MakeBounded',['../classegoa_1_1_power_grid.html#ab0a2711c11ba4570ae42a16f2d431a52',1,'egoa::PowerGrid']]], + ['makeexact_2',['MakeExact',['../classegoa_1_1_power_grid.html#a5ed3492077d249e50fa9d30beb0519c5',1,'egoa::PowerGrid']]], + ['makeheapproperty_3',['makeheapproperty',['../classegoa_1_1_binary_heap.html#acb0407e2f873eb215c419bb63b9c2911',1,'egoa::BinaryHeap::MakeHeapProperty()'],['../classegoa_1_1_mapping_binary_heap.html#ac356fd6afe187ac205dc620b3231a9f5',1,'egoa::MappingBinaryHeap::MakeHeapProperty()']]], + ['makepureunbounded_4',['MakePureUnbounded',['../classegoa_1_1_power_grid.html#a5c9ca6a0426cc04a6a7941bf083d7fad',1,'egoa::PowerGrid']]], + ['makeunbounded_5',['MakeUnbounded',['../classegoa_1_1_power_grid.html#af74cf9dee6225b7d017a9fc553b1802c',1,'egoa::PowerGrid']]], + ['map_5f_6',['map_',['../classegoa_1_1_mapping_binary_heap.html#a151f0529b951b06006d8705d95ae1394',1,'egoa::MappingBinaryHeap']]], + ['mapbusname2vertexid_5f_7',['mapBusName2VertexId_',['../classegoa_1_1_py_psa_parser.html#a7ab6a6ecadb34fd84e0f14493a15ebc8',1,'egoa::PyPsaParser']]], + ['mapedges_8',['mapedges',['../classegoa_1_1_dynamic_graph.html#afce3324d042167ccdba78f26c798ee32',1,'egoa::DynamicGraph::MapEdges()'],['../classegoa_1_1_static_graph.html#affe5646eebfdafd8957c45dd951915c9',1,'egoa::StaticGraph::MapEdges()']]], + ['mapgeneratorname2busname_5f_9',['mapGeneratorName2BusName_',['../classegoa_1_1_py_psa_parser.html#a367e1a229147fe4c428afd4a4e828940',1,'egoa::PyPsaParser']]], + ['mapgeneratorname2generator_5f_10',['mapGeneratorName2Generator_',['../classegoa_1_1_py_psa_parser.html#add4341d1bc0ca1d13a4abd8029eeeb96',1,'egoa::PyPsaParser']]], + ['mapgeneratorname2identifier_5f_11',['mapGeneratorName2Identifier_',['../classegoa_1_1_py_psa_parser.html#a38783541b9d6f861637c632d550bb1dc',1,'egoa::PyPsaParser']]], + ['maploadname2identifier_5f_12',['mapLoadName2Identifier_',['../classegoa_1_1_py_psa_parser.html#a4e23c838c00645bbefeb850e0fd0cef2',1,'egoa::PyPsaParser']]], + ['mappingbinaryheap_13',['mappingbinaryheap',['../classegoa_1_1_mapping_binary_heap.html#ae60fc95c590462d297d019cc84a4e8ce',1,'egoa::MappingBinaryHeap::MappingBinaryHeap()'],['../classegoa_1_1_mapping_binary_heap.html',1,'egoa::MappingBinaryHeap< ElementType, KeyType, MapType >'],['../classegoa_1_1_mapping_binary_heap.html#a90e6d8312ee4ac7cc53182b85dfcff12',1,'egoa::MappingBinaryHeap::MappingBinaryHeap(std::vector< std::pair< TElement, TKey > > elementsKeyPairs, TComparator comparator=std::less< TKey >(), TMap map=TMap())'],['../classegoa_1_1_mapping_binary_heap.html#a2a2b0385b4d8c79291907bc85c10ea3a',1,'egoa::MappingBinaryHeap::MappingBinaryHeap(It first, It last, TComparator comparator=std::less< TKey >(), TMap map=TMap())']]], + ['mappingbinaryheap_3c_20typename_20graphtype_3a_3atvertexid_2c_20voltageangledifferencelabel_3c_20typename_20graphtype_3a_3atedge_20_3e_20_3e_14',['MappingBinaryHeap< typename GraphType::TVertexId, VoltageAngleDifferenceLabel< typename GraphType::TEdge > >',['../classegoa_1_1_mapping_binary_heap.html',1,'egoa']]], + ['mapvertices_15',['mapvertices',['../classegoa_1_1_dynamic_graph.html#accd9f93833b9a04d2a6c650224d1043e',1,'egoa::DynamicGraph::MapVertices()'],['../classegoa_1_1_static_graph.html#af0e8456898230772b2d96bb5f9e537de',1,'egoa::StaticGraph::MapVertices()']]], + ['marginalcost_16',['marginalcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a24dbf28e426a5c38c6fe721c3cd40853',1,'egoa::Vertices::GeneratorProperties::MarginalCost() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ade66c669e302f2eabf4337c2dc3b8f09',1,'egoa::Vertices::GeneratorProperties::MarginalCost()']]], + ['marginalcost_5f_17',['marginalCost_',['../classegoa_1_1_vertices_1_1_generator_properties.html#af04ab141877a41e5c849dd1841a30d06',1,'egoa::Vertices::GeneratorProperties']]], + ['maroon_18',['Maroon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad87fa7a1a056e269cdd6e102e507a822',1,'egoa::Color']]], + ['matchpathseparator_19',['MatchPathSeparator',['../structegoa_1_1_auxiliary_1_1_match_path_separator.html',1,'egoa::Auxiliary']]], + ['maxdegree_20',['maxdegree',['../classegoa_1_1_dynamic_graph.html#a0e4ba0993cf9cc7bbeb6a50b35741fef',1,'egoa::DynamicGraph::MaxDegree(Types::vertexId &id) const'],['../classegoa_1_1_dynamic_graph.html#acf65ad3153492d929753e3632c4405f9',1,'egoa::DynamicGraph::MaxDegree() const'],['../classegoa_1_1_static_graph.html#a8863c15316782f57249638f40acfb8a5',1,'egoa::StaticGraph::MaxDegree(Types::vertexId &id) const'],['../classegoa_1_1_static_graph.html#ada9c2faac6b9f4abeebd41987797e64e',1,'egoa::StaticGraph::MaxDegree() const']]], + ['maximize_21',['Maximize',['../classegoa_1_1_binary_heap.html#aedc884ad91379005f048105f5d6c2064',1,'egoa::BinaryHeap']]], + ['maximum_22',['maximum',['../classegoa_1_1_bound.html#a40ea7b759a29b3f69a6d8048ca859aad',1,'egoa::Bound::Maximum() const'],['../classegoa_1_1_bound.html#a67321cd1d7da3f8304e476594c8ca1ae',1,'egoa::Bound::Maximum()']]], + ['maximum_5f_23',['maximum_',['../classegoa_1_1_bound.html#aedfdd98c5f68a5c91e91f51d3564fe2e',1,'egoa::Bound']]], + ['maximumindex_24',['maximumindex',['../classegoa_1_1_mapping_binary_heap.html#a8dd16ac0c4f58970c5cbae2814ca000d',1,'egoa::MappingBinaryHeap::MaximumIndex()'],['../classegoa_1_1_binary_heap.html#a83cb95c271460ba8eec78f2d9677fff6',1,'egoa::BinaryHeap::MaximumIndex()']]], + ['maximumvoltage_25',['maximumvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a67afe428a3ee38adcbb9883b77303ee0',1,'egoa::Vertices::ElectricalProperties::MaximumVoltage() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a90cf78d44fe85cb098a294b892534466',1,'egoa::Vertices::ElectricalProperties::MaximumVoltage()']]], + ['mediumaquamarine_26',['Mediumaquamarine',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8adf61272b6c122106de50b7aeb449b8',1,'egoa::Color']]], + ['mediumblue_27',['Mediumblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4937b59cfe9d1be959ec69ffa328a590',1,'egoa::Color']]], + ['mediumorchid_28',['Mediumorchid',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a580a0007fa751cfe2fb0b15d17cd279d',1,'egoa::Color']]], + ['mediumpurple_29',['Mediumpurple',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa746a8190ddfdd1430e73536c1a8a137',1,'egoa::Color']]], + ['mediumseagreen_30',['Mediumseagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a49003468fce2917e93d941e3429c7897',1,'egoa::Color']]], + ['mediumslateblue_31',['Mediumslateblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a039cdc30f12b86b5015f0c8e11d4a1c8',1,'egoa::Color']]], + ['mediumspringgreen_32',['Mediumspringgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a9f52ca0ac460318c34520983fb0c8508',1,'egoa::Color']]], + ['mediumturquoise_33',['Mediumturquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a02db6e1da1059eb2fed387dc6ca80d7a',1,'egoa::Color']]], + ['mediumvioletred_34',['Mediumvioletred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a59f20c7f92e51acbb32dec421fc3095e',1,'egoa::Color']]], + ['mergelabelat_35',['MergeLabelAt',['../classegoa_1_1_dominating_theta_path.html#a852fcea5c53353b555be381100e0dbf8',1,'egoa::DominatingThetaPath']]], + ['midnightblue_36',['Midnightblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a920401d908962a4ce5bd177cc482e53d',1,'egoa::Color']]], + ['mindegree_37',['mindegree',['../classegoa_1_1_dynamic_graph.html#a7ad7413ef0b774cf5a9bad6b6a09011e',1,'egoa::DynamicGraph::MinDegree(Types::vertexId &id) const'],['../classegoa_1_1_dynamic_graph.html#a61aa60d20b8321828a9384426a6b63f1',1,'egoa::DynamicGraph::MinDegree() const'],['../classegoa_1_1_static_graph.html#a8018c87cdd76584f431ab953db798742',1,'egoa::StaticGraph::MinDegree(Types::vertexId &id) const'],['../classegoa_1_1_static_graph.html#a7c1f2f0b6e011b71eab90e4ea7e92244',1,'egoa::StaticGraph::MinDegree() const']]], + ['mindowntime_5f_38',['minDownTime_',['../classegoa_1_1_vertices_1_1_generator_properties.html#aff8bdf3753c68c97eb608be2302cf516',1,'egoa::Vertices::GeneratorProperties']]], + ['minimize_39',['Minimize',['../classegoa_1_1_binary_heap.html#a9bba6170b0d3a8d3fc952b4b31d855cd',1,'egoa::BinaryHeap']]], + ['minimum_40',['minimum',['../classegoa_1_1_bound.html#a3cd2f766d6978928da6f0cabcbae4280',1,'egoa::Bound::Minimum() const'],['../classegoa_1_1_bound.html#a6a4b726cbeee421b7ed1b6be90d7ead1',1,'egoa::Bound::Minimum()']]], + ['minimum_5f_41',['minimum_',['../classegoa_1_1_bound.html#ad44e96b48d4fb444193868a18e248164',1,'egoa::Bound']]], + ['minimumcapacity_42',['minimumcapacity',['../classegoa_1_1_voltage_angle_difference_label.html#a0448c53dad8ab6d31ffef25021be4446',1,'egoa::VoltageAngleDifferenceLabel::MinimumCapacity() const'],['../classegoa_1_1_voltage_angle_difference_label.html#a20a5b76d02f8f53063aaa7c2aaba0199',1,'egoa::VoltageAngleDifferenceLabel::MinimumCapacity()']]], + ['minimumcapacity_5f_43',['minimumCapacity_',['../classegoa_1_1_voltage_angle_difference_label.html#a9bc3ea6c23de1c75c3be7ac61048d84d',1,'egoa::VoltageAngleDifferenceLabel']]], + ['minimumdowntime_44',['minimumdowntime',['../classegoa_1_1_vertices_1_1_generator_properties.html#ad4ff5ef8c0116f5650aeae7ffd6b047c',1,'egoa::Vertices::GeneratorProperties::MinimumDownTime()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1844388ff5d3f5d61578837ac2d2fc6b',1,'egoa::Vertices::GeneratorProperties::MinimumDownTime() const']]], + ['minimumuptime_45',['minimumuptime',['../classegoa_1_1_vertices_1_1_generator_properties.html#a9f1422d1f8784f03f8e1487a42074d57',1,'egoa::Vertices::GeneratorProperties::MinimumUpTime() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a5a16f00b7f4a45a89885504aae6d4536',1,'egoa::Vertices::GeneratorProperties::MinimumUpTime()']]], + ['minimumvoltage_46',['minimumvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#ac8146b65a35336f8046f8a7d55ddb1b1',1,'egoa::Vertices::ElectricalProperties::MinimumVoltage() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6021bab4ec8254a07392cfef235cf45c',1,'egoa::Vertices::ElectricalProperties::MinimumVoltage()']]], + ['mintcream_47',['Mintcream',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acd821bc185401547f07cc6af8e94be10',1,'egoa::Color']]], + ['minuptime_5f_48',['minUpTime_',['../classegoa_1_1_vertices_1_1_generator_properties.html#ac19e8eb982b01ff06c081d955087dc9c',1,'egoa::Vertices::GeneratorProperties']]], + ['mipgap_49',['MipGap',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a782c3355bc799da00a25b8ffdf752f12',1,'egoa::IO::SolverRuntimeRow']]], + ['mistyrose_50',['Mistyrose',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6903df0c8f5530f30aae1db466f650ce',1,'egoa::Color']]], + ['moccasin_51',['Moccasin',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3764027d5d248d8e346a5951e9264338',1,'egoa::Color']]], + ['movetoprocessed_52',['MoveToProcessed',['../classegoa_1_1_bucket.html#a6c60263233e0265deb361625664846aa',1,'egoa::Bucket']]], + ['mst_53',['MST',['../classegoa_1_1_m_s_t.html',1,'egoa']]] +]; diff --git a/search/all_d.js b/search/all_d.js new file mode 100644 index 00000000..fe712bc1 --- /dev/null +++ b/search/all_d.js @@ -0,0 +1,55 @@ +var searchData= +[ + ['name_0',['name',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09',1,'egoa::Color::Name'],['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a9712533cdf0af1a5c37e5dd998b3b1a5',1,'egoa::IO::DtpRuntimeRow::Name'],['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a5fcbce71cb14048869110cf62b55fab8',1,'egoa::IO::SolverRuntimeRow::Name'],['../classegoa_1_1_dynamic_graph.html#af76a2b9a17b83abaa8fafa2829d5a239',1,'egoa::DynamicGraph::Name()'],['../classegoa_1_1_static_graph.html#a2a420df640dedf6bf52a5797d3731e4c',1,'egoa::StaticGraph::Name()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a0b13fb28bc969a0de0fcb1b6988d103f',1,'egoa::Vertices::LoadProperties::Name()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a1e4459b7846d1ff950134a9f655d32cf',1,'egoa::Vertices::LoadProperties::Name() const']]], + ['name_5f_1',['name_',['../classegoa_1_1_vertices_1_1_load_properties.html#addc4eb58febbb7c45bc58ac0594a23a6',1,'egoa::Vertices::LoadProperties::name_'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a22e57e9594c1e7da7871438f9cf38a7f',1,'egoa::Vertices::GeneratorProperties::name_'],['../classegoa_1_1_dynamic_graph.html#a2eb218c0d8908472695b0cae1366a6be',1,'egoa::DynamicGraph::name_'],['../classegoa_1_1_edges_1_1_electrical_properties.html#a369b3988b93769f574e65f34e789e57a',1,'egoa::Edges::ElectricalProperties::name_'],['../classegoa_1_1_static_graph.html#abd977b0836d23b35839e614c998eafd2',1,'egoa::StaticGraph::name_'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a366c607f56f40f5f56b17e3afd84c65c',1,'egoa::Vertices::ElectricalProperties::name_']]], + ['nameofproblem_2',['nameofproblem',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a241a5cde8f89b85bed11bfbb7d8f4572',1,'egoa::IO::SolverRuntimeRow::NameOfProblem'],['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#aebf6bf602b689f1b08c5df63fa32b613',1,'egoa::IO::DtpRuntimeRow::NameOfProblem']]], + ['navajowhite_3',['Navajowhite',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a971fa79bebff1cf4c43dd837ef0fe80f',1,'egoa::Color']]], + ['navy_4',['Navy',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a13ad5ac690e735fa48cf982532174e79',1,'egoa::Color']]], + ['neighborsof_5',['neighborsof',['../classegoa_1_1_dynamic_graph.html#a5633ee4d3e372ca4edef50dece494407',1,'egoa::DynamicGraph::NeighborsOf(Types::vertexId id) const'],['../classegoa_1_1_dynamic_graph.html#ad4d491e741c5187401d8294ab71ba5df',1,'egoa::DynamicGraph::NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const'],['../classegoa_1_1_static_graph.html#a38473d24376a5a77cdf10fda912785de',1,'egoa::StaticGraph::NeighborsOf(Types::vertexId id) const'],['../classegoa_1_1_static_graph.html#a000af065a6eca662c41e0b44eff8e642',1,'egoa::StaticGraph::NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const']]], + ['networkboundtype_6',['NetworkBoundType',['../classegoa_1_1_power_grid.html#a4392ec356e91e4bb64c07946c74e73a3',1,'egoa::PowerGrid']]], + ['networkdifferentiation_7',['NetworkDifferentiation',['../classegoa_1_1internal_1_1_network_differentiation.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20egoa_3a_3avertices_3a_3aelectricalproperties_3c_20egoa_3a_3avertices_3a_3aieeebustype_20_3e_2c_20egoa_3a_3aedges_3a_3aelectricalproperties_2c_20staticgraph_3c_20egoa_3a_3avertices_3a_3aelectricalproperties_3c_20egoa_3a_3avertices_3a_3aieeebustype_20_3e_2c_20egoa_3a_3aedges_3a_3aelectricalproperties_20_3e_20_3e_8',['NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie25fdcdc3c845cdb06c6c2944360d5752.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20vertextypeproperties_2c_20edgetypeproperties_2c_20powergrid_3c_20staticgraph_3c_20vertextypeproperties_2c_20edgetypeproperties_20_3e_2c_20vertices_3a_3ageneratorproperties_3c_3e_2c_20vertices_3a_3aloadproperties_3c_20vertices_3a_3aieeebustype_20_3e_20_3e_20_3e_9',['NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr95fa1fc366e5b030b1043055b1ebef80.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20vertextypeproperties_2c_20edgetypeproperties_2c_20staticgraph_3c_20vertextypeproperties_2c_20edgetypeproperties_20_3e_20_3e_10',['NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr828ec4fd22b4d3b547d9914b4f2478c6.html',1,'egoa::internal']]], + ['networktype_11',['NetworkType',['../classegoa_1_1_power_grid.html#a22c34322d376bfd48a68ace260654c66',1,'egoa::PowerGrid']]], + ['newline_12',['NewLine',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5677431182ce2a13ae4bbdaae71a554c',1,'egoa::IO::GeoJsonWriter']]], + ['nodestack_5f_13',['nodeStack_',['../classegoa_1_1_block_cut_tree_traversal.html#adaf915e2ea7532ee3760ff9a5132eb66',1,'egoa::BlockCutTreeTraversal']]], + ['nominalapparentpower_5f_14',['nominalApparentPower_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a1ff8f801883afe82ac7e2a752a6f4121',1,'egoa::Edges::ElectricalProperties']]], + ['nominalapparentpowerbound_5f_15',['nominalApparentPowerBound_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a1dbfaab8272b3df076676be5ea0ca81b',1,'egoa::Edges::ElectricalProperties']]], + ['nominalapparentpowerextendable_5f_16',['nominalApparentPowerExtendable_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a7dc05b22a95cb5f0ecd5aeed3e388fc8',1,'egoa::Edges::ElectricalProperties']]], + ['nominalpower_17',['nominalpower',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0c430e37f0fff0b447b9e59533710f67',1,'egoa::Vertices::GeneratorProperties::NominalPower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8ab23e2ff8350bf4836d78d3bf93725f',1,'egoa::Vertices::GeneratorProperties::NominalPower()']]], + ['nominalpower_5f_18',['nominalPower_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a3610c231c3a87808b48928c472781b99',1,'egoa::Vertices::GeneratorProperties']]], + ['nominalrealpowerbound_19',['nominalrealpowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a7ce421682af9dbdf8ee716a560b52522',1,'egoa::Vertices::GeneratorProperties::NominalRealPowerBound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1cb4cea1223751a4b0a4aff400dad15c',1,'egoa::Vertices::GeneratorProperties::NominalRealPowerBound()']]], + ['nominalrealpowerbound_5f_20',['nominalRealPowerBound_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8390bd49c6d35f04975a8a4212bd16aa',1,'egoa::Vertices::GeneratorProperties']]], + ['nominalvoltage_21',['nominalvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a7b51be20f051f419ac4a1cc701119366',1,'egoa::Vertices::ElectricalProperties::NominalVoltage()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a77b87ce0275164fed50ac909ed2c649e',1,'egoa::Vertices::ElectricalProperties::NominalVoltage() const']]], + ['nominalvoltage_5f_22',['nominalvoltage_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a0bf3475c3b172575ef061e449476f3a3',1,'egoa::Edges::ElectricalProperties::nominalVoltage_'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a7ec941f89ead467356b19d26e1b3dcb7',1,'egoa::Vertices::ElectricalProperties::nominalVoltage_']]], + ['numberofbinaryvars_23',['NumberOfBinaryVars',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#ac0300ab8539831a8c34dd74f5fa201b8',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofblocks_24',['NumberOfBlocks',['../classegoa_1_1_block_cut_tree.html#a301355e10817dc9454fabe685603182f',1,'egoa::BlockCutTree']]], + ['numberofconstraints_25',['NumberOfConstraints',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#adfc9241ecf408b92c3a72dcffbfc3c66',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofcutvertices_26',['NumberOfCutVertices',['../classegoa_1_1_block_cut_tree.html#a9632b5d0c09c805ec06dda6362fa9d68',1,'egoa::BlockCutTree']]], + ['numberofcutvertices_5f_27',['numberOfCutVertices_',['../classegoa_1_1_block_cut_tree.html#a037cc6cf81e84b6c987eca50262e9f7d',1,'egoa::BlockCutTree']]], + ['numberofedges_28',['numberofedges',['../classegoa_1_1_static_graph.html#aad69a3656933a239e1bb75f7df725fb1',1,'egoa::StaticGraph::NumberOfEdges()'],['../classegoa_1_1_dynamic_graph.html#a721c90423907f562dbbd4eecc2de83cb',1,'egoa::DynamicGraph::NumberOfEdges()'],['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#ad7226e55ddf400727cacba020f6d1260',1,'egoa::IO::SolverRuntimeRow::NumberOfEdges'],['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#afd97c66447a907055de872d8e46e1531',1,'egoa::IO::DtpRuntimeRow::NumberOfEdges']]], + ['numberofedges_5f_29',['numberOfEdges_',['../classegoa_1_1_dynamic_graph.html#aaa987018767a1c69f1c77875e48418a0',1,'egoa::DynamicGraph']]], + ['numberofedgesproducingnocycle_30',['NumberOfEdgesProducingNoCycle',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a621a64b6de98762329542d5e46893cb3',1,'egoa::IO::DtpRuntimeRow']]], + ['numberofgenconstrains_31',['NumberOfGenConstrains',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a99098bbfe2675b0a964db02012153f7b',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofgenerators_32',['NumberOfGenerators',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a0020438795621eeb95865040340065a6',1,'egoa::IO::DtpRuntimeRow']]], + ['numberofgenerators_5f_33',['numberOfGenerators_',['../classegoa_1_1_power_grid.html#a6538d0b5be0f77be5c28bda7dbbce531',1,'egoa::PowerGrid']]], + ['numberofintvars_34',['NumberOfIntVars',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a5505dcc731146bdf3d1f2d9971e35a89',1,'egoa::IO::SolverRuntimeRow']]], + ['numberoflabels_35',['numberoflabels',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#aaac8bc34a6d2d9167c7af77bc20e71d1',1,'egoa::IO::DtpRuntimeRow::NumberOfLabels'],['../classegoa_1_1_dominating_theta_path.html#a76b262a59b028eafefbaaf4177b87cb7',1,'egoa::DominatingThetaPath::NumberOfLabels()']]], + ['numberofloads_36',['NumberOfLoads',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#ab1352bcb3197cb531b0952f66c081bd2',1,'egoa::IO::DtpRuntimeRow']]], + ['numberofloads_5f_37',['numberOfLoads_',['../classegoa_1_1_power_grid.html#a19463a217e5072df0d1e4e34c7e0e439',1,'egoa::PowerGrid']]], + ['numberofnzs_38',['NumberOfNZs',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a8fcc61daa6551733186795f8ef742713',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofparallellines_5f_39',['numberOfParallelLines_',['../classegoa_1_1_edges_1_1_electrical_properties.html#a3748abf7baaff0cbb43064d77923baeb',1,'egoa::Edges::ElectricalProperties']]], + ['numberofpathsthroughedge_40',['NumberOfPathsThroughEdge',['../classegoa_1_1_dominating_theta_path.html#a40352a0d3e186565fb3a9bc3db5a72b2',1,'egoa::DominatingThetaPath']]], + ['numberofpathsthroughvertex_41',['NumberOfPathsThroughVertex',['../classegoa_1_1_dominating_theta_path.html#acfd8640564100eb2098d9b1880184be0',1,'egoa::DominatingThetaPath']]], + ['numberofprocessedelements_42',['NumberOfProcessedElements',['../classegoa_1_1_bucket.html#a9bdb3f0ab0be29032de6985ebccfaea8',1,'egoa::Bucket']]], + ['numberofqconstrains_43',['NumberOfQConstrains',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#afb564b69198d445b9e90a342c41c0fcb',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofrelaxededges_44',['NumberOfRelaxedEdges',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#a339d6112ffd6388d48197114eb8082c5',1,'egoa::IO::DtpRuntimeRow']]], + ['numberofscannededges_45',['NumberOfScannedEdges',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#adf8e4362c0375bc3f63d0a5397ece156',1,'egoa::IO::DtpRuntimeRow']]], + ['numberofsos_46',['NumberOfSoS',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#ab0418efa19314e5ad907338e0b20ca2d',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofunprocessedelements_47',['NumberOfUnprocessedElements',['../classegoa_1_1_bucket.html#a47262dfb1e4d3dfef9fa2ee3a35e69c8',1,'egoa::Bucket']]], + ['numberofvalidunprocessedelements_5f_48',['numberOfValidUnprocessedElements_',['../classegoa_1_1_bucket.html#a4ae2987628560b8d40a3597fdbef041d',1,'egoa::Bucket']]], + ['numberofvariables_49',['NumberOfVariables',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a5afec2fa6b261b02c1737c64b5ee15bb',1,'egoa::IO::SolverRuntimeRow']]], + ['numberofvertices_50',['numberofvertices',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html#afe6873008581b68f61dc818893da7f50',1,'egoa::IO::DtpRuntimeRow::NumberOfVertices'],['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a7dd5b631fc6af9469dd23f92073d4d46',1,'egoa::IO::SolverRuntimeRow::NumberOfVertices'],['../classegoa_1_1_union_find.html#a9255a8cfbb34ae60715733b5c170f6e8',1,'egoa::UnionFind::NumberOfVertices()'],['../classegoa_1_1_dynamic_graph.html#abb92b7483970a5b1184a83a2d9a4ad09',1,'egoa::DynamicGraph::NumberOfVertices()'],['../classegoa_1_1_static_graph.html#a2366b7e2c19337129a0d0e50cb53e746',1,'egoa::StaticGraph::NumberOfVertices()']]], + ['numberofvertices_5f_51',['numberOfVertices_',['../classegoa_1_1_dynamic_graph.html#ab88d36e94cab406ab7e3323850de4c69',1,'egoa::DynamicGraph']]] +]; diff --git a/search/all_e.js b/search/all_e.js new file mode 100644 index 00000000..648b2fb0 --- /dev/null +++ b/search/all_e.js @@ -0,0 +1,30 @@ +var searchData= +[ + ['oldlace_0',['Oldlace',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4431c944bbf8d821ac35f49de336bc96',1,'egoa::Color']]], + ['olive_1',['Olive',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2b8b384cdd92d3e81c43b2d43de8c247',1,'egoa::Color']]], + ['olivedrab_2',['Olivedrab',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa88205173f829b308604a4578842de30',1,'egoa::Color']]], + ['omittingiterator_3',['omittingiterator',['../classegoa_1_1_omitting_iterator.html#abc7b5b14722c7011924b11981ade8aec',1,'egoa::OmittingIterator::OmittingIterator()'],['../classegoa_1_1_omitting_iterator.html',1,'egoa::OmittingIterator< ElementVectorIt, BoolVectorIt >']]], + ['omittingvectorview_4',['omittingvectorview',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html',1,'egoa::DynamicGraph< VertexProperties, EdgeProperties >::OmittingVectorView< ElementType, Const >'],['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a8b7754882c2f5b145cdbedb9aed7c8ab',1,'egoa::DynamicGraph::OmittingVectorView::OmittingVectorView()']]], + ['openfile_5',['OpenFile',['../classegoa_1_1_py_psa_parser.html#af9f3c86056d53c6e768ce27fd56c0522',1,'egoa::PyPsaParser']]], + ['operator_21_3d_6',['operator!=',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a95e2a8abe5ad61172055fd8399dfeabe',1,'egoa::Vertices::ElectricalProperties::operator!=()'],['../classegoa_1_1_voltage_angle_difference_label.html#a5c76be28dd6acf9b4670e235526ecfe0',1,'egoa::VoltageAngleDifferenceLabel::operator!=()'],['../classegoa_1_1_susceptance_norm_label.html#ab7cc9d78f4107666fe073191417b7f3f',1,'egoa::SusceptanceNormLabel::operator!=()'],['../classegoa_1_1_bucket_element.html#a13803e1f85f3f0459df51f778357cad9',1,'egoa::BucketElement::operator!=()'],['../classegoa_1_1_vertices_1_1_vertex.html#aaff90cca8b8b4991ac4e2f33fc4c6502',1,'egoa::Vertices::Vertex::operator!='],['../classegoa_1_1_vertices_1_1_load_properties.html#a8fe6ebc3a45d5adb6e419cdeecea3f8a',1,'egoa::Vertices::LoadProperties::operator!=()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a662c025833dce2fbae0d1fa4e9a87e5d',1,'egoa::Vertices::GeneratorProperties::operator!=()'],['../classegoa_1_1_edges_1_1_electrical_properties.html#ac60413c9f3bc89163e900f65acc727cc',1,'egoa::Edges::ElectricalProperties::operator!='],['../classegoa_1_1_edges_1_1_edge.html#a3a7d391a881d7e305956a91ea59e7d31',1,'egoa::Edges::Edge::operator!='],['../classegoa_1_1_binary_heap.html#a6e2e4b1011eb6fc5c941e7821f499b81',1,'egoa::BinaryHeap::operator!=()']]], + ['operator_2b_7',['operator+',['../classegoa_1_1_susceptance_norm_label.html#ae4ada6f0eaf806beed9b1517a3e4288e',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#ad452ef4763e1305f678ac97c8b5353ca',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#ad968f3fb33ac3558c2f05a2c03de9412',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#a5259d94609c7014e83936b0fe7e4e010',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#afe173a6796db67ae93c6d0a323a231b7',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#a03093772f00792746a61a76fee7f8dbd',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#ae8710fe5ffbf887042391e8f0cc6b9f2',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#adbcdbbabeb758c86aeb262a76e5670fc',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_bucket_element.html#a8dea837200204f7403d0f414a3e2d604',1,'egoa::BucketElement::operator+()']]], + ['operator_2b_3d_8',['operator+=',['../classegoa_1_1_binary_heap.html#a4cdd31030d364846945fad833718e185',1,'egoa::BinaryHeap::operator+=(TElement const &rhs)'],['../classegoa_1_1_binary_heap.html#adb2bfb65ff911ca750969f6cd212db58',1,'egoa::BinaryHeap::operator+=(TElement &&rhs)'],['../classegoa_1_1_mapping_binary_heap.html#a14bcb1a1d010b271363c9b57c8d64b53',1,'egoa::MappingBinaryHeap::operator+=()'],['../classegoa_1_1_bucket_element.html#a3e909b638fcb3488c56d5000bcf37354',1,'egoa::BucketElement::operator+=()'],['../classegoa_1_1_susceptance_norm_label.html#a55c657a35bb2539847eb4d634732eb7b',1,'egoa::SusceptanceNormLabel::operator+=()'],['../classegoa_1_1_voltage_angle_difference_label.html#af5e2e1b3e08439f3ce6254a39c2b3c42',1,'egoa::VoltageAngleDifferenceLabel::operator+=()'],['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#ac583de3aa142785d04285431bfa356a3',1,'egoa::IO::DtpRuntimeCollection::operator+=()']]], + ['operator_3c_9',['operator<',['../classegoa_1_1_bucket_element.html#a86827612a62c1ae2459c636e4988f829',1,'egoa::BucketElement::operator<()'],['../classegoa_1_1_susceptance_norm_label.html#a893afd3b5e92e9b385c23ddf6fad31fd',1,'egoa::SusceptanceNormLabel::operator<()'],['../classegoa_1_1_voltage_angle_difference_label.html#ad141916e892f5bd00530f7ab5ae777a6',1,'egoa::VoltageAngleDifferenceLabel::operator<()']]], + ['operator_3c_3c_10',['operator<<',['../classegoa_1_1_label.html#a8605f408c1b65641e478eb2576cfbca5',1,'egoa::Label::operator<<'],['../classegoa_1_1_susceptance_norm_label.html#afefc5f826b7a22d0ff9c6c6bd5434147',1,'egoa::SusceptanceNormLabel::operator<<'],['../classegoa_1_1_voltage_angle_difference_label.html#ae880ec9359b588940656813a44602077',1,'egoa::VoltageAngleDifferenceLabel::operator<<'],['../classegoa_1_1_power_grid.html#ac71da4b2f48c667225317ce60555c8ca',1,'egoa::PowerGrid::operator<<'],['../namespaceegoa.html#a5f54156277004b69798bfdf1548add62',1,'egoa::operator<<()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8d288ddb2d4a11f5c5aac8d0d1f3cfcd',1,'egoa::Vertices::GeneratorProperties::operator<<'],['../classegoa_1_1_binary_heap.html#abf1d9b71852bb62b191eee6db5ee01fb',1,'egoa::BinaryHeap::operator<<'],['../classegoa_1_1_edges_1_1_electrical_properties.html#a4952a22fe49cd84a17941a9756e0cc52',1,'egoa::Edges::ElectricalProperties::operator<<'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a58f8d91d03482a8e908a9bd5463979ec',1,'egoa::Vertices::ElectricalProperties::operator<<'],['../classegoa_1_1_bucket_element.html#aa1e10f422d96710227e704c8736a05fa',1,'egoa::BucketElement::operator<<'],['../classegoa_1_1_static_graph.html#aa5c46d95341653c3f92e60d21bc6f570',1,'egoa::StaticGraph::operator<<']]], + ['operator_3c_3d_11',['operator<=',['../classegoa_1_1_susceptance_norm_label.html#a49fd536f5803fe62920ef81672bf3cc9',1,'egoa::SusceptanceNormLabel::operator<=()'],['../classegoa_1_1_voltage_angle_difference_label.html#acbac31b31ccf4a3891db37c48289f619',1,'egoa::VoltageAngleDifferenceLabel::operator<=()'],['../classegoa_1_1_bucket_element.html#a5e9f6c74469e7121b12c94fb37be50b6',1,'egoa::BucketElement::operator<=()']]], + ['operator_3d_3d_12',['operator==',['../classegoa_1_1_bound.html#a07ba950cf18d1c51e86d59371f7a3346',1,'egoa::Bound::operator==()'],['../classegoa_1_1_voltage_angle_difference_label.html#a3508a0a62a327f26f7a632d760d69995',1,'egoa::VoltageAngleDifferenceLabel::operator==()'],['../classegoa_1_1_susceptance_norm_label.html#ad7356566ddf7c3b18293274bdd492366',1,'egoa::SusceptanceNormLabel::operator==()'],['../classegoa_1_1_bucket_element.html#a0acddc0768beaad9718687cdcfb16988',1,'egoa::BucketElement::operator==()'],['../classegoa_1_1_vertices_1_1_vertex.html#a578b6a4b9528651ce5ddead6ed87d7ea',1,'egoa::Vertices::Vertex::operator=='],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8cc858d1eaa8c653901a58428004bcc8',1,'egoa::Vertices::GeneratorProperties::operator==()'],['../classegoa_1_1_binary_heap.html#a8b515bc93fc52b1294575de9818f4aa0',1,'egoa::BinaryHeap::operator==()'],['../classegoa_1_1_edges_1_1_edge.html#a5c7ab13984a79518de6ff1d43db56d95',1,'egoa::Edges::Edge::operator=='],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5e1c51302b170ce459e8ce95223f5db8',1,'egoa::Vertices::ElectricalProperties::operator==()'],['../classegoa_1_1_vertices_1_1_load_properties.html#af618517002a610e45592f0949ac900e2',1,'egoa::Vertices::LoadProperties::operator==()'],['../classegoa_1_1_edges_1_1_electrical_properties.html#a287f42f66ea28d67f170128df12610a0',1,'egoa::Edges::ElectricalProperties::operator==']]], + ['operator_3e_13',['operator>',['../classegoa_1_1_susceptance_norm_label.html#aeb81bffa61720553785f806cfeb1eaae',1,'egoa::SusceptanceNormLabel::operator>()'],['../classegoa_1_1_voltage_angle_difference_label.html#a3915d847607a6ca7defd659a74bfe301',1,'egoa::VoltageAngleDifferenceLabel::operator>()'],['../classegoa_1_1_bucket_element.html#adc7abd4ef0dc7887989d4096aa1f62e9',1,'egoa::BucketElement::operator>(BucketElement const &rhs) const']]], + ['operator_3e_3d_14',['operator>=',['../classegoa_1_1_bucket_element.html#a96b7f3bb6c12ea44b7db0b8d00b29eb7',1,'egoa::BucketElement::operator>=()'],['../classegoa_1_1_voltage_angle_difference_label.html#a26132f4531c24d60ef2ab52df177fcd3',1,'egoa::VoltageAngleDifferenceLabel::operator>=()'],['../classegoa_1_1_susceptance_norm_label.html#aa8af31381d488d7d6832916068477767',1,'egoa::SusceptanceNormLabel::operator>=()']]], + ['operator_5b_5d_15',['operator[]',['../classegoa_1_1_bucket.html#a55b47966ca7150d2daa2f5499f8e34fc',1,'egoa::Bucket::operator[](Types::index index)'],['../classegoa_1_1_bucket.html#a251a45b6ee5efde0fd015f5e169bf2b1',1,'egoa::Bucket::operator[](Types::index index) const']]], + ['optima_16',['Optima',['../classegoa_1_1_bucket.html#a002053357b5bbfa8f6f81c82002071b4',1,'egoa::Bucket']]], + ['optimizationruntimeseconds_17',['OptimizationRuntimeSeconds',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html#a69149a0d2458976cbc95a17a7fb4ad57',1,'egoa::IO::SolverRuntimeRow']]], + ['orange_18',['Orange',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a909cea0c97058cfe2e3ea8d675cb08e1',1,'egoa::Color']]], + ['orangered_19',['Orangered',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a9f9a24f2c44edc91083fd1f03ebbbaaa',1,'egoa::Color']]], + ['orchid_20',['Orchid',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0474ae22bec123c6a616d6a757c9fce0',1,'egoa::Color']]], + ['other_21',['Other',['../classegoa_1_1_edges_1_1_edge.html#a9ad20c2e19045ec9a615356862e2244e',1,'egoa::Edges::Edge']]], + ['outdegreeat_22',['outdegreeat',['../classegoa_1_1_dynamic_graph.html#aaa36840ee841fadc63092c6be0a623f0',1,'egoa::DynamicGraph::OutDegreeAt()'],['../classegoa_1_1_static_graph.html#a209c7941ec3d098ca4803aba156d2c3b',1,'egoa::StaticGraph::OutDegreeAt()']]], + ['outedgeids_5f_23',['outedgeids_',['../classegoa_1_1_dynamic_graph.html#a19101bf2f0c38195893806c02ca52a8c',1,'egoa::DynamicGraph::outEdgeIds_'],['../classegoa_1_1_static_graph.html#a28704b04045cf6ee055c37c4abaab830',1,'egoa::StaticGraph::outEdgeIds_']]], + ['outedgeidsat_24',['outedgeidsat',['../classegoa_1_1_dynamic_graph.html#ae40c57a847b4c0bc735584eb7c8eb631',1,'egoa::DynamicGraph::OutEdgeIdsAt()'],['../classegoa_1_1_static_graph.html#a5101bb31aafc18f74abde087828d6084',1,'egoa::StaticGraph::OutEdgeIdsAt()']]], + ['outputgeneratorsnaps_25',['OutputGeneratorSnaps',['../classegoa_1_1_power_grid.html#a9371133bd3fe1339111c1b717b0bf336',1,'egoa::PowerGrid']]], + ['outputloadsnaps_26',['OutputLoadSnaps',['../classegoa_1_1_power_grid.html#a7d847e7a4851634bb5a83a2a2c52f90e',1,'egoa::PowerGrid']]] +]; diff --git a/search/all_f.js b/search/all_f.js new file mode 100644 index 00000000..07b60c23 --- /dev/null +++ b/search/all_f.js @@ -0,0 +1,54 @@ +var searchData= +[ + ['palegoldenrod_0',['Palegoldenrod',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a530cb76dd794405902c9d20f716e645a',1,'egoa::Color']]], + ['palegreen_1',['Palegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af005435518cdbc041fd486c8d5267f5a',1,'egoa::Color']]], + ['paleturquoise_2',['Paleturquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af0579e21eaed558089b5c43a32821217',1,'egoa::Color']]], + ['palevioletred_3',['Palevioletred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a356d0f2e545365efaf5868285deac49a',1,'egoa::Color']]], + ['papayawhip_4',['Papayawhip',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a18c28e06a92a4d121da46dee1023cad7',1,'egoa::Color']]], + ['parallel_5',['parallel',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a48920c071f6a5c97ae3739be64630697',1,'egoa']]], + ['parent_5f_6',['parent_',['../classegoa_1_1_traversal.html#a6da29457427805c3d8c93556c15de07f',1,'egoa::Traversal']]], + ['parentof_7',['ParentOf',['../classegoa_1_1_traversal.html#aacc75d7dbc197114ad3ebff7a9b43489',1,'egoa::Traversal']]], + ['path2filedirectory_5f_8',['path2FileDirectory_',['../classegoa_1_1_py_psa_parser.html#a29a51cd56d7f187dae0cd610702f4445',1,'egoa::PyPsaParser']]], + ['pc1_9',['pc1',['../classegoa_1_1_vertices_1_1_generator_properties.html#a4411578ddd3188b92c8833925b5cd2a6',1,'egoa::Vertices::GeneratorProperties::Pc1()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a837f2e2d404419f78eae7b0ae6658dc3',1,'egoa::Vertices::GeneratorProperties::Pc1() const']]], + ['pc1_5f_10',['pc1_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0b593ccd84e9425b4e65af60b105f21a',1,'egoa::Vertices::GeneratorProperties']]], + ['pc2_11',['pc2',['../classegoa_1_1_vertices_1_1_generator_properties.html#af99167fb703905d177c6d5d57ff7ab3f',1,'egoa::Vertices::GeneratorProperties::Pc2()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#addbec61641e682d8a6ef8946e3ef99be',1,'egoa::Vertices::GeneratorProperties::Pc2() const']]], + ['pc2_5f_12',['pc2_',['../classegoa_1_1_vertices_1_1_generator_properties.html#a322a777807d3d6f7b849343cf6b69d75',1,'egoa::Vertices::GeneratorProperties']]], + ['peachpuff_13',['Peachpuff',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09abb2ac4541cb992d295d5df676692fa78',1,'egoa::Color']]], + ['peru_14',['Peru',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a84c8fa2341f7d052a1ee3a36ff043798',1,'egoa::Color']]], + ['pink_15',['Pink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8dc5344bc0746e1cc5abf896ca03bbdf',1,'egoa::Color']]], + ['plum_16',['Plum',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93df2c41a9abe4a797371f5c761adbfe',1,'egoa::Color']]], + ['pnomextendable_5f_17',['pNomExtendable_',['../classegoa_1_1_vertices_1_1_generator_properties.html#af74e0d97f27e176b48681f4f45174c80',1,'egoa::Vertices::GeneratorProperties']]], + ['pointer_18',['pointer',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html#ae6c6af9511bb99a7a1b499b66404f1ef',1,'egoa::BinaryHeap::HeapIterator']]], + ['pop_19',['pop',['../classegoa_1_1_mapping_binary_heap.html#a2fb041b6866be5b4313def2b529c9959',1,'egoa::MappingBinaryHeap::Pop()'],['../classegoa_1_1_bucket.html#a498efb3fbf9e5a010df1cbde41b13340',1,'egoa::Bucket::Pop()'],['../classegoa_1_1_binary_heap.html#ac895f8167d62a9767f3e319e85fece7c',1,'egoa::BinaryHeap::Pop()']]], + ['popblock_20',['PopBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#ae56d0d1da49b8105b242a8513f1821e1',1,'egoa::internal::BlockCutTreeBuilder']]], + ['popinvalidunprocessedelements_21',['PopInvalidUnprocessedElements',['../classegoa_1_1_bucket.html#a9fb37902e69ac3c4791b041e1ea07765',1,'egoa::Bucket']]], + ['positionof_22',['PositionOf',['../classegoa_1_1_power_grid.html#a56b95993041b44f84dc7b5c104a5487b',1,'egoa::PowerGrid']]], + ['postprocessingedgewith_23',['postprocessingedgewith',['../classegoa_1_1_depth_first_search.html#af91647fa8959f846c7bad3227a34a9c8',1,'egoa::DepthFirstSearch::PostprocessingEdgeWith()'],['../classegoa_1_1_articulation_vertex_detection.html#a1b0a4a578cf8ade4bccd0f43d8d40328',1,'egoa::ArticulationVertexDetection::PostprocessingEdgeWith()']]], + ['postprocessingvertexwith_24',['postprocessingvertexwith',['../classegoa_1_1_depth_first_search.html#a36e25533cde9364f59e083e5b1221d38',1,'egoa::DepthFirstSearch::PostprocessingVertexWith()'],['../classegoa_1_1_articulation_vertex_detection.html#a2fad54d275484feb6f233e2c7d9b9ca3',1,'egoa::ArticulationVertexDetection::PostprocessingVertexWith()']]], + ['powderblue_25',['Powderblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a50e023a045ecd1dd1f6d249b065ae7a8',1,'egoa::Color']]], + ['powergrid_26',['powergrid',['../classegoa_1_1_power_grid.html#a19c62ffecf3b6cfa8d1efa6adcbf0524',1,'egoa::PowerGrid::PowerGrid()'],['../classegoa_1_1_power_grid.html',1,'egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >']]], + ['powergridio_27',['PowerGridIO',['../classegoa_1_1_power_grid_i_o.html',1,'egoa']]], + ['powergridloopdifferentiation_28',['PowerGridLoopDifferentiation',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3abreakable_20_3e_29',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3aparallel_20_3e_30',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3asequential_20_3e_31',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['powersign_32',['powersign',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8f1dfba9865d02f454c36e327916f155',1,'egoa::Vertices::GeneratorProperties::PowerSign() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a403c85a83ea0581ac239119c4e2fdc43',1,'egoa::Vertices::GeneratorProperties::PowerSign()']]], + ['preprocessingvertexwith_33',['preprocessingvertexwith',['../classegoa_1_1_articulation_vertex_detection.html#a5aa44ab46057229f0f3a8d9eaede960b',1,'egoa::ArticulationVertexDetection::PreprocessingVertexWith()'],['../classegoa_1_1_depth_first_search.html#af1711f72afe88006828f839295b4190b',1,'egoa::DepthFirstSearch::PreprocessingVertexWith()']]], + ['previouslabel_34',['previouslabel',['../classegoa_1_1_label.html#aa9b4adb866c2c18057de32b7d296516e',1,'egoa::Label::PreviousLabel()'],['../classegoa_1_1_label.html#a2fe7325ef63dc2d9b46fcdf1dbbc2b7e',1,'egoa::Label::PreviousLabel() const']]], + ['previouslabelid_5f_35',['previousLabelId_',['../classegoa_1_1_label.html#ae21dc9b9aba7b065b3d825833941406b',1,'egoa::Label']]], + ['previousvertex_36',['previousvertex',['../classegoa_1_1_label.html#a15361b688257549ecf4cd50223c312fc',1,'egoa::Label::PreviousVertex() const'],['../classegoa_1_1_label.html#ac956096abbd4c13c2f50be788c1e8877',1,'egoa::Label::PreviousVertex()']]], + ['previousvertexid_5f_37',['previousVertexId_',['../classegoa_1_1_label.html#aa76fbca0d8c698354b1ed68c39a56e6a',1,'egoa::Label']]], + ['prim_38',['Prim',['../classegoa_1_1_prim.html',1,'egoa']]], + ['priorityqueue_39',['PriorityQueue',['../classegoa_1_1_priority_queue.html',1,'egoa']]], + ['processed_5f_40',['processed_',['../classegoa_1_1_traversal.html#a4260c0021417b6b446119fa6e3b3550c',1,'egoa::Traversal']]], + ['processedelements_5f_41',['processedElements_',['../classegoa_1_1_bucket.html#a54ce88050b6d09da21d362eaacc489d3',1,'egoa::Bucket']]], + ['processedvertexat_42',['ProcessedVertexAt',['../classegoa_1_1_traversal.html#a60cd6af384c9f5c7301e886434825a15',1,'egoa::Traversal']]], + ['processingedgewith_43',['ProcessingEdgeWith',['../classegoa_1_1_articulation_vertex_detection.html#af63e8535adc756d8d121ecdda60303e7',1,'egoa::ArticulationVertexDetection']]], + ['producecycle_44',['ProduceCycle',['../classegoa_1_1_dominating_theta_path.html#ad43c8c05a04271a701b47fe99c30700f',1,'egoa::DominatingThetaPath']]], + ['properties_5f_45',['properties_',['../classegoa_1_1_edges_1_1_edge.html#a97bb045e6599fced68b3a18d100b17b1',1,'egoa::Edges::Edge::properties_'],['../classegoa_1_1_vertices_1_1_vertex.html#a5edad6fc7657db8136c02970efbc13d1',1,'egoa::Vertices::Vertex::properties_']]], + ['propertytemplate_46',['PropertyTemplate',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ad7aefa6f9db1e3573382a1853fb1f7c1',1,'egoa::IO::GeoJsonWriter']]], + ['purple_47',['Purple',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab9ba865fec061c9706d2fd7ce49c0cc7',1,'egoa::Color']]], + ['push_48',['push',['../classegoa_1_1_priority_queue.html#a368f3b8f030ce038447daa031f3c924e',1,'egoa::PriorityQueue::Push()'],['../classegoa_1_1_queue.html#ad9a6293663c6167cd3b831d6511e458b',1,'egoa::Queue::Push()'],['../classegoa_1_1_std_queue.html#a2d5726740c3a7bc0e1cba7e824cb30da',1,'egoa::StdQueue::Push()']]], + ['pushnextblock_49',['PushNextBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#acba2cff6ea5a6daca0a8ec43c318054e',1,'egoa::internal::BlockCutTreeBuilder']]], + ['pypsaparser_50',['PyPsaParser',['../classegoa_1_1_py_psa_parser.html',1,'egoa']]] +]; diff --git a/search/classes_0.js b/search/classes_0.js new file mode 100644 index 00000000..9549780a --- /dev/null +++ b/search/classes_0.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['articulationvertexdetection_0',['ArticulationVertexDetection',['../classegoa_1_1_articulation_vertex_detection.html',1,'egoa']]], + ['articulationvertexdetection_3c_20graphtype_2c_20false_20_3e_1',['ArticulationVertexDetection< GraphType, false >',['../classegoa_1_1_articulation_vertex_detection.html',1,'egoa']]] +]; diff --git a/search/classes_1.js b/search/classes_1.js new file mode 100644 index 00000000..61bbada9 --- /dev/null +++ b/search/classes_1.js @@ -0,0 +1,31 @@ +var searchData= +[ + ['betweennesscentrality_0',['BetweennessCentrality',['../classegoa_1_1_betweenness_centrality.html',1,'egoa']]], + ['bfs_1',['BFS',['../classegoa_1_1_b_f_s.html',1,'egoa']]], + ['binaryheap_2',['BinaryHeap',['../classegoa_1_1_binary_heap.html',1,'egoa']]], + ['binaryheap_3c_20voltageangledifferencelabel_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_20_3e_20_3e_3',['BinaryHeap< VoltageAngleDifferenceLabel< Edges::Edge< Edges::ElectricalProperties > > >',['../classegoa_1_1_binary_heap.html',1,'egoa']]], + ['binaryheapcheck_4',['BinaryHeapCheck',['../classegoa_1_1internal_1_1_binary_heap_check.html',1,'egoa::internal']]], + ['binaryheapcheck_3c_20type_2c_20false_20_3e_5',['BinaryHeapCheck< Type, false >',['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html',1,'egoa::internal']]], + ['binaryheapcheck_3c_20type_2c_20true_20_3e_6',['BinaryHeapCheck< Type, true >',['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_7',['BinaryHeapLoopDifferentiation',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_20const_2c_20executionpolicy_3a_3abreakable_20_3e_8',['BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_20const_2c_20executionpolicy_3a_3asequential_20_3e_9',['BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3abreakable_20_3e_10',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3aparallel_20_3e_11',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['binaryheaploopdifferentiation_3c_20heaptype_2c_20executionpolicy_3a_3asequential_20_3e_12',['BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['block_13',['Block',['../classegoa_1_1_block_cut_tree_1_1_block.html',1,'egoa::BlockCutTree']]], + ['blockcuttree_14',['BlockCutTree',['../classegoa_1_1_block_cut_tree.html',1,'egoa']]], + ['blockcuttree_3c_20tgraph_20_3e_15',['BlockCutTree< TGraph >',['../classegoa_1_1_block_cut_tree.html',1,'egoa']]], + ['blockcuttreebuilder_16',['BlockCutTreeBuilder',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html',1,'egoa::internal']]], + ['blockcuttreetraversal_17',['BlockCutTreeTraversal',['../classegoa_1_1_block_cut_tree_traversal.html',1,'egoa']]], + ['blockunderconstruction_18',['BlockUnderConstruction',['../structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction.html',1,'egoa::internal::BlockCutTreeBuilder']]], + ['bound_19',['Bound',['../classegoa_1_1_bound.html',1,'egoa']]], + ['bound_3c_20types_3a_3areal_20_3e_20',['Bound< Types::real >',['../classegoa_1_1_bound.html',1,'egoa']]], + ['boundmismatch_21',['BoundMismatch',['../classegoa_1_1_bound_mismatch.html',1,'egoa']]], + ['bucket_22',['Bucket',['../classegoa_1_1_bucket.html',1,'egoa']]], + ['bucketelement_23',['BucketElement',['../classegoa_1_1_bucket_element.html',1,'egoa']]], + ['bucketloopdifferentiation_24',['BucketLoopDifferentiation',['../classegoa_1_1internal_1_1_bucket_loop_differentiation.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3abreakable_20_3e_25',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3aparallel_20_3e_26',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['bucketloopdifferentiation_3c_20buckettype_2c_20executionpolicy_3a_3asequential_20_3e_27',['BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]] +]; diff --git a/search/classes_10.js b/search/classes_10.js new file mode 100644 index 00000000..79d70bd9 --- /dev/null +++ b/search/classes_10.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['timer_0',['Timer',['../classegoa_1_1_auxiliary_1_1_timer.html',1,'egoa::Auxiliary']]], + ['traversal_1',['Traversal',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['traversal_3c_20false_20_3e_2',['Traversal< false >',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['traversal_3c_20graphtype_2c_20false_20_3e_3',['Traversal< GraphType, false >',['../classegoa_1_1_traversal.html',1,'egoa']]], + ['traversal_3c_20graphtype_2c_20isdirected_20_3e_4',['Traversal< GraphType, IsDirected >',['../classegoa_1_1_traversal.html',1,'egoa']]] +]; diff --git a/search/classes_11.js b/search/classes_11.js new file mode 100644 index 00000000..890fcae6 --- /dev/null +++ b/search/classes_11.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['unionfind_0',['UnionFind',['../classegoa_1_1_union_find.html',1,'egoa']]] +]; diff --git a/search/classes_12.js b/search/classes_12.js new file mode 100644 index 00000000..bf099aa0 --- /dev/null +++ b/search/classes_12.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['vectorbasedcomparator_0',['VectorBasedComparator',['../classegoa_1_1_vector_based_comparator.html',1,'egoa']]], + ['vectorview_1',['VectorView',['../classegoa_1_1_vector_view.html',1,'egoa']]], + ['vertex_2',['Vertex',['../classegoa_1_1_vertices_1_1_vertex.html',1,'egoa::Vertices']]], + ['voltageangledifferencelabel_3',['VoltageAngleDifferenceLabel',['../classegoa_1_1_voltage_angle_difference_label.html',1,'egoa']]] +]; diff --git a/search/classes_2.js b/search/classes_2.js new file mode 100644 index 00000000..53902dbf --- /dev/null +++ b/search/classes_2.js @@ -0,0 +1,14 @@ +var searchData= +[ + ['callbackempty_0',['CallbackEmpty',['../classegoa_1_1_callback_empty.html',1,'egoa']]], + ['carrierdifferentiation_1',['CarrierDifferentiation',['../classegoa_1_1_edges_1_1_carrier_differentiation.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3aac_20_3e_2',['CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3adc_20_3e_3',['CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html',1,'egoa::Edges']]], + ['carrierdifferentiation_3c_20edges_3a_3acarrierdifferentiationtype_3a_3aunknown_20_3e_4',['CarrierDifferentiation< Edges::CarrierDifferentiationType::unknown >',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1unknown_01_4.html',1,'egoa::Edges']]], + ['color_5',['Color',['../classegoa_1_1_color.html',1,'egoa']]], + ['containerloop_6',['ContainerLoop',['../structegoa_1_1internal_1_1_container_loop.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3abreakable_20_3e_7',['ContainerLoop< ExecutionPolicy::breakable >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3aparallel_20_3e_8',['ContainerLoop< ExecutionPolicy::parallel >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['containerloop_3c_20executionpolicy_3a_3asequential_20_3e_9',['ContainerLoop< ExecutionPolicy::sequential >',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['cutvertex_10',['CutVertex',['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html',1,'egoa::BlockCutTree']]] +]; diff --git a/search/classes_3.js b/search/classes_3.js new file mode 100644 index 00000000..d34d209c --- /dev/null +++ b/search/classes_3.js @@ -0,0 +1,17 @@ +var searchData= +[ + ['depthfirstsearch_0',['DepthFirstSearch',['../classegoa_1_1_depth_first_search.html',1,'egoa']]], + ['depthfirstsearch_3c_20graphtype_2c_20false_20_3e_1',['DepthFirstSearch< GraphType, false >',['../classegoa_1_1_depth_first_search.html',1,'egoa']]], + ['depthfirstsearch_3c_20graphtype_2c_20isdirected_20_3e_2',['DepthFirstSearch< GraphType, IsDirected >',['../classegoa_1_1_depth_first_search.html',1,'egoa']]], + ['dominatingthetapath_3',['DominatingThetaPath',['../classegoa_1_1_dominating_theta_path.html',1,'egoa']]], + ['dominationdifferentiation_4',['DominationDifferentiation',['../classegoa_1_1internal_1_1_domination_differentiation.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3anone_20_3e_5',['DominationDifferentiation< ElementType, DominationCriterion::none >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1none_01_4.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3astrict_20_3e_6',['DominationDifferentiation< ElementType, DominationCriterion::strict >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1strict_01_4.html',1,'egoa::internal']]], + ['dominationdifferentiation_3c_20elementtype_2c_20dominationcriterion_3a_3aweak_20_3e_7',['DominationDifferentiation< ElementType, DominationCriterion::weak >',['../classegoa_1_1internal_1_1_domination_differentiation_3_01_element_type_00_01_domination_criterion_1_1weak_01_4.html',1,'egoa::internal']]], + ['dtpruntimecollection_8',['DtpRuntimeCollection',['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html',1,'egoa::IO']]], + ['dtpruntimerow_9',['DtpRuntimeRow',['../classegoa_1_1_i_o_1_1_dtp_runtime_row.html',1,'egoa::IO']]], + ['dynamicgraph_10',['DynamicGraph',['../classegoa_1_1_dynamic_graph.html',1,'egoa']]], + ['dynamicgraphloopdifferentiation_11',['DynamicGraphLoopDifferentiation',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html',1,'egoa::internal']]], + ['dynamicgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_12',['DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['dynamicgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_13',['DynamicGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_dynamic_graph_loop_differentiation.html',1,'egoa::internal']]] +]; diff --git a/search/classes_4.js b/search/classes_4.js new file mode 100644 index 00000000..9cbdde8e --- /dev/null +++ b/search/classes_4.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['edge_0',['edge',['../classegoa_1_1_edges_1_1_edge.html',1,'egoa::Edges::Edge< PropertiesType >'],['../classegoa_1_1io_1_1_edge.html',1,'egoa::io::Edge< PropertiesType >']]], + ['electricalproperties_1',['electricalproperties',['../classegoa_1_1_edges_1_1_electrical_properties.html',1,'egoa::Edges::ElectricalProperties'],['../classegoa_1_1_vertices_1_1_electrical_properties.html',1,'egoa::Vertices::ElectricalProperties< VertexType >']]] +]; diff --git a/search/classes_5.js b/search/classes_5.js new file mode 100644 index 00000000..f95e23a0 --- /dev/null +++ b/search/classes_5.js @@ -0,0 +1,15 @@ +var searchData= +[ + ['generationstrategydifferentiation_0',['GenerationStrategyDifferentiation',['../classegoa_1_1internal_1_1_generation_strategy_differentiation.html',1,'egoa::internal']]], + ['generationstrategydifferentiation_3c_20networktype_2c_20vertices_3a_3agenerationstrategydifferentiationtype_3a_3atotalvertexpowergenerationpersnapshot_20_3e_1',['GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >',['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html',1,'egoa::internal']]], + ['generatorproperties_2',['GeneratorProperties',['../classegoa_1_1_vertices_1_1_generator_properties.html',1,'egoa::Vertices']]], + ['geojsonwriter_3',['GeoJsonWriter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html',1,'egoa::IO']]], + ['graphloopdifferentiation_4',['GraphLoopDifferentiation',['../classegoa_1_1internal_1_1_graph_loop_differentiation.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3abreakable_20_3e_5',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_6',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['graphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_7',['GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_8',['GraphTypeLoopDifferentiation',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_3c_20graphtype_2c_20false_20_3e_9',['GraphTypeLoopDifferentiation< GraphType, false >',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01false_01_4.html',1,'egoa::internal']]], + ['graphtypeloopdifferentiation_3c_20graphtype_2c_20true_20_3e_10',['GraphTypeLoopDifferentiation< GraphType, true >',['../classegoa_1_1internal_1_1_graph_type_loop_differentiation_3_01_graph_type_00_01true_01_4.html',1,'egoa::internal']]], + ['gurobisolver_11',['GurobiSolver',['../classegoa_1_1_gurobi_solver.html',1,'egoa']]] +]; diff --git a/search/classes_6.js b/search/classes_6.js new file mode 100644 index 00000000..63909245 --- /dev/null +++ b/search/classes_6.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['heapiterator_0',['HeapIterator',['../classegoa_1_1_binary_heap_1_1_heap_iterator.html',1,'egoa::BinaryHeap']]] +]; diff --git a/search/classes_7.js b/search/classes_7.js new file mode 100644 index 00000000..2857af1f --- /dev/null +++ b/search/classes_7.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['ieeecdfmatlabparser_0',['IeeeCdfMatlabParser',['../classegoa_1_1_ieee_cdf_matlab_parser.html',1,'egoa']]] +]; diff --git a/search/classes_8.js b/search/classes_8.js new file mode 100644 index 00000000..7178ddfa --- /dev/null +++ b/search/classes_8.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['kruskal_0',['Kruskal',['../classegoa_1_1_kruskal.html',1,'egoa']]] +]; diff --git a/search/classes_9.js b/search/classes_9.js new file mode 100644 index 00000000..1e1f3b2e --- /dev/null +++ b/search/classes_9.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['label_0',['Label',['../classegoa_1_1_label.html',1,'egoa']]], + ['label_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_2c_20std_3a_3aunordered_5fset_3c_20types_3a_3avertexid_20_3e_2c_20types_3a_3avertexid_20_3e_1',['Label< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId >',['../classegoa_1_1_label.html',1,'egoa']]], + ['loadproperties_2',['LoadProperties',['../classegoa_1_1_vertices_1_1_load_properties.html',1,'egoa::Vertices']]] +]; diff --git a/search/classes_a.js b/search/classes_a.js new file mode 100644 index 00000000..b441da73 --- /dev/null +++ b/search/classes_a.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['mappingbinaryheap_0',['MappingBinaryHeap',['../classegoa_1_1_mapping_binary_heap.html',1,'egoa']]], + ['mappingbinaryheap_3c_20typename_20graphtype_3a_3atvertexid_2c_20voltageangledifferencelabel_3c_20typename_20graphtype_3a_3atedge_20_3e_20_3e_1',['MappingBinaryHeap< typename GraphType::TVertexId, VoltageAngleDifferenceLabel< typename GraphType::TEdge > >',['../classegoa_1_1_mapping_binary_heap.html',1,'egoa']]], + ['matchpathseparator_2',['MatchPathSeparator',['../structegoa_1_1_auxiliary_1_1_match_path_separator.html',1,'egoa::Auxiliary']]], + ['mst_3',['MST',['../classegoa_1_1_m_s_t.html',1,'egoa']]] +]; diff --git a/search/classes_b.js b/search/classes_b.js new file mode 100644 index 00000000..06a12ac5 --- /dev/null +++ b/search/classes_b.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['networkdifferentiation_0',['NetworkDifferentiation',['../classegoa_1_1internal_1_1_network_differentiation.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20egoa_3a_3avertices_3a_3aelectricalproperties_3c_20egoa_3a_3avertices_3a_3aieeebustype_20_3e_2c_20egoa_3a_3aedges_3a_3aelectricalproperties_2c_20staticgraph_3c_20egoa_3a_3avertices_3a_3aelectricalproperties_3c_20egoa_3a_3avertices_3a_3aieeebustype_20_3e_2c_20egoa_3a_3aedges_3a_3aelectricalproperties_20_3e_20_3e_1',['NetworkDifferentiation< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties, StaticGraph< egoa::Vertices::ElectricalProperties< egoa::Vertices::IeeeBusType >, egoa::Edges::ElectricalProperties > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01egoa_1_1_vertices_1_1_electrical_propertie25fdcdc3c845cdb06c6c2944360d5752.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20vertextypeproperties_2c_20edgetypeproperties_2c_20powergrid_3c_20staticgraph_3c_20vertextypeproperties_2c_20edgetypeproperties_20_3e_2c_20vertices_3a_3ageneratorproperties_3c_3e_2c_20vertices_3a_3aloadproperties_3c_20vertices_3a_3aieeebustype_20_3e_20_3e_20_3e_2',['NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, PowerGrid< StaticGraph< VertexTypeProperties, EdgeTypeProperties >, Vertices::GeneratorProperties<>, Vertices::LoadProperties< Vertices::IeeeBusType > > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr95fa1fc366e5b030b1043055b1ebef80.html',1,'egoa::internal']]], + ['networkdifferentiation_3c_20vertextypeproperties_2c_20edgetypeproperties_2c_20staticgraph_3c_20vertextypeproperties_2c_20edgetypeproperties_20_3e_20_3e_3',['NetworkDifferentiation< VertexTypeProperties, EdgeTypeProperties, StaticGraph< VertexTypeProperties, EdgeTypeProperties > >',['../classegoa_1_1internal_1_1_network_differentiation_3_01_vertex_type_properties_00_01_edge_type_pr828ec4fd22b4d3b547d9914b4f2478c6.html',1,'egoa::internal']]] +]; diff --git a/search/classes_c.js b/search/classes_c.js new file mode 100644 index 00000000..5a7043c6 --- /dev/null +++ b/search/classes_c.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['omittingiterator_0',['OmittingIterator',['../classegoa_1_1_omitting_iterator.html',1,'egoa']]], + ['omittingvectorview_1',['OmittingVectorView',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html',1,'egoa::DynamicGraph']]] +]; diff --git a/search/classes_d.js b/search/classes_d.js new file mode 100644 index 00000000..016dcfa1 --- /dev/null +++ b/search/classes_d.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['powergrid_0',['PowerGrid',['../classegoa_1_1_power_grid.html',1,'egoa']]], + ['powergridio_1',['PowerGridIO',['../classegoa_1_1_power_grid_i_o.html',1,'egoa']]], + ['powergridloopdifferentiation_2',['PowerGridLoopDifferentiation',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3abreakable_20_3e_3',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3aparallel_20_3e_4',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['powergridloopdifferentiation_3c_20powergridtype_2c_20executionpolicy_3a_3asequential_20_3e_5',['PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['prim_6',['Prim',['../classegoa_1_1_prim.html',1,'egoa']]], + ['priorityqueue_7',['PriorityQueue',['../classegoa_1_1_priority_queue.html',1,'egoa']]], + ['pypsaparser_8',['PyPsaParser',['../classegoa_1_1_py_psa_parser.html',1,'egoa']]] +]; diff --git a/search/classes_e.js b/search/classes_e.js new file mode 100644 index 00000000..477bf87e --- /dev/null +++ b/search/classes_e.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['queue_0',['Queue',['../classegoa_1_1_queue.html',1,'egoa']]] +]; diff --git a/search/classes_f.js b/search/classes_f.js new file mode 100644 index 00000000..cf5f43ea --- /dev/null +++ b/search/classes_f.js @@ -0,0 +1,19 @@ +var searchData= +[ + ['solverruntimecollection_0',['SolverRuntimeCollection',['../classegoa_1_1_i_o_1_1_solver_runtime_collection.html',1,'egoa::IO']]], + ['solverruntimerow_1',['SolverRuntimeRow',['../structegoa_1_1_i_o_1_1_solver_runtime_row.html',1,'egoa::IO']]], + ['staticgraph_2',['StaticGraph',['../classegoa_1_1_static_graph.html',1,'egoa']]], + ['staticgraph_3c_20vertices_3a_3aelectricalproperties_3c_20vertices_3a_3aieeebustype_20_3e_2c_20edges_3a_3aelectricalproperties_20_3e_3',['StaticGraph< Vertices::ElectricalProperties< Vertices::IeeeBusType >, Edges::ElectricalProperties >',['../classegoa_1_1_static_graph.html',1,'egoa']]], + ['staticgraphloopdifferentiation_4',['StaticGraphLoopDifferentiation',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3abreakable_20_3e_5',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3aparallel_20_3e_6',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::parallel >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1parallel_01_4.html',1,'egoa::internal']]], + ['staticgraphloopdifferentiation_3c_20graphtype_2c_20executionpolicy_3a_3asequential_20_3e_7',['StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html',1,'egoa::internal']]], + ['stdqueue_8',['StdQueue',['../classegoa_1_1_std_queue.html',1,'egoa']]], + ['stdqueue_3c_20graphtype_3a_3atvertexid_20_3e_9',['StdQueue< GraphType::TVertexId >',['../classegoa_1_1_std_queue.html',1,'egoa']]], + ['stroke_10',['Stroke',['../classegoa_1_1_stroke.html',1,'egoa']]], + ['subgraph_11',['Subgraph',['../classegoa_1_1_subgraph.html',1,'egoa']]], + ['subgraph_3c_20tgraph_20_3e_12',['Subgraph< TGraph >',['../classegoa_1_1_subgraph.html',1,'egoa']]], + ['subgraph_3c_20tgraph_20const_20_3e_13',['Subgraph< TGraph const >',['../classegoa_1_1_subgraph.html',1,'egoa']]], + ['susceptancenormlabel_14',['SusceptanceNormLabel',['../classegoa_1_1_susceptance_norm_label.html',1,'egoa']]], + ['susceptancenormlabel_3c_20edges_3a_3aedge_3c_20edges_3a_3aelectricalproperties_20_3e_2c_20std_3a_3aunordered_5fset_3c_20types_3a_3avertexid_20_3e_2c_20types_3a_3avertexid_20_3e_15',['SusceptanceNormLabel< Edges::Edge< Edges::ElectricalProperties >, std::unordered_set< Types::vertexId >, Types::vertexId >',['../classegoa_1_1_susceptance_norm_label.html',1,'egoa']]] +]; diff --git a/search/close.svg b/search/close.svg new file mode 100644 index 00000000..337d6cc1 --- /dev/null +++ b/search/close.svg @@ -0,0 +1,18 @@ + + + + + + diff --git a/search/enums_0.js b/search/enums_0.js new file mode 100644 index 00000000..8ef77862 --- /dev/null +++ b/search/enums_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['dominationcriterion_0',['DominationCriterion',['../namespaceegoa.html#a8139eea6466926933882a4a21a929b52',1,'egoa']]] +]; diff --git a/search/enums_1.js b/search/enums_1.js new file mode 100644 index 00000000..f9209aac --- /dev/null +++ b/search/enums_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['executionpolicy_0',['ExecutionPolicy',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369',1,'egoa']]] +]; diff --git a/search/enums_2.js b/search/enums_2.js new file mode 100644 index 00000000..289bba39 --- /dev/null +++ b/search/enums_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['name_0',['Name',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_0.js b/search/enumvalues_0.js new file mode 100644 index 00000000..cc7bcc11 --- /dev/null +++ b/search/enumvalues_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['breakable_0',['breakable',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a29ec0ca77cfb897451dceae1cde2e9e8',1,'egoa']]] +]; diff --git a/search/enumvalues_1.js b/search/enumvalues_1.js new file mode 100644 index 00000000..15026c5c --- /dev/null +++ b/search/enumvalues_1.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['goldenrod_0',['Goldenrod',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acf193ee60d2856bcefc85bdbc245ff66',1,'egoa::Color']]], + ['gray_1',['Gray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a994ae1d9731cebe455aff211bcb25b93',1,'egoa::Color']]], + ['green_2',['Green',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad382816a3cbeed082c9e216e7392eed1',1,'egoa::Color']]], + ['greenyellow_3',['Greenyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aaa7193f0b831d1a5246e2cd87a07302c',1,'egoa::Color']]], + ['grey_4',['Grey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acaf3a042a037c064b7513ed640c22f77',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_2.js b/search/enumvalues_2.js new file mode 100644 index 00000000..c2e57a07 --- /dev/null +++ b/search/enumvalues_2.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['honeydew_0',['Honeydew',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4702a340a91866eea3143f6c1c735ef4',1,'egoa::Color']]], + ['hotpink_1',['Hotpink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93cc23e594200f6388cdf73208bc5c1c',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_3.js b/search/enumvalues_3.js new file mode 100644 index 00000000..c8d47437 --- /dev/null +++ b/search/enumvalues_3.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['indianred_0',['Indianred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6f2351a92fe2e42de9bdb2b1e6756d78',1,'egoa::Color']]], + ['indigo_1',['Indigo',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8b7b9806e715b01b9021912e0f86935f',1,'egoa::Color']]], + ['ivory_2',['Ivory',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5aea7cdf0f3349ac62a04335ec1c918d',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_4.js b/search/enumvalues_4.js new file mode 100644 index 00000000..f974b3cd --- /dev/null +++ b/search/enumvalues_4.js @@ -0,0 +1,89 @@ +var searchData= +[ + ['khaki_0',['Khaki',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7ec23b405c5319f55b7660569c077f41',1,'egoa::Color']]], + ['kitblack_1',['KITblack',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad04b42146d64f8f9bee8fe38567da67d',1,'egoa::Color']]], + ['kitblack01_2',['KITblack01',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af985f7b747fb5936da8e34e605f643a4',1,'egoa::Color']]], + ['kitblack02_3',['KITblack02',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93867309e7749d4825e54d9a0852806f',1,'egoa::Color']]], + ['kitblack03_4',['KITblack03',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac1a2ba5b298bfd21ec69f68af374e925',1,'egoa::Color']]], + ['kitblack04_5',['KITblack04',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a78c99dcdb6a72f9b8d86c38577171371',1,'egoa::Color']]], + ['kitblack05_6',['KITblack05',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a136ae6b2863f310cc7c1cfc9bd0d9c86',1,'egoa::Color']]], + ['kitblack06_7',['KITblack06',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae8a714111b23985d37fbee2784ac62d8',1,'egoa::Color']]], + ['kitblack07_8',['KITblack07',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a49031707a6690face30ae1f2c062bc66',1,'egoa::Color']]], + ['kitblack08_9',['KITblack08',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5fd5854de12c6b9853df10fbcc840958',1,'egoa::Color']]], + ['kitblack09_10',['KITblack09',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a04f67e44fd17062295b40a9ea0ba76a2',1,'egoa::Color']]], + ['kitblack10_11',['KITblack10',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1aa7fdbe1029a4eb0667ca036139746c',1,'egoa::Color']]], + ['kitblack11_12',['KITblack11',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac61ab4a1c093e4c854473f3aab38e507',1,'egoa::Color']]], + ['kitblack12_13',['KITblack12',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab60514a42a41f81fdbe788f281cf4c27',1,'egoa::Color']]], + ['kitblack13_14',['KITblack13',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aafbfd093bd346084a084d0165e95382b',1,'egoa::Color']]], + ['kitblack14_15',['KITblack14',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a30613fdb8310681ac8c2acd51a14b44d',1,'egoa::Color']]], + ['kitblack15_16',['KITblack15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acb3b1b190885775dc3c92dfc142bb0ab',1,'egoa::Color']]], + ['kitblack16_17',['KITblack16',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a28db8035bc28c8f918d676144988305e',1,'egoa::Color']]], + ['kitblack17_18',['KITblack17',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeecf337d540ebbd78c219ffbe43fb807',1,'egoa::Color']]], + ['kitblack18_19',['KITblack18',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac54b0f3a9fab3d025d51e7baa5d89b43',1,'egoa::Color']]], + ['kitblack19_20',['KITblack19',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3d596a45c78f186cc0c2ed9fc36704fa',1,'egoa::Color']]], + ['kitblack20_21',['KITblack20',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6f7eb731aab9631f6a6dabf902336437',1,'egoa::Color']]], + ['kitblack21_22',['KITblack21',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad28fe8d7aea9e7b232b61c69f9911b85',1,'egoa::Color']]], + ['kitblack22_23',['KITblack22',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4245a285af0ebe48d4e80740dccce3e4',1,'egoa::Color']]], + ['kitblack23_24',['KITblack23',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a87719299eb02858ad2b80a9284eb4fac',1,'egoa::Color']]], + ['kitblack24_25',['KITblack24',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0a769699e389c260d5d7766c656bdaa5',1,'egoa::Color']]], + ['kitblack25_26',['KITblack25',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1ad5d41d82af1def77b10fd92eece25f',1,'egoa::Color']]], + ['kitblack26_27',['KITblack26',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab817b6c508fcc330adde327419837bb5',1,'egoa::Color']]], + ['kitblack27_28',['KITblack27',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a67b786a7b286409cdbc68a56869bb63a',1,'egoa::Color']]], + ['kitblack28_29',['KITblack28',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae1dba20dc03c75b333500c3b1dedd198',1,'egoa::Color']]], + ['kitblack29_30',['KITblack29',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a11503e43ff3fa847db22c073f9dbc54e',1,'egoa::Color']]], + ['kitblack30_31',['KITblack30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac1c253f4da13687459426ce7f4599ffb',1,'egoa::Color']]], + ['kitblack31_32',['KITblack31',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aff4f6637d4fc4498b39e86c77edee401',1,'egoa::Color']]], + ['kitblack32_33',['KITblack32',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a73ee9cebbd782850a6acde95e0743ece',1,'egoa::Color']]], + ['kitblack50_34',['KITblack50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a777b1ebb50d01395ad15a7a2a9ca5586',1,'egoa::Color']]], + ['kitblack70_35',['KITblack70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a432452009a0fcd6f552861d8ea91f806',1,'egoa::Color']]], + ['kitblue_36',['KITblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a39f7cc9510d0e1be760ef5988a231aa1',1,'egoa::Color']]], + ['kitblue15_37',['KITblue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a63a7589152e02f4e3979ab9cfe97cb69',1,'egoa::Color']]], + ['kitblue30_38',['KITblue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aff4c82c0db801dfa22730e480cd4db1a',1,'egoa::Color']]], + ['kitblue50_39',['KITblue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93485c08064a61c413be46d9323a4053',1,'egoa::Color']]], + ['kitblue70_40',['KITblue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a63ba97f52bb8817c7273f8581aa48ff8',1,'egoa::Color']]], + ['kitbrown_41',['KITbrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0323d4e649ec14a16e8759b5342e95c1',1,'egoa::Color']]], + ['kitbrown15_42',['KITbrown15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba1633bdd789db72558bed1eaeeb8a5c',1,'egoa::Color']]], + ['kitbrown30_43',['KITbrown30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6d16c19e273ba22bbec544602a8914d3',1,'egoa::Color']]], + ['kitbrown50_44',['KITbrown50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5b20653d34b2b29659d482f087b6242f',1,'egoa::Color']]], + ['kitbrown70_45',['KITbrown70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a27063de98f067ec5b8ab82a427be4253',1,'egoa::Color']]], + ['kitcyanblue_46',['KITcyanblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad002abd1fce7b721637e3043b5b5f8b0',1,'egoa::Color']]], + ['kitcyanblue15_47',['KITcyanblue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7f3476c90c9453f60bc1c24722174961',1,'egoa::Color']]], + ['kitcyanblue30_48',['KITcyanblue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8610b95d45ed022728870d7db8abf2ee',1,'egoa::Color']]], + ['kitcyanblue50_49',['KITcyanblue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a36c31c707e7184576fc8a23662bf17fb',1,'egoa::Color']]], + ['kitcyanblue70_50',['KITcyanblue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7f0a1b587eec0d4e5576e790ee655ca9',1,'egoa::Color']]], + ['kitgreen_51',['KITgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a971d2cefb5f4717e7ec36dc008c01400',1,'egoa::Color']]], + ['kitgreen15_52',['KITgreen15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2f5ec06e71ce648205da1990e2ef81ec',1,'egoa::Color']]], + ['kitgreen30_53',['KITgreen30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aadca5eecaad051ef4e89f95381323572',1,'egoa::Color']]], + ['kitgreen50_54',['KITgreen50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adbfaa143f52f20258b02d65bf8415d19',1,'egoa::Color']]], + ['kitgreen70_55',['KITgreen70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab537e8c7d24e1a39302f596df9fb7ca9',1,'egoa::Color']]], + ['kitlilac_56',['KITlilac',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8fbc3ee3f98bc568c916db2e826f2ed9',1,'egoa::Color']]], + ['kitlilac15_57',['KITlilac15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a40027b7487b1291459494fc82a2fdae8',1,'egoa::Color']]], + ['kitlilac30_58',['KITlilac30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af8ea2ce999a0bfa0dccefe48f589972e',1,'egoa::Color']]], + ['kitlilac50_59',['KITlilac50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a80ad706c0a273ea98b56fe0d4c78ff5f',1,'egoa::Color']]], + ['kitlilac70_60',['KITlilac70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8660b35b948522dca4b311948d59bf7f',1,'egoa::Color']]], + ['kitorange_61',['KITorange',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac3685734294a38e23826a95a6ea6d03a',1,'egoa::Color']]], + ['kitorange15_62',['KITorange15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2eb0eb1e621e02b2cbd8faac80f4b552',1,'egoa::Color']]], + ['kitorange30_63',['KITorange30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae46961ef3db5d59c0aaa82d09131c356',1,'egoa::Color']]], + ['kitorange50_64',['KITorange50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac401f81efc16f69158fa49f288f2154e',1,'egoa::Color']]], + ['kitorange70_65',['KITorange70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d038565ca5e9bfacada419aa4e66218',1,'egoa::Color']]], + ['kitpalegreen_66',['KITpalegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8ea75cbe6ed3255db1a14b984b3f6035',1,'egoa::Color']]], + ['kitpalegreen15_67',['KITpalegreen15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adf3e0a36228370fd5c5bf5cc6bd75c48',1,'egoa::Color']]], + ['kitpalegreen30_68',['KITpalegreen30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09afae9ad56751f3c4ea20a2c79086610c2',1,'egoa::Color']]], + ['kitpalegreen50_69',['KITpalegreen50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2fd5f0aa1e5c14ee64948c9e4602a28b',1,'egoa::Color']]], + ['kitpalegreen70_70',['KITpalegreen70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad8023cfc76f017e60a9362f759b73b1e',1,'egoa::Color']]], + ['kitred_71',['KITred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acbdf6daeecce29e65cb750b24c9618c7',1,'egoa::Color']]], + ['kitred15_72',['KITred15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a34864ec6752719138e7df5a5e4915d6a',1,'egoa::Color']]], + ['kitred30_73',['KITred30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4ad7f140fee3fdac9fddb09a0f7bcb72',1,'egoa::Color']]], + ['kitred50_74',['KITred50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09abea49d949ed01e2212f06f68780629f8',1,'egoa::Color']]], + ['kitred70_75',['KITred70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5774875a0619e6d0047ce8204743cc58',1,'egoa::Color']]], + ['kitseablue_76',['KITseablue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2f8ad8ee518b58c8e17fc15cd0679a7d',1,'egoa::Color']]], + ['kitseablue15_77',['KITseablue15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a938f1c09b5a3bfbdb737a103a9c6c9f7',1,'egoa::Color']]], + ['kitseablue30_78',['KITseablue30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a56501b05496e60dd3cb2278de641693a',1,'egoa::Color']]], + ['kitseablue50_79',['KITseablue50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad6994772bddd017701a302b6ce973e65',1,'egoa::Color']]], + ['kitseablue70_80',['KITseablue70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d76fe3f4f70294348ad6018396e5f9f',1,'egoa::Color']]], + ['kityellow_81',['KITyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5d0ecdc2ed050d8ff49ab80743c36ec1',1,'egoa::Color']]], + ['kityellow15_82',['KITyellow15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d0a9e15b8251a5c5e43cf668205d9c9',1,'egoa::Color']]], + ['kityellow30_83',['KITyellow30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1548dbd2985e6369bdcc182a319570be',1,'egoa::Color']]], + ['kityellow50_84',['KITyellow50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4f1518f3d4fe71977697859d837b18ba',1,'egoa::Color']]], + ['kityellow70_85',['KITyellow70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa954f43ae60e07c61ba62c6a51b490a1',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_5.js b/search/enumvalues_5.js new file mode 100644 index 00000000..d8d1e2cc --- /dev/null +++ b/search/enumvalues_5.js @@ -0,0 +1,25 @@ +var searchData= +[ + ['lavender_0',['Lavender',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae346c232ce72c429ea0995de9f63f551',1,'egoa::Color']]], + ['lavenderblush_1',['Lavenderblush',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2608628d9926a877f5557354f4c16e9f',1,'egoa::Color']]], + ['lawngreen_2',['Lawngreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3d6c544640f5a8a459cdc6f10f90dabb',1,'egoa::Color']]], + ['lemonchiffon_3',['Lemonchiffon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5c651ed90facf4bb7ddc64a4e466cad7',1,'egoa::Color']]], + ['lightblue_4',['Lightblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeee4484ffe23236009ba4b3fc5b3b260',1,'egoa::Color']]], + ['lightcoral_5',['Lightcoral',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae854b167e568a8a8b0702ba72243efd6',1,'egoa::Color']]], + ['lightcyan_6',['Lightcyan',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5bb982b0c73416b14789c4ec00bcf201',1,'egoa::Color']]], + ['lightgoldenrodyellow_7',['Lightgoldenrodyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad7e2c8f55498c8bb1afc0919b4538d43',1,'egoa::Color']]], + ['lightgray_8',['Lightgray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af732b1b8bbfac23a09f44ac8760d155b',1,'egoa::Color']]], + ['lightgreen_9',['Lightgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4f5de044d10c971c68f5a6ca9e003944',1,'egoa::Color']]], + ['lightgrey_10',['Lightgrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba443ab182c66fef799b62d244028dde',1,'egoa::Color']]], + ['lightpink_11',['Lightpink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aba5b3bbbccecc93032475b74a422c5ef',1,'egoa::Color']]], + ['lightsalmon_12',['Lightsalmon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5957441ec1336b5798202d47c4b1edc1',1,'egoa::Color']]], + ['lightseagreen_13',['Lightseagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a838adfb6f15a1d6e6e34d8bdf4780f23',1,'egoa::Color']]], + ['lightskyblue_14',['Lightskyblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adfae21840c461b684ef9033f7fee8cb0',1,'egoa::Color']]], + ['lightslategray_15',['Lightslategray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4d43c707907df664518e6891bb5d7458',1,'egoa::Color']]], + ['lightslategrey_16',['Lightslategrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a91cc4dd99e26947eee42dd8f0cd18a1f',1,'egoa::Color']]], + ['lightsteelblue_17',['Lightsteelblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1d624025be2093c781e92d19cadfa0c4',1,'egoa::Color']]], + ['lightyellow_18',['Lightyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acb3655bfd6e7b23c65240a365d2e5f74',1,'egoa::Color']]], + ['lime_19',['Lime',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09afc1cebf02dc2ee68655f3e7bf1b84230',1,'egoa::Color']]], + ['limegreen_20',['Limegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a034debfe19e91356b49ed1180537d9ce',1,'egoa::Color']]], + ['linen_21',['Linen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5ab518fc894c7438e44d9a035c2e970e',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_6.js b/search/enumvalues_6.js new file mode 100644 index 00000000..53d4b7dc --- /dev/null +++ b/search/enumvalues_6.js @@ -0,0 +1,18 @@ +var searchData= +[ + ['magenta_0',['Magenta',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab91cc2c1416fcca942b61c7ac5b1a9ac',1,'egoa::Color']]], + ['maroon_1',['Maroon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad87fa7a1a056e269cdd6e102e507a822',1,'egoa::Color']]], + ['mediumaquamarine_2',['Mediumaquamarine',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8adf61272b6c122106de50b7aeb449b8',1,'egoa::Color']]], + ['mediumblue_3',['Mediumblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4937b59cfe9d1be959ec69ffa328a590',1,'egoa::Color']]], + ['mediumorchid_4',['Mediumorchid',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a580a0007fa751cfe2fb0b15d17cd279d',1,'egoa::Color']]], + ['mediumpurple_5',['Mediumpurple',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa746a8190ddfdd1430e73536c1a8a137',1,'egoa::Color']]], + ['mediumseagreen_6',['Mediumseagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a49003468fce2917e93d941e3429c7897',1,'egoa::Color']]], + ['mediumslateblue_7',['Mediumslateblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a039cdc30f12b86b5015f0c8e11d4a1c8',1,'egoa::Color']]], + ['mediumspringgreen_8',['Mediumspringgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a9f52ca0ac460318c34520983fb0c8508',1,'egoa::Color']]], + ['mediumturquoise_9',['Mediumturquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a02db6e1da1059eb2fed387dc6ca80d7a',1,'egoa::Color']]], + ['mediumvioletred_10',['Mediumvioletred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a59f20c7f92e51acbb32dec421fc3095e',1,'egoa::Color']]], + ['midnightblue_11',['Midnightblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a920401d908962a4ce5bd177cc482e53d',1,'egoa::Color']]], + ['mintcream_12',['Mintcream',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09acd821bc185401547f07cc6af8e94be10',1,'egoa::Color']]], + ['mistyrose_13',['Mistyrose',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a6903df0c8f5530f30aae1db466f650ce',1,'egoa::Color']]], + ['moccasin_14',['Moccasin',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3764027d5d248d8e346a5951e9264338',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_7.js b/search/enumvalues_7.js new file mode 100644 index 00000000..11f24f17 --- /dev/null +++ b/search/enumvalues_7.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['navajowhite_0',['Navajowhite',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a971fa79bebff1cf4c43dd837ef0fe80f',1,'egoa::Color']]], + ['navy_1',['Navy',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a13ad5ac690e735fa48cf982532174e79',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_8.js b/search/enumvalues_8.js new file mode 100644 index 00000000..a85024d1 --- /dev/null +++ b/search/enumvalues_8.js @@ -0,0 +1,9 @@ +var searchData= +[ + ['oldlace_0',['Oldlace',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4431c944bbf8d821ac35f49de336bc96',1,'egoa::Color']]], + ['olive_1',['Olive',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a2b8b384cdd92d3e81c43b2d43de8c247',1,'egoa::Color']]], + ['olivedrab_2',['Olivedrab',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa88205173f829b308604a4578842de30',1,'egoa::Color']]], + ['orange_3',['Orange',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a909cea0c97058cfe2e3ea8d675cb08e1',1,'egoa::Color']]], + ['orangered_4',['Orangered',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a9f9a24f2c44edc91083fd1f03ebbbaaa',1,'egoa::Color']]], + ['orchid_5',['Orchid',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0474ae22bec123c6a616d6a757c9fce0',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_9.js b/search/enumvalues_9.js new file mode 100644 index 00000000..65d5d98a --- /dev/null +++ b/search/enumvalues_9.js @@ -0,0 +1,15 @@ +var searchData= +[ + ['palegoldenrod_0',['Palegoldenrod',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a530cb76dd794405902c9d20f716e645a',1,'egoa::Color']]], + ['palegreen_1',['Palegreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af005435518cdbc041fd486c8d5267f5a',1,'egoa::Color']]], + ['paleturquoise_2',['Paleturquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af0579e21eaed558089b5c43a32821217',1,'egoa::Color']]], + ['palevioletred_3',['Palevioletred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a356d0f2e545365efaf5868285deac49a',1,'egoa::Color']]], + ['papayawhip_4',['Papayawhip',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a18c28e06a92a4d121da46dee1023cad7',1,'egoa::Color']]], + ['parallel_5',['parallel',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a48920c071f6a5c97ae3739be64630697',1,'egoa']]], + ['peachpuff_6',['Peachpuff',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09abb2ac4541cb992d295d5df676692fa78',1,'egoa::Color']]], + ['peru_7',['Peru',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a84c8fa2341f7d052a1ee3a36ff043798',1,'egoa::Color']]], + ['pink_8',['Pink',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8dc5344bc0746e1cc5abf896ca03bbdf',1,'egoa::Color']]], + ['plum_9',['Plum',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a93df2c41a9abe4a797371f5c761adbfe',1,'egoa::Color']]], + ['powderblue_10',['Powderblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a50e023a045ecd1dd1f6d249b065ae7a8',1,'egoa::Color']]], + ['purple_11',['Purple',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab9ba865fec061c9706d2fd7ce49c0cc7',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_a.js b/search/enumvalues_a.js new file mode 100644 index 00000000..9572fa7d --- /dev/null +++ b/search/enumvalues_a.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['red_0',['Red',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aee38e4d5dd68c4e440825018d549cb47',1,'egoa::Color']]], + ['rosybrown_1',['Rosybrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3eedcd0326719e4f934807a6b85c8fb0',1,'egoa::Color']]], + ['royalblue_2',['Royalblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aeb4caa9c7ef309310a5b00acbba3324b',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_b.js b/search/enumvalues_b.js new file mode 100644 index 00000000..a580d0e0 --- /dev/null +++ b/search/enumvalues_b.js @@ -0,0 +1,18 @@ +var searchData= +[ + ['saddlebrown_0',['Saddlebrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1141cab5c534a37e23dd7f5f3ac853ed',1,'egoa::Color']]], + ['salmon_1',['Salmon',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae30d211c66fe9025efb79b79e4244fd0',1,'egoa::Color']]], + ['sandybrown_2',['Sandybrown',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8e3623c1a82fb0036faa1f51cd7b2b16',1,'egoa::Color']]], + ['seagreen_3',['Seagreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa34ce0ea9d774680ddf2d32af085cd14',1,'egoa::Color']]], + ['seashell_4',['Seashell',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ad3027eff8d2b1e45c8357151581d6a2d',1,'egoa::Color']]], + ['sequential_5',['sequential',['../namespaceegoa.html#af2970c6dff9c629d37997c1cc7cab369a6ec7489017b25b5fff20d353b6d2162e',1,'egoa']]], + ['sienna_6',['Sienna',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3bfd0cce8e9cda754a5b78d85be622ed',1,'egoa::Color']]], + ['silver_7',['Silver',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af96e345fdc19cbd4cf15256c251a39a0',1,'egoa::Color']]], + ['skyblue_8',['Skyblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a7138173edd0fee059ebc0ab05b8c5009',1,'egoa::Color']]], + ['slateblue_9',['Slateblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab82f8bfdc1b9e5917139b05522a5550e',1,'egoa::Color']]], + ['slategray_10',['Slategray',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab73e0c558d263b98e856248b3f211135',1,'egoa::Color']]], + ['slategrey_11',['Slategrey',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09af2ea39d82a9de82be1eb49bfee258272',1,'egoa::Color']]], + ['snow_12',['Snow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab46d3c8ee8032551c011745d587705cc',1,'egoa::Color']]], + ['springgreen_13',['Springgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a53f5b0070628492f9dd44e3094012eca',1,'egoa::Color']]], + ['steelblue_14',['Steelblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a79691ec0a05553d1cb46f94e538232de',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_c.js b/search/enumvalues_c.js new file mode 100644 index 00000000..e0d7b287 --- /dev/null +++ b/search/enumvalues_c.js @@ -0,0 +1,30 @@ +var searchData= +[ + ['tan_0',['Tan',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1266b4e6f81e60733ec6c717e0181f60',1,'egoa::Color']]], + ['teal_1',['Teal',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ae20385a2b41df1743f787ebef18222b8',1,'egoa::Color']]], + ['thesisblack_2',['THESISblack',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5e6b63c7024130fcb63c4b4489fde631',1,'egoa::Color']]], + ['thesisblack15_3',['THESISblack15',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a52d090d7833129c47b2f6d847d7e3a06',1,'egoa::Color']]], + ['thesisblack30_4',['THESISblack30',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a97246c55afd5d6dfecbfd74caa8b49a6',1,'egoa::Color']]], + ['thesisblack50_5',['THESISblack50',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a92e03351157d9213614fa82dc9fcd171',1,'egoa::Color']]], + ['thesisblack7_6',['THESISblack7',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0af2bf5b95916636ece52b9d26b4ed6f',1,'egoa::Color']]], + ['thesisblack70_7',['THESISblack70',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a985fc47c9f35651101d04deda6cf4092',1,'egoa::Color']]], + ['thesisblue_8',['THESISblue',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a4b13fd198900aaebc1bff85222a2701b',1,'egoa::Color']]], + ['thesisblue_5fdark_9',['THESISblue_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a98735aaa15b8677b72f9d9275fb19f33',1,'egoa::Color']]], + ['thesisblue_5flight_10',['THESISblue_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a0a0cfae62dad21bc2d094aca19b9fdc6',1,'egoa::Color']]], + ['thesisblue_5fvlight_11',['THESISblue_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a580c4fecb9d67729c1a9957ead03fefd',1,'egoa::Color']]], + ['thesisgreen_12',['THESISgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5668553cc9266629dea6f15650c08e8d',1,'egoa::Color']]], + ['thesisgreen_5fdark_13',['THESISgreen_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1fca7973cc2907b86178687947ab7cba',1,'egoa::Color']]], + ['thesisgreen_5flight_14',['THESISgreen_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab26aee35a786c150ba7610327d504aa5',1,'egoa::Color']]], + ['thesisgreen_5fvlight_15',['THESISgreen_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09aa51ecf4c00d73f4366ab82632b10ea56',1,'egoa::Color']]], + ['thesisred_16',['THESISred',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1fa454490e6a131d18344d53123b0ad3',1,'egoa::Color']]], + ['thesisred_5fdark_17',['THESISred_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a3bab1b783ed772bd518e5f4e3fc45391',1,'egoa::Color']]], + ['thesisred_5flight_18',['THESISred_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09adf0acb483bda17df346fc313e441d4db',1,'egoa::Color']]], + ['thesisred_5fvlight_19',['THESISred_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a5eab00519bded83b195131a77a0afb58',1,'egoa::Color']]], + ['thesisyellow_20',['THESISyellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a8a3c2a48ba29ad1ea8d88f7abdd78487',1,'egoa::Color']]], + ['thesisyellow_5fdark_21',['THESISyellow_dark',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a655a20860d84d45d794f0c86f8cd9191',1,'egoa::Color']]], + ['thesisyellow_5flight_22',['THESISyellow_light',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ab481b26ff40776f83160152a20553a05',1,'egoa::Color']]], + ['thesisyellow_5fvlight_23',['THESISyellow_vlight',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ac177ff56d4f83243cdf29a78ae2be3aa',1,'egoa::Color']]], + ['thistle_24',['Thistle',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a58849bbd6b4fb8844f01c2ebf7e59c36',1,'egoa::Color']]], + ['tomato_25',['Tomato',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a77bd79b3dca1f49815655b6f2df760ba',1,'egoa::Color']]], + ['turquoise_26',['Turquoise',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09ada3a4f0a911cebe3bc75f6e39c324696',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_d.js b/search/enumvalues_d.js new file mode 100644 index 00000000..1c946d02 --- /dev/null +++ b/search/enumvalues_d.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['violet_0',['Violet',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a80f1187112e2e5e0403499147f7014b8',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_e.js b/search/enumvalues_e.js new file mode 100644 index 00000000..4a163317 --- /dev/null +++ b/search/enumvalues_e.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['wheat_0',['Wheat',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a966d953817980d045a3538d3b8bbb468',1,'egoa::Color']]], + ['white_1',['White',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a25a81701fbfa4a1efdf660a950c1d006',1,'egoa::Color']]], + ['whitesmoke_2',['Whitesmoke',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a1377f5800ab28508ba00345281d1313c',1,'egoa::Color']]] +]; diff --git a/search/enumvalues_f.js b/search/enumvalues_f.js new file mode 100644 index 00000000..e15c546a --- /dev/null +++ b/search/enumvalues_f.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['yellow_0',['Yellow',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a51e6cd92b6c45f9affdc158ecca2b8b8',1,'egoa::Color']]], + ['yellowgreen_1',['Yellowgreen',['../classegoa_1_1_color.html#a58adc570c1f8d4d158fa43786522dd09a35f693dc6a5bbd4ba7a55ee26c591b3c',1,'egoa::Color']]] +]; diff --git a/search/functions_0.js b/search/functions_0.js new file mode 100644 index 00000000..61d85e66 --- /dev/null +++ b/search/functions_0.js @@ -0,0 +1,111 @@ +var searchData= +[ + ['addbusname_0',['AddBusName',['../classegoa_1_1_py_psa_parser.html#a3445016279bc2b5d0139e6e6a3af31d7',1,'egoa::PyPsaParser']]], + ['addbustypetovertexproperty_1',['AddBusTypeToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a267b6c68d44045136157fc575bb8e9e4',1,'egoa::PyPsaParser']]], + ['addcapitalcosttoedge_2',['AddCapitalCostToEdge',['../classegoa_1_1_py_psa_parser.html#a8a3ab49107b8ac190e2dc8098645ee53',1,'egoa::PyPsaParser']]], + ['addcapitalcosttogenerator_3',['AddCapitalCostToGenerator',['../classegoa_1_1_py_psa_parser.html#af3b8f72c1af8b46de2e2b0ed0f03e4c7',1,'egoa::PyPsaParser']]], + ['addcarriertogenerator_4',['AddCarrierToGenerator',['../classegoa_1_1_py_psa_parser.html#a89eef36bf9edca65b06ea02e523d3538',1,'egoa::PyPsaParser']]], + ['addcarriertovertexproperty_5',['AddCarrierToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a5a3d4c37488ede00304bf274cca4bde5',1,'egoa::PyPsaParser']]], + ['addcommittabilitytogenerator_6',['AddCommittabilityToGenerator',['../classegoa_1_1_py_psa_parser.html#a5959ade2e11c2968eb8ac1c25fba8139',1,'egoa::PyPsaParser']]], + ['addconductanceputoedge_7',['AddConductancePuToEdge',['../classegoa_1_1_py_psa_parser.html#adf9f3ae85d25a714155930753e3db4cf',1,'egoa::PyPsaParser']]], + ['addconductancetoedge_8',['AddConductanceToEdge',['../classegoa_1_1_py_psa_parser.html#af933482c7f2b6bcb702438bef55914ca',1,'egoa::PyPsaParser']]], + ['addcontroltypetogenerator_9',['AddControlTypeToGenerator',['../classegoa_1_1_py_psa_parser.html#a5f75742ec279b9cb8d35abeb0bb39401',1,'egoa::PyPsaParser']]], + ['addcontroltypetovertexproperty_10',['AddControlTypeToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a9fca664987df8bf47cdbf82e4ca373f7',1,'egoa::PyPsaParser']]], + ['addcountrytovertexproperty_11',['AddCountryToVertexProperty',['../classegoa_1_1_py_psa_parser.html#adffe09c74ce9767c0fa01193d9bee719',1,'egoa::PyPsaParser']]], + ['addedge_12',['addedge',['../classegoa_1_1_dynamic_graph.html#adabca8848d02cae2543fdb670dda8704',1,'egoa::DynamicGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &properties)'],['../classegoa_1_1_dynamic_graph.html#a5435904379c51b02d70aa860aa6b92f5',1,'egoa::DynamicGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)'],['../classegoa_1_1_dynamic_graph.html#a6d8011dbc01c7a4b165c2e9f4106128e',1,'egoa::DynamicGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)'],['../classegoa_1_1_static_graph.html#ab11e90bbb1a1ecb5150f6d9c6c952eb5',1,'egoa::StaticGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties const &properties)'],['../classegoa_1_1_static_graph.html#af526a9476c1329be5b972fd0df7cf16f',1,'egoa::StaticGraph::AddEdge(Types::vertexId source, Types::vertexId target, TEdgeProperties &&properties)'],['../classegoa_1_1_py_psa_parser.html#af4e9ee451975f96d88c9ed78fb794581',1,'egoa::PyPsaParser::AddEdge()']]], + ['addedgetocurrentblock_13',['AddEdgeToCurrentBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#af65e7c2bfd5561fd25f1fc02fc0faa78',1,'egoa::internal::BlockCutTreeBuilder']]], + ['addeffectivereactanceputoedge_14',['AddEffectiveReactancePuToEdge',['../classegoa_1_1_py_psa_parser.html#ae552905f45d584bbda5b32df6a5fe965',1,'egoa::PyPsaParser']]], + ['addeffectiveresistanceputoedge_15',['AddEffectiveResistancePuToEdge',['../classegoa_1_1_py_psa_parser.html#abad2b2546156ff3d1c381df68ca4bfd2',1,'egoa::PyPsaParser']]], + ['addgeneratorat_16',['addgeneratorat',['../classegoa_1_1_power_grid.html#af4f06ba244cb4a872d90358547151435',1,'egoa::PowerGrid::AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties const &generatorProperty)'],['../classegoa_1_1_power_grid.html#afd5f83de414a797957b7a23af63d0c9b',1,'egoa::PowerGrid::AddGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &&generatorProperty)'],['../classegoa_1_1_power_grid.html#add1dda403c34d4716e7a009d48032d20',1,'egoa::PowerGrid::AddGeneratorAt(TVertex const &vertex, TGeneratorProperties const &generatorProperty)'],['../classegoa_1_1_power_grid.html#ab8e76feffea66ff5bddbf04e95115637',1,'egoa::PowerGrid::AddGeneratorAt(TVertex const &vertex, TGeneratorProperties &&generatorProperty)']]], + ['addgeneratorefficiencytogenerator_17',['AddGeneratorEfficiencyToGenerator',['../classegoa_1_1_py_psa_parser.html#a27e5608532759d924c50e51f0acbbe6e',1,'egoa::PyPsaParser']]], + ['addgeneratorrealpowersnapshotat_18',['AddGeneratorRealPowerSnapshotAt',['../classegoa_1_1_power_grid.html#a5ccae8fc77cb3e2499cb6d38b8920ab1',1,'egoa::PowerGrid']]], + ['addgeneratorsigntogenerator_19',['AddGeneratorSignToGenerator',['../classegoa_1_1_py_psa_parser.html#a500bbb72a57cf596507cc9aa5be8d435',1,'egoa::PyPsaParser']]], + ['addinitialstatustogenerator_20',['AddInitialStatusToGenerator',['../classegoa_1_1_py_psa_parser.html#a55f213f4f4ff15d3719cec888e8b606f',1,'egoa::PyPsaParser']]], + ['addlengthtoedge_21',['AddLengthToEdge',['../classegoa_1_1_py_psa_parser.html#ad1146569450485e0d914f2768db623a1',1,'egoa::PyPsaParser']]], + ['addlinetypetoedge_22',['AddLineTypeToEdge',['../classegoa_1_1_py_psa_parser.html#a5ae1fccec5f6144151c0af1e17690512',1,'egoa::PyPsaParser']]], + ['addloadat_23',['addloadat',['../classegoa_1_1_power_grid.html#ad2a4a48ed221fc2e0b29a4b51470ebaf',1,'egoa::PowerGrid::AddLoadAt(TVertex const &vertex, TLoadProperties &&load)'],['../classegoa_1_1_power_grid.html#ab8c968ca493b8ae790ebd2a37ccbe1d5',1,'egoa::PowerGrid::AddLoadAt(Types::vertexId vertexId, TLoadProperties load)'],['../classegoa_1_1_power_grid.html#abc5e24c98548509f9c4d704dcb212646',1,'egoa::PowerGrid::AddLoadAt(TVertex const &vertex, TLoadProperties const &load)']]], + ['addloadsnapshotat_24',['AddLoadSnapshotAt',['../classegoa_1_1_power_grid.html#ab7430a1550c051dea28013b52dfe2ba5',1,'egoa::PowerGrid']]], + ['addloadtimestampname_25',['AddLoadTimestampName',['../classegoa_1_1_py_psa_parser.html#a4cf1c63e979e2b34d3ddf8747d6189f0',1,'egoa::PyPsaParser']]], + ['addmarginalcosttogenerator_26',['AddMarginalCostToGenerator',['../classegoa_1_1_py_psa_parser.html#aaf663ec9428365d50be86ee96186316f',1,'egoa::PyPsaParser']]], + ['addmarginalpricetovertexproperty_27',['AddMarginalPriceToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a1f2c18588d754ec9a35fc62cbd687515',1,'egoa::PyPsaParser']]], + ['addmaximalnominalapparentpowertoedge_28',['AddMaximalNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a3af9200e6a2cbe47c5db559d9eafe9a5',1,'egoa::PyPsaParser']]], + ['addmaximumapparentpowerputoedge_29',['AddMaximumApparentPowerPuToEdge',['../classegoa_1_1_py_psa_parser.html#ac61ba5042bf0ed39be8ed6cc083f74c8',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowerputogenerator_30',['AddMaximumRealPowerPuToGenerator',['../classegoa_1_1_py_psa_parser.html#abbf462aaafc602afdd096f50a40df63d',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowersnapshotputogenerator_31',['AddMaximumRealPowerSnapshotPuToGenerator',['../classegoa_1_1_py_psa_parser.html#ab4fa84d0c2103dfff6db038b6ba02d56',1,'egoa::PyPsaParser']]], + ['addmaximumrealpowersnapshotputoload_32',['AddMaximumRealPowerSnapshotPuToLoad',['../classegoa_1_1_py_psa_parser.html#ae74d4506eb14af74aa9684dc6539e436',1,'egoa::PyPsaParser']]], + ['addmaximumvoltageangletoedge_33',['AddMaximumVoltageAngleToEdge',['../classegoa_1_1_py_psa_parser.html#a0029747b2df51dc934d72b431a579d8a',1,'egoa::PyPsaParser']]], + ['addmaximumvoltagemagnitudeputovertexproperty_34',['AddMaximumVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a95aeb7455ea5567fcfcede5b8c77e76f',1,'egoa::PyPsaParser']]], + ['addminimumdowntimetogenerator_35',['AddMinimumDownTimeToGenerator',['../classegoa_1_1_py_psa_parser.html#a59636265bf2177685bf40d9ad8b7d8ac',1,'egoa::PyPsaParser']]], + ['addminimumnominalapparentpowertoedge_36',['AddMinimumNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a328bbbf60111118f39182052d8012af2',1,'egoa::PyPsaParser']]], + ['addminimumrealpowerputogenerator_37',['AddMinimumRealPowerPuToGenerator',['../classegoa_1_1_py_psa_parser.html#a78461a34d2f35f0d1614e7e248896dc6',1,'egoa::PyPsaParser']]], + ['addminimumuptimetogenerator_38',['AddMinimumUpTimeToGenerator',['../classegoa_1_1_py_psa_parser.html#a9ca5064ef4d41c25650275fd87d3c921',1,'egoa::PyPsaParser']]], + ['addminimumvoltageangletoedge_39',['AddMinimumVoltageAngleToEdge',['../classegoa_1_1_py_psa_parser.html#ac13bd228023a22570721e72aff72643e',1,'egoa::PyPsaParser']]], + ['addminimumvoltagemagnitudeputovertexproperty_40',['AddMinimumVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#aa6c6b530808a2adbfac8c3c0a00ae722',1,'egoa::PyPsaParser']]], + ['addmulowertoedge_41',['AddMuLowerToEdge',['../classegoa_1_1_py_psa_parser.html#a00aa91dd90ee03f156f7b8e507bc0d42',1,'egoa::PyPsaParser']]], + ['addmuuppertoedge_42',['AddMuUpperToEdge',['../classegoa_1_1_py_psa_parser.html#a7adf777fefad31730ada3227475cb598',1,'egoa::PyPsaParser']]], + ['addnametoedge_43',['AddNameToEdge',['../classegoa_1_1_py_psa_parser.html#acb81c15c7f1babff4f76cddc194c4b20',1,'egoa::PyPsaParser']]], + ['addnametogenerator_44',['AddNameToGenerator',['../classegoa_1_1_py_psa_parser.html#a654232a8589378058746994983876c6c',1,'egoa::PyPsaParser']]], + ['addnametoload_45',['AddNameToLoad',['../classegoa_1_1_py_psa_parser.html#a6200d5d2384df18d859fe14d7715641e',1,'egoa::PyPsaParser']]], + ['addnominalapparentpowertoedge_46',['AddNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a3749f6dcbc1a6eb0327857541da8ba3b',1,'egoa::PyPsaParser']]], + ['addnominalextendableapparentpowertoedge_47',['AddNominalExtendableApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#ac9e2fedfdd421ceac8586b4b111d5e6b',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogenerator_48',['AddNominalRealPowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a528d9a8b071397539c0eaff65a23dbe6',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratorextendable_49',['AddNominalRealPowerToGeneratorExtendable',['../classegoa_1_1_py_psa_parser.html#ae85ae02a32544fe4e92317ed1e6b857b',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratormax_50',['AddNominalRealPowerToGeneratorMax',['../classegoa_1_1_py_psa_parser.html#ad696d7c972812e61bcf5db4560156105',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratormin_51',['AddNominalRealPowerToGeneratorMin',['../classegoa_1_1_py_psa_parser.html#a6affd1ff402423f3478853eb0713ff79',1,'egoa::PyPsaParser']]], + ['addnominalrealpowertogeneratoropt_52',['AddNominalRealPowerToGeneratorOpt',['../classegoa_1_1_py_psa_parser.html#a1bea8fa187445da489d2ce3839d47e0e',1,'egoa::PyPsaParser']]], + ['addnominalvoltagetoedge_53',['AddNominalVoltageToEdge',['../classegoa_1_1_py_psa_parser.html#a5b7bb16c8d32386e26e6584674558e3f',1,'egoa::PyPsaParser']]], + ['addnominalvoltagetovertexproperty_54',['AddNominalVoltageToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a75ae9723dbf9cb5cbc1462699e79bfba',1,'egoa::PyPsaParser']]], + ['addnumberofparallellinestoedge_55',['AddNumberOfParallelLinesToEdge',['../classegoa_1_1_py_psa_parser.html#aee9c0e8ea3779a38f18fe9f21feca1cd',1,'egoa::PyPsaParser']]], + ['addoptimalnominalapparentpowertoedge_56',['AddOptimalNominalApparentPowerToEdge',['../classegoa_1_1_py_psa_parser.html#a7f5db2c7f17b7cb20a60800e48e53bb4',1,'egoa::PyPsaParser']]], + ['addp0toedge_57',['AddP0ToEdge',['../classegoa_1_1_py_psa_parser.html#a49a2fce6db4f4b8e537bc6e80ff43e40',1,'egoa::PyPsaParser']]], + ['addp1toedge_58',['AddP1ToEdge',['../classegoa_1_1_py_psa_parser.html#ae7be1c269bfd4f3bb57b7f8b05202def',1,'egoa::PyPsaParser']]], + ['addq0toedge_59',['AddQ0ToEdge',['../classegoa_1_1_py_psa_parser.html#a5698989ef63c2f0134228e0a3a368c3f',1,'egoa::PyPsaParser']]], + ['addq1toedge_60',['AddQ1ToEdge',['../classegoa_1_1_py_psa_parser.html#a9a73cd4e3263564fb0f7b41dba8e19b4',1,'egoa::PyPsaParser']]], + ['addramplimitdowntogenerator_61',['AddRampLimitDownToGenerator',['../classegoa_1_1_py_psa_parser.html#aa6bc287a8d396d4966a4cf63e8a78137',1,'egoa::PyPsaParser']]], + ['addramplimitshutdowntogenerator_62',['AddRampLimitShutDownToGenerator',['../classegoa_1_1_py_psa_parser.html#a2447ed28cc087517ba5146cd88c73d80',1,'egoa::PyPsaParser']]], + ['addramplimitstartuptogenerator_63',['AddRampLimitStartUpToGenerator',['../classegoa_1_1_py_psa_parser.html#aa7f182b89cabce6fd56c00ddc85e8f01',1,'egoa::PyPsaParser']]], + ['addramplimituptogenerator_64',['AddRampLimitUpToGenerator',['../classegoa_1_1_py_psa_parser.html#a467aa671e02046c19b58abe7668c02b0',1,'egoa::PyPsaParser']]], + ['addreactanceputoedge_65',['AddReactancePuToEdge',['../classegoa_1_1_py_psa_parser.html#a75b3a79b14f82449457b91153a9af4a6',1,'egoa::PyPsaParser']]], + ['addreactancetoedge_66',['AddReactanceToEdge',['../classegoa_1_1_py_psa_parser.html#a92f246728777b798029405d570755f82',1,'egoa::PyPsaParser']]], + ['addreactivepowersetpointtogenerator_67',['AddReactivePowerSetPointToGenerator',['../classegoa_1_1_py_psa_parser.html#a3a320502f9aa2ca1498638ef4710636f',1,'egoa::PyPsaParser']]], + ['addreactivepowersetpointtoload_68',['AddReactivePowerSetPointToLoad',['../classegoa_1_1_py_psa_parser.html#a9d396a453ab25b94d4339f1ae5281c2e',1,'egoa::PyPsaParser']]], + ['addreactivepowertogenerator_69',['AddReactivePowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a554183d1c3dda989bfc7385b4fa11481',1,'egoa::PyPsaParser']]], + ['addreactivepowertoload_70',['AddReactivePowerToLoad',['../classegoa_1_1_py_psa_parser.html#ab7ef70610a7ca8570176955102d87e48',1,'egoa::PyPsaParser']]], + ['addreactivepowertovertexproperty_71',['AddReactivePowerToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a49918356dff806452257bfeaabfdcde3',1,'egoa::PyPsaParser']]], + ['addrealpowersetpointtogenerator_72',['AddRealPowerSetPointToGenerator',['../classegoa_1_1_py_psa_parser.html#a6ff64b521042388bd26aa89c061626f1',1,'egoa::PyPsaParser']]], + ['addrealpowersetpointtoload_73',['AddRealPowerSetPointToLoad',['../classegoa_1_1_py_psa_parser.html#aff8fdf549c004d8fd0819f5ad16593f8',1,'egoa::PyPsaParser']]], + ['addrealpowertogenerator_74',['AddRealPowerToGenerator',['../classegoa_1_1_py_psa_parser.html#a1eecef897a21752551db7c8d8a1d7e9e',1,'egoa::PyPsaParser']]], + ['addrealpowertoload_75',['AddRealPowerToLoad',['../classegoa_1_1_py_psa_parser.html#a15e28022605aa4bdfa0432d2978d2594',1,'egoa::PyPsaParser']]], + ['addrealpowertovertexproperty_76',['AddRealPowerToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a0f06ef0fd22dbd0b5e9447053220c209',1,'egoa::PyPsaParser']]], + ['addresistanceputoedge_77',['AddResistancePuToEdge',['../classegoa_1_1_py_psa_parser.html#afd773348d59e2b09a7e35b28ecb07d36',1,'egoa::PyPsaParser']]], + ['addresistancetoedge_78',['AddResistanceToEdge',['../classegoa_1_1_py_psa_parser.html#aefd7779c64c8efb97949c56a4fcc2549',1,'egoa::PyPsaParser']]], + ['addshutdowncosttogenerator_79',['AddShutDownCostToGenerator',['../classegoa_1_1_py_psa_parser.html#a33ef74f205ebb6ce472be63878ce2e00',1,'egoa::PyPsaParser']]], + ['addsigntoload_80',['AddSignToLoad',['../classegoa_1_1_py_psa_parser.html#aab6985a24f772074a7e5d13dc0281695',1,'egoa::PyPsaParser']]], + ['addsnapshottimestamp_81',['AddSnapshotTimestamp',['../classegoa_1_1_power_grid.html#aac315c4caad0e761a489d33aae8945ae',1,'egoa::PowerGrid']]], + ['addsnapshotweighting_82',['AddSnapshotWeighting',['../classegoa_1_1_power_grid.html#ad82909d39614c8a4421a662267928a3b',1,'egoa::PowerGrid']]], + ['addsourcevertextoedge_83',['AddSourceVertexToEdge',['../classegoa_1_1_py_psa_parser.html#a8f5f01567a2f2e8db338b15d52f07cc2',1,'egoa::PyPsaParser']]], + ['addstartupcosttogenerator_84',['AddStartUpCostToGenerator',['../classegoa_1_1_py_psa_parser.html#a27211926b5e9be1b0be1713a4052f333',1,'egoa::PyPsaParser']]], + ['addstatustogenerator_85',['AddStatusToGenerator',['../classegoa_1_1_py_psa_parser.html#a1d7b852dd0d6a202ce32f78b31486e32',1,'egoa::PyPsaParser']]], + ['addsubnetworktoedge_86',['AddSubnetworkToEdge',['../classegoa_1_1_py_psa_parser.html#a0011a70723b8c8bcd65add93545a9f3f',1,'egoa::PyPsaParser']]], + ['addsubnetworktovertexproperty_87',['AddSubnetworkToVertexProperty',['../classegoa_1_1_py_psa_parser.html#abf059d71bb8543b0f06a995d9f758c63',1,'egoa::PyPsaParser']]], + ['addsusceptanceputoedge_88',['AddSusceptancePuToEdge',['../classegoa_1_1_py_psa_parser.html#a9a43a85bbdeb4cd756a64df4eaa9fa57',1,'egoa::PyPsaParser']]], + ['addsusceptancetoedge_89',['AddSusceptanceToEdge',['../classegoa_1_1_py_psa_parser.html#ad0001244f15f85e4f9d1716470f2db28',1,'egoa::PyPsaParser']]], + ['addtargetvertextoedge_90',['AddTargetVertexToEdge',['../classegoa_1_1_py_psa_parser.html#ab09280ee3271fa5ddc1990b4b8a939b0',1,'egoa::PyPsaParser']]], + ['addterrainfactortoedge_91',['AddTerrainFactorToEdge',['../classegoa_1_1_py_psa_parser.html#a858468364914a03e1efd793e1873e670',1,'egoa::PyPsaParser']]], + ['addtimestampofgenerator_92',['AddTimestampOfGenerator',['../classegoa_1_1_py_psa_parser.html#a3c8df9c7f7f81217165e8b55c248e412',1,'egoa::PyPsaParser']]], + ['addtypetogenerator_93',['AddTypeToGenerator',['../classegoa_1_1_py_psa_parser.html#aa8b3363a453ee05b1b8ca65de0f98be4',1,'egoa::PyPsaParser']]], + ['addtypetoload_94',['AddTypeToLoad',['../classegoa_1_1_py_psa_parser.html#abc00a92a8db93792260d690657e599c1',1,'egoa::PyPsaParser']]], + ['addvertex_95',['addvertex',['../classegoa_1_1_dynamic_graph.html#af2fcdca888289c2aaa9a90ef506a33e5',1,'egoa::DynamicGraph::AddVertex(TVertexProperties &properties)'],['../classegoa_1_1_dynamic_graph.html#a95407d696b80b5bdf06170b6d37b3994',1,'egoa::DynamicGraph::AddVertex(TVertexProperties const &properties)'],['../classegoa_1_1_dynamic_graph.html#a6c86a1e253d1df5abbafa919f51bdbfc',1,'egoa::DynamicGraph::AddVertex(TVertexProperties &&properties)'],['../classegoa_1_1_static_graph.html#ad480d6a773c928c2c93f292ec5352b26',1,'egoa::StaticGraph::AddVertex(TVertexProperties const &properties)'],['../classegoa_1_1_static_graph.html#af3ef46db810c3affbf125b6bebe28f42',1,'egoa::StaticGraph::AddVertex(TVertexProperties &&properties)'],['../classegoa_1_1_py_psa_parser.html#aafc76b33a5ddd9fd3cef2ab36e33a5b7',1,'egoa::PyPsaParser::AddVertex()']]], + ['addvertextocurrentblock_96',['AddVertexToCurrentBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#af4df260da8c36657f63907cc84bd24c8',1,'egoa::internal::BlockCutTreeBuilder']]], + ['addvoltageangletovertexproperty_97',['AddVoltageAngleToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a8a4a373d318646adefb51d0d19e125c3',1,'egoa::PyPsaParser']]], + ['addvoltagemagnitudepusetpointtovertexproperty_98',['AddVoltageMagnitudePuSetPointToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a7750d668c3d227d5dd84f6b3905b4d1a',1,'egoa::PyPsaParser']]], + ['addvoltagemagnitudeputovertexproperty_99',['AddVoltageMagnitudePuToVertexProperty',['../classegoa_1_1_py_psa_parser.html#a33ba1ef1e1ed48b166a1427c94abd9c7',1,'egoa::PyPsaParser']]], + ['addweighttogenerator_100',['AddWeightToGenerator',['../classegoa_1_1_py_psa_parser.html#a8ee58d638aca31409e5221ac34eba752',1,'egoa::PyPsaParser']]], + ['addxcoordinatetovertexproperty_101',['AddXcoordinateToVertexProperty',['../classegoa_1_1_py_psa_parser.html#abb7c70692c13dd42eab7e81568ba4588',1,'egoa::PyPsaParser']]], + ['addycoordinatetovertexproperty_102',['AddYcoordinateToVertexProperty',['../classegoa_1_1_py_psa_parser.html#ab6306a46c3512737760c87ad60a85dea',1,'egoa::PyPsaParser']]], + ['algorithm_103',['algorithm',['../classegoa_1_1_betweenness_centrality.html#aeaababaccedb091ec99c3374a3c023f0',1,'egoa::BetweennessCentrality::Algorithm()'],['../classegoa_1_1_betweenness_centrality.html#a3a786cdf4fd7f3ec530eb6754e125d08',1,'egoa::BetweennessCentrality::Algorithm() const']]], + ['apf_104',['apf',['../classegoa_1_1_vertices_1_1_generator_properties.html#a42ec385b8d1dd14bf270fa64862c715b',1,'egoa::Vertices::GeneratorProperties::Apf() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2b6a862388168431cd64652cb51f1a7b',1,'egoa::Vertices::GeneratorProperties::Apf()']]], + ['area_105',['area',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4b8b9a433956953145d67bab0969ef5d',1,'egoa::Vertices::ElectricalProperties::Area() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a1aa339af06301ec17619b525689adf3b',1,'egoa::Vertices::ElectricalProperties::Area()']]], + ['associategeneratorwithbus_106',['AssociateGeneratorWithBus',['../classegoa_1_1_py_psa_parser.html#a7459411be4145d39566609a33daef74f',1,'egoa::PyPsaParser']]], + ['associateloadwithvertex_107',['AssociateLoadWithVertex',['../classegoa_1_1_py_psa_parser.html#a66ae1ccdb5f5c017f65424e734c549b6',1,'egoa::PyPsaParser']]] +]; diff --git a/search/functions_1.js b/search/functions_1.js new file mode 100644 index 00000000..f981872e --- /dev/null +++ b/search/functions_1.js @@ -0,0 +1,22 @@ +var searchData= +[ + ['back_0',['back',['../classegoa_1_1_binary_heap.html#a7147b7725db2104890631797df129d21',1,'egoa::BinaryHeap::Back() const'],['../classegoa_1_1_binary_heap.html#af4e3c696496fdce5f9083fbfa227e080',1,'egoa::BinaryHeap::Back()']]], + ['basemva_1',['basemva',['../classegoa_1_1_power_grid.html#acd2fd791ef9c602d0641cd64d21fed75',1,'egoa::PowerGrid::BaseMva() const'],['../classegoa_1_1_power_grid.html#adf506f99b8484ade676d5fccf391ed85',1,'egoa::PowerGrid::BaseMva()']]], + ['begin_2',['begin',['../classegoa_1_1_binary_heap.html#a41608cd5b4174c68dfa0724a829580a5',1,'egoa::BinaryHeap']]], + ['betweennesscentrality_3',['BetweennessCentrality',['../classegoa_1_1_betweenness_centrality.html#a219fa47c10a5c4b753869a2380ac1c62',1,'egoa::BetweennessCentrality']]], + ['binaryheap_4',['binaryheap',['../classegoa_1_1_binary_heap.html#aed6d9f5c7953ac8a5396f57a4808c6d8',1,'egoa::BinaryHeap::BinaryHeap()'],['../classegoa_1_1_binary_heap.html#aba83b6ec8280405111f4a7017d30539b',1,'egoa::BinaryHeap::BinaryHeap(std::vector< TElement > const &elements)']]], + ['blockat_5',['BlockAt',['../classegoa_1_1_block_cut_tree.html#a874dcff7204e23eb06b656b1aa0a2c8a',1,'egoa::BlockCutTree']]], + ['blockcuttreebuilder_6',['BlockCutTreeBuilder',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#adde87192716b708b9471deebf5d5c224',1,'egoa::internal::BlockCutTreeBuilder']]], + ['blockcuttreetraversal_7',['blockcuttreetraversal',['../classegoa_1_1_block_cut_tree_traversal.html#a5814d7135026368eb8cfd890ef5cebf9',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree)'],['../classegoa_1_1_block_cut_tree_traversal.html#a04f97c0ddaa770310aed3f419185652b',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, TNode root)'],['../classegoa_1_1_block_cut_tree_traversal.html#ac487550340394894511662124d4afff5',1,'egoa::BlockCutTreeTraversal::BlockCutTreeTraversal(BlockCutTree< TGraph > const &bcTree, CutVertex const &root)']]], + ['blockofedge_8',['BlockOfEdge',['../classegoa_1_1_block_cut_tree.html#a401278536936af4febd2c969cbe1ca75',1,'egoa::BlockCutTree']]], + ['blocks_9',['Blocks',['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html#a7b18ad7af34c6cc15740442af6c4546d',1,'egoa::BlockCutTree::CutVertex']]], + ['blocksofvertex_10',['BlocksOfVertex',['../classegoa_1_1_block_cut_tree.html#a4fa6e7ab1b7adb4569f547e393b5104c',1,'egoa::BlockCutTree']]], + ['bound_11',['Bound',['../classegoa_1_1_bound.html#a0f3a93cd13fa2be64dc86e9c795cf984',1,'egoa::Bound']]], + ['boundmismatch_12',['BoundMismatch',['../classegoa_1_1_bound_mismatch.html#aea104d9f29cf77ddb37bd1a67d74763e',1,'egoa::BoundMismatch']]], + ['breakable_5ffor_5fall_5fedges_5fat_13',['breakable_for_all_edges_at',['../classegoa_1_1_traversal.html#a0de63cb32b6f954f3e8d30b4af8c2bb9',1,'egoa::Traversal']]], + ['bucket_14',['Bucket',['../classegoa_1_1_bucket.html#a9a615b2348db1435db53d42caae51c3d',1,'egoa::Bucket']]], + ['bucketelement_15',['bucketelement',['../classegoa_1_1_bucket_element.html#a35453483cbc516788738758d21b9e8a5',1,'egoa::BucketElement::BucketElement(TElement value, bool valid)'],['../classegoa_1_1_bucket_element.html#a6b56d8f5e486789136563256d5614093',1,'egoa::BucketElement::BucketElement(TElement element)']]], + ['build_16',['build',['../classegoa_1_1_block_cut_tree.html#a7349ba96044deedda9bccf07f631ceb4',1,'egoa::BlockCutTree::Build()'],['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#ae76c6aca56d8f920d976e1a9dc2dac7d',1,'egoa::internal::BlockCutTreeBuilder::Build()']]], + ['buildblockcuttree_17',['buildBlockCutTree',['../group__bctree.html#gac2b3e1c1f521eca70968599a7d50d3e2',1,'egoa']]], + ['buildwith_18',['buildwith',['../classegoa_1_1_binary_heap.html#ac2edbdf1dc2971c2c507c085e63f0e72',1,'egoa::BinaryHeap::BuildWith()'],['../classegoa_1_1_priority_queue.html#a94d54d6e5b9ba377ed95cbe3fa3d4e7f',1,'egoa::PriorityQueue::BuildWith()']]] +]; diff --git a/search/functions_10.js b/search/functions_10.js new file mode 100644 index 00000000..74ddbd09 --- /dev/null +++ b/search/functions_10.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['qc1bound_0',['qc1bound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a014a858b61cc46d290aea2709a60b65f',1,'egoa::Vertices::GeneratorProperties::Qc1Bound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a723c05f065705dc9e98fa338c0ec4aec',1,'egoa::Vertices::GeneratorProperties::Qc1Bound()']]], + ['qc2bound_1',['qc2bound',['../classegoa_1_1_vertices_1_1_generator_properties.html#af05a082df8fc2c2940c3785723dbb8a0',1,'egoa::Vertices::GeneratorProperties::Qc2Bound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#adb4182ed6efe1c13915150c4c4e56c09',1,'egoa::Vertices::GeneratorProperties::Qc2Bound()']]], + ['queuedeleteminimum_2',['QueueDeleteMinimum',['../classegoa_1_1_dominating_theta_path.html#ae4b44e835c6123fb83d1cd1696a31579',1,'egoa::DominatingThetaPath']]], + ['queueempty_3',['QueueEmpty',['../classegoa_1_1_dominating_theta_path.html#abb76294b3c10fb5fc56394a66b57d554',1,'egoa::DominatingThetaPath']]] +]; diff --git a/search/functions_11.js b/search/functions_11.js new file mode 100644 index 00000000..583d298a --- /dev/null +++ b/search/functions_11.js @@ -0,0 +1,54 @@ +var searchData= +[ + ['ramp10_0',['ramp10',['../classegoa_1_1_vertices_1_1_generator_properties.html#af4b142757e3410920306713d595a75d9',1,'egoa::Vertices::GeneratorProperties::Ramp10()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2b9e3ef3b94a13691de4700270a0b9ff',1,'egoa::Vertices::GeneratorProperties::Ramp10() const']]], + ['ramp30_1',['ramp30',['../classegoa_1_1_vertices_1_1_generator_properties.html#abf8fc3420ac6a9b7e63a3f5d5fd9de37',1,'egoa::Vertices::GeneratorProperties::Ramp30()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a0d5c17f4dbf4afd36b0c8b3bfbc9d95f',1,'egoa::Vertices::GeneratorProperties::Ramp30() const']]], + ['rampagc_2',['rampagc',['../classegoa_1_1_vertices_1_1_generator_properties.html#a27280374423f01d45115110519ad451f',1,'egoa::Vertices::GeneratorProperties::RampAgc()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a53f32577000a34f41f72b42a373b055b',1,'egoa::Vertices::GeneratorProperties::RampAgc() const']]], + ['ramplimitdown_3',['ramplimitdown',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa41b37f35b5a43fb93326481dbb8eb7e',1,'egoa::Vertices::GeneratorProperties::RampLimitDown() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8762430d9fc121a39d4eb8dae42d4120',1,'egoa::Vertices::GeneratorProperties::RampLimitDown()']]], + ['ramplimitshutdown_4',['ramplimitshutdown',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5b9eb7d984a3cc1dc9c1ddaecc4ff4d2',1,'egoa::Vertices::GeneratorProperties::RampLimitShutDown() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8e244ba49628a8fae46fb2eb968ab578',1,'egoa::Vertices::GeneratorProperties::RampLimitShutDown()']]], + ['ramplimitstartup_5',['ramplimitstartup',['../classegoa_1_1_vertices_1_1_generator_properties.html#af1e033f5e2afe770f805c3e6cf130453',1,'egoa::Vertices::GeneratorProperties::RampLimitStartUp() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ae76bd6acfee87cb7f0448933d3f70df3',1,'egoa::Vertices::GeneratorProperties::RampLimitStartUp()']]], + ['ramplimitup_6',['ramplimitup',['../classegoa_1_1_vertices_1_1_generator_properties.html#a6b7c85c77b3c510ce0dd9c711be521bd',1,'egoa::Vertices::GeneratorProperties::RampLimitUp() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ad652a617a102ea8e411d69f0f582354a',1,'egoa::Vertices::GeneratorProperties::RampLimitUp()']]], + ['rampq_7',['rampq',['../classegoa_1_1_vertices_1_1_generator_properties.html#a6c83113062e7ebf59d4e8ae5c9e2b656',1,'egoa::Vertices::GeneratorProperties::RampQ() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a9727ceba91f0c1368acde06c83da1be1',1,'egoa::Vertices::GeneratorProperties::RampQ()']]], + ['range_8',['Range',['../classegoa_1_1_bound.html#a1b784093b7f3f93e40fde7ebe0ffb157',1,'egoa::Bound']]], + ['reactivepower_9',['reactivepower',['../classegoa_1_1_vertices_1_1_generator_properties.html#af761e8418a57b1b49d1f988a4704d9cf',1,'egoa::Vertices::GeneratorProperties::ReactivePower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2638096b1f58a70af684ac4122739862',1,'egoa::Vertices::GeneratorProperties::ReactivePower()']]], + ['reactivepowerbound_10',['reactivepowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#aa4440d418ec103efecb9e0372f75534c',1,'egoa::Vertices::GeneratorProperties::ReactivePowerBound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a2debdf69d9a0eb109ba6a68bdf14516e',1,'egoa::Vertices::GeneratorProperties::ReactivePowerBound()']]], + ['reactivepowerload_11',['reactivepowerload',['../classegoa_1_1_vertices_1_1_load_properties.html#ab87c60ebbb19607f300f6daf87351621',1,'egoa::Vertices::LoadProperties::ReactivePowerLoad() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#a469a7d86b06b8904f078d1b9061b9c8b',1,'egoa::Vertices::LoadProperties::ReactivePowerLoad()']]], + ['reactivepowerloadbound_12',['reactivepowerloadbound',['../classegoa_1_1_vertices_1_1_load_properties.html#a40cb4d1e9a1cd0399827c3e87ab1f661',1,'egoa::Vertices::LoadProperties::ReactivePowerLoadBound() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#a1aabf52802f8d2386c07db037b6ef2a0',1,'egoa::Vertices::LoadProperties::ReactivePowerLoadBound()']]], + ['read_13',['read',['../classegoa_1_1_py_psa_parser.html#a2f8cd295e12fc19ff512f5f8a1d7b83a',1,'egoa::PyPsaParser::read(TNetwork &network, std::string const &filename)'],['../classegoa_1_1_py_psa_parser.html#a3e83cd88ca4fdb401efb0a05a098fe5a',1,'egoa::PyPsaParser::read(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#a1473163c2bf05490fca49ff87c4ef042',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::istream &input_stream)'],['../classegoa_1_1_power_grid_i_o.html#a5ef60b5da88230f9f18baf295cb61ae4',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#a2948d89a83f9ea8368068f18149905c2',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStreamBased reader=PowerGridIO< GraphType >::read)'],['../classegoa_1_1_power_grid_i_o.html#a1ddb7b91a3789094587c4359457ddcae',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, std::string const &filename, ReaderFunctionStringBased reader=PowerGridIO< GraphType >::read)'],['../classegoa_1_1_power_grid_i_o.html#ab6c7b284f94ff047853fd4c7f6ffeeda',1,'egoa::PowerGridIO::read(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename, ReaderFunctionStreamBasedPowerGridAndCandidateNetwork reader=PowerGridIO< GraphType >::read)']]], + ['readable_14',['Readable',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ab27e0b1a7ea5bf91bcfc7e79deccf844',1,'egoa::IO::GeoJsonWriter']]], + ['readbasemva_15',['readBaseMva',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a6a8fb203082a3704e912f879af6b1da3',1,'egoa::IeeeCdfMatlabParser']]], + ['readbranchmatrix_16',['readBranchMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#aab179d28aae1e1f8beae96f823ea2492',1,'egoa::IeeeCdfMatlabParser']]], + ['readbuses_17',['ReadBuses',['../classegoa_1_1_py_psa_parser.html#aaa1b7b4395e7c4bc137eecbc5c0b8335',1,'egoa::PyPsaParser']]], + ['readbusmatrix_18',['readBusMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#aeb931c8dea794813f2eef7072407fdb4',1,'egoa::IeeeCdfMatlabParser']]], + ['readcarriers_19',['ReadCarriers',['../classegoa_1_1_py_psa_parser.html#a82090f1864e8027c223264297a32346b',1,'egoa::PyPsaParser']]], + ['readcasename_20',['readCaseName',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a1fbea31b2ed5715a5b16da2ced9c8754',1,'egoa::IeeeCdfMatlabParser']]], + ['readcompletenetwork_21',['readcompletenetwork',['../classegoa_1_1_py_psa_parser.html#a120aa4bca295b0dfc6a5c29707d8e55b',1,'egoa::PyPsaParser::ReadCompleteNetwork(TNetwork &network, std::string const &filename)'],['../classegoa_1_1_py_psa_parser.html#a1ad8bf82ea077f9cff68234045ad928b',1,'egoa::PyPsaParser::ReadCompleteNetwork(TNetwork &network, TGraph &candidateNetwork, std::string const &filename)']]], + ['readgeneratormatrix_22',['readGeneratorMatrix',['../classegoa_1_1_ieee_cdf_matlab_parser.html#add80c979e0e2b2bbb1c84ce237072117',1,'egoa::IeeeCdfMatlabParser']]], + ['readgenerators_23',['ReadGenerators',['../classegoa_1_1_py_psa_parser.html#a55de696ad6ab7a55b663a9811baf830e',1,'egoa::PyPsaParser']]], + ['readgeneratorsrealpowermaxpu_24',['ReadGeneratorsRealPowerMaxPu',['../classegoa_1_1_py_psa_parser.html#a8f322c88e239f52e1ec6d53b006e6f74',1,'egoa::PyPsaParser']]], + ['readglobalconstraints_25',['ReadGlobalConstraints',['../classegoa_1_1_py_psa_parser.html#abfe41edb56a3f8683ecdc0f767e77a04',1,'egoa::PyPsaParser']]], + ['readgraphgml_26',['ReadGraphGml',['../classegoa_1_1_power_grid_i_o.html#a2259a05ec96e90ac30e957b732a6efcd',1,'egoa::PowerGridIO']]], + ['readieeecdfmatlab_27',['readIeeeCdfMatlab',['../classegoa_1_1_power_grid_i_o.html#a359196094df5704c21eb9b2829ba5f0e',1,'egoa::PowerGridIO']]], + ['readline_28',['ReadLine',['../classegoa_1_1_py_psa_parser.html#a3613605957f4afdfccf915081fdd9c6f',1,'egoa::PyPsaParser']]], + ['readlines_29',['ReadLines',['../classegoa_1_1_py_psa_parser.html#a1da3a5940b5ddbc8872f0f95080bb457',1,'egoa::PyPsaParser']]], + ['readloads_30',['ReadLoads',['../classegoa_1_1_py_psa_parser.html#a5cb9f55ee9149d457ab74a1b85e43de1',1,'egoa::PyPsaParser']]], + ['readloadspset_31',['ReadLoadsPset',['../classegoa_1_1_py_psa_parser.html#a8db656a77a1d4986cb1a7d91f820fcac',1,'egoa::PyPsaParser']]], + ['readnetwork_32',['readnetwork',['../classegoa_1_1_ieee_cdf_matlab_parser.html#a399b96926adc854193983e680cea41c8',1,'egoa::IeeeCdfMatlabParser::readNetwork()'],['../classegoa_1_1_py_psa_parser.html#a672874174d008c35709d19c00aba5696',1,'egoa::PyPsaParser::ReadNetwork()']]], + ['readpypsa_33',['readpypsa',['../classegoa_1_1_power_grid_i_o.html#ac0b7db858e4106bd471df6303d1f3699',1,'egoa::PowerGridIO::ReadPyPsa(PowerGrid< GraphType > &network, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#ad10b09c3c60c127139ad4168a0201c06',1,'egoa::PowerGridIO::ReadPyPsa(PowerGrid< GraphType > &network, GraphType &candidateNetwork, std::string const &filename)']]], + ['readsnapshots_34',['ReadSnapshots',['../classegoa_1_1_py_psa_parser.html#ac8665942230fce5984f6434af811393a',1,'egoa::PyPsaParser']]], + ['readstorageunits_35',['ReadStorageUnits',['../classegoa_1_1_py_psa_parser.html#a02c857ac281a2dec0f9cc1116370162f',1,'egoa::PyPsaParser']]], + ['readstorageunitsinflows_36',['ReadStorageUnitsInflows',['../classegoa_1_1_py_psa_parser.html#ab1cf13fa8f9696f02ff45df060cdd919',1,'egoa::PyPsaParser']]], + ['realpower_37',['realpower',['../classegoa_1_1_vertices_1_1_generator_properties.html#adb1e7db4440b9446b0e2ce01a4a30d4f',1,'egoa::Vertices::GeneratorProperties::RealPower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a39fa5dcca4166228d8a607e8f214e8cf',1,'egoa::Vertices::GeneratorProperties::RealPower()']]], + ['realpowerbound_38',['realpowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0c1e9f8fa3a94009b5a11f86ceb505bd',1,'egoa::Vertices::GeneratorProperties::RealPowerBound() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac686597506b9d29e519b22d1042f8d82',1,'egoa::Vertices::GeneratorProperties::RealPowerBound()']]], + ['realpowerload_39',['realpowerload',['../classegoa_1_1_vertices_1_1_load_properties.html#a239e5d037bde34f96e69af4a1b9a7316',1,'egoa::Vertices::LoadProperties::RealPowerLoad() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#afbd2d143bee082c5d57aef63a358b6a1',1,'egoa::Vertices::LoadProperties::RealPowerLoad()']]], + ['realpowerloadat_40',['realpowerloadat',['../classegoa_1_1_power_grid.html#a76e6636f4ae50b5e614d32443ce319ef',1,'egoa::PowerGrid::RealPowerLoadAt(TVertex const &vertex, Types::index snapshotId=0) const'],['../classegoa_1_1_power_grid.html#a0ad99b8b6aaccbf57ad5f6e1d6d9aa02',1,'egoa::PowerGrid::RealPowerLoadAt(Types::vertexId vertexId, Types::index snapshotId=0) const']]], + ['realpowerloadbound_41',['realpowerloadbound',['../classegoa_1_1_vertices_1_1_load_properties.html#a4d6868d16ae3e643bdcce8a1a57d2763',1,'egoa::Vertices::LoadProperties::RealPowerLoadBound() const'],['../classegoa_1_1_vertices_1_1_load_properties.html#acf0e443a793fe5957d58cba4933b9fe8',1,'egoa::Vertices::LoadProperties::RealPowerLoadBound()']]], + ['red_42',['red',['../classegoa_1_1_color.html#ac0262a754506952f2cd35c85a8590bc7',1,'egoa::Color']]], + ['removeallincidentedgesat_43',['RemoveAllIncidentEdgesAt',['../classegoa_1_1_dynamic_graph.html#af4cf9dec17d8d8f508a19f095aa763fa',1,'egoa::DynamicGraph']]], + ['removeedgeat_44',['RemoveEdgeAt',['../classegoa_1_1_dynamic_graph.html#a1439eb482da86aee51f6e9fcd2b5fd28',1,'egoa::DynamicGraph']]], + ['removegeneratorat_45',['removegeneratorat',['../classegoa_1_1_power_grid.html#a007252fb0f9458101504bee62aded0b4',1,'egoa::PowerGrid::RemoveGeneratorAt(Types::vertexId vertexId, Types::generatorId generatorId)'],['../classegoa_1_1_power_grid.html#a27d896fe872fb31bff7f747b022efef0',1,'egoa::PowerGrid::RemoveGeneratorAt(Types::vertexId vertexId, TGeneratorProperties &generatorProperty)']]], + ['removeloadat_46',['removeloadat',['../classegoa_1_1_power_grid.html#a0d6b7dbfcc56ae904ea92d95ec25ade0',1,'egoa::PowerGrid::RemoveLoadAt(Types::vertexId vertexId, Types::loadId loadId)'],['../classegoa_1_1_power_grid.html#aaa2cba96d7337ae301867e2681b907bd',1,'egoa::PowerGrid::RemoveLoadAt(Types::vertexId vertexId, TLoadProperties &load)']]], + ['removevertexat_47',['RemoveVertexAt',['../classegoa_1_1_dynamic_graph.html#a4016f2a89fddac9b1a600d81a1e668f8',1,'egoa::DynamicGraph']]], + ['reset_48',['reset',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5ca0740b13b4f37e0e0bda37fb29f86a',1,'egoa::Vertices::ElectricalProperties::Reset()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a4961e722fef1b1436f4785e6adc40f4f',1,'egoa::Vertices::GeneratorProperties::Reset()']]], + ['result_49',['result',['../classegoa_1_1_dominating_theta_path.html#a818ba50c2bedadcdc9cfb79d45258699',1,'egoa::DominatingThetaPath::Result(Subgraph< TGraph const > &resultSubgraph, TVertexId const target)'],['../classegoa_1_1_dominating_theta_path.html#ab2d6f458076d6c113987bd242649ecd8',1,'egoa::DominatingThetaPath::Result(std::vector< std::vector< TVertexId > > &parent, TVertexId const target)'],['../classegoa_1_1_m_s_t.html#a32bf7e31a800597a41cb6872e947890b',1,'egoa::MST::Result()']]], + ['run_50',['run',['../classegoa_1_1_block_cut_tree_traversal.html#a325c650ca820a35a79a7f9e7a858166f',1,'egoa::BlockCutTreeTraversal::Run()'],['../classegoa_1_1_betweenness_centrality.html#a5f364f7a1f44eb9716d9a49f618fde12',1,'egoa::BetweennessCentrality::Run()'],['../classegoa_1_1_b_f_s.html#acd9ea3faefd2cd2c59b49f86784d924b',1,'egoa::BFS::Run()'],['../classegoa_1_1_dominating_theta_path.html#a8255dba72b52f5875bb2eea79d37f3e8',1,'egoa::DominatingThetaPath::Run()'],['../classegoa_1_1_kruskal.html#aebe2686432729619f7851cca2e943696',1,'egoa::Kruskal::Run()'],['../classegoa_1_1_prim.html#aa1860e37400c3f34111edb86ddd10807',1,'egoa::Prim::Run()']]] +]; diff --git a/search/functions_12.js b/search/functions_12.js new file mode 100644 index 00000000..4dc8f895 --- /dev/null +++ b/search/functions_12.js @@ -0,0 +1,31 @@ +var searchData= +[ + ['search_0',['Search',['../classegoa_1_1_binary_heap.html#a393e558559b9c1ac7f9ac955d9adf5b3',1,'egoa::BinaryHeap']]], + ['selectswappablechildat_1',['selectswappablechildat',['../classegoa_1_1_binary_heap.html#a74506ce29cf79cd27be29aba345c14cd',1,'egoa::BinaryHeap::SelectSwappableChildAt()'],['../classegoa_1_1_mapping_binary_heap.html#a4d5d1a132db65d579ce0232fcd0f96b3',1,'egoa::MappingBinaryHeap::SelectSwappableChildAt()']]], + ['setlinedefaultvalues_2',['SetLineDefaultValues',['../classegoa_1_1_py_psa_parser.html#a6f4ba696bb8766842c2185d6ab8faad1',1,'egoa::PyPsaParser']]], + ['setloaddefaultvalues_3',['SetLoadDefaultValues',['../classegoa_1_1_py_psa_parser.html#a0f6161489581546388b5885f3f6b9391',1,'egoa::PyPsaParser']]], + ['setparentof_4',['SetParentOf',['../classegoa_1_1_dominating_theta_path.html#a7032884e83c902935483cd76efc85832',1,'egoa::DominatingThetaPath']]], + ['setresult_5',['SetResult',['../classegoa_1_1_m_s_t.html#a4577ac689018e9fce16775a744f52a2c',1,'egoa::MST']]], + ['setvertexprocessedat_6',['SetVertexProcessedAt',['../classegoa_1_1_traversal.html#a33188b59efd9736defff871d4f2597f2',1,'egoa::Traversal']]], + ['setvertexvisitedat_7',['SetVertexVisitedAt',['../classegoa_1_1_traversal.html#ab9d5522bc200837e76015a3c31ae09c5',1,'egoa::Traversal']]], + ['shuntconductance_8',['shuntconductance',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a798428fa53b0f7fd7abdd9becf85b2f2',1,'egoa::Vertices::ElectricalProperties::ShuntConductance() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4d5034eca7eaef9c231905aed6ae89b2',1,'egoa::Vertices::ElectricalProperties::ShuntConductance()']]], + ['shuntsusceptance_9',['shuntsusceptance',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6001cea3db65dfcd0c5947e4652772be',1,'egoa::Vertices::ElectricalProperties::ShuntSusceptance() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5bdcac2c2fb15a1a9775f25c0fb292a5',1,'egoa::Vertices::ElectricalProperties::ShuntSusceptance()']]], + ['shutdowncost_10',['shutdowncost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a816377edafb113204d9f5fcca4cde414',1,'egoa::Vertices::GeneratorProperties::ShutDownCost()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1f059f93a66d4884736d277bcd788a1a',1,'egoa::Vertices::GeneratorProperties::ShutDownCost() const']]], + ['siftdown_11',['siftdown',['../classegoa_1_1_binary_heap.html#a9fe572daa5c381d1e4354d37afb93fc6',1,'egoa::BinaryHeap::SiftDown()'],['../classegoa_1_1_binary_heap.html#aec5dc2b7fc30e9829e31c102f96f7f2e',1,'egoa::BinaryHeap::SiftDown(Types::index index)'],['../classegoa_1_1_mapping_binary_heap.html#ad35c2ccc90f8f806ed616855050bf16a',1,'egoa::MappingBinaryHeap::SiftDown()'],['../classegoa_1_1_mapping_binary_heap.html#a8e6d7f27cfee63887d1e5cc9896a118a',1,'egoa::MappingBinaryHeap::SiftDown(Types::index index)']]], + ['siftup_12',['siftup',['../classegoa_1_1_binary_heap.html#afc629079dded733d1ad41410fc23f5b5',1,'egoa::BinaryHeap::SiftUp()'],['../classegoa_1_1_binary_heap.html#af4bc7523cdba5c6c9defbdc523759f9e',1,'egoa::BinaryHeap::SiftUp(Types::index index)'],['../classegoa_1_1_mapping_binary_heap.html#a9d56cbcba39fcbe4afdc2e1322596dbb',1,'egoa::MappingBinaryHeap::SiftUp()'],['../classegoa_1_1_mapping_binary_heap.html#a78f608e8fbb685b7f490efc528c018e1',1,'egoa::MappingBinaryHeap::SiftUp(Types::index index)']]], + ['size_13',['size',['../classegoa_1_1_binary_heap.html#a78f5d8380001a14caee95f4e18004c7a',1,'egoa::BinaryHeap::Size()'],['../classegoa_1_1_mapping_binary_heap.html#a74dd4cd4319e565a2bc6b51d8ca8f60e',1,'egoa::MappingBinaryHeap::Size()']]], + ['sortblocks_14',['SortBlocks',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#a8c9acf4004b3ddacf2af4bed234ba639',1,'egoa::internal::BlockCutTreeBuilder']]], + ['source_15',['source',['../classegoa_1_1_dominating_theta_path.html#a443ddb1cc3f347672b0cc1e5f37bdb89',1,'egoa::DominatingThetaPath::Source()'],['../classegoa_1_1_traversal.html#adb62b9f9c152287d375c7769dbf63703',1,'egoa::Traversal::Source()']]], + ['sourcelabel_16',['sourcelabel',['../classegoa_1_1_susceptance_norm_label.html#a89e65d3fcf4e74ef3337c0ef1d9bae12',1,'egoa::SusceptanceNormLabel::SourceLabel()'],['../classegoa_1_1_voltage_angle_difference_label.html#a7a0e242e8d62d2d295aa45b2cd5614a1',1,'egoa::VoltageAngleDifferenceLabel::SourceLabel()']]], + ['startupcost_17',['startupcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5e2faaadf35a6097bdb0b5a802867ca9',1,'egoa::Vertices::GeneratorProperties::StartUpCost() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac8e1fe3da5b23a0b20d25a4f42593ef2',1,'egoa::Vertices::GeneratorProperties::StartUpCost()']]], + ['statistic_18',['statistic',['../classegoa_1_1_dominating_theta_path.html#ab7cd27a921da2599eefd595710723780',1,'egoa::DominatingThetaPath::Statistic()'],['../classegoa_1_1_dominating_theta_path.html#a58b4cc1f54142f7b53303b8ddf14f0b0',1,'egoa::DominatingThetaPath::Statistic() const']]], + ['status_19',['status',['../classegoa_1_1_vertices_1_1_electrical_properties.html#acda4e5d8f5acdc2621ad46f8bceadc1d',1,'egoa::Vertices::ElectricalProperties::Status()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#abd8898fc56caa29533cd1096832ab3d0',1,'egoa::Vertices::ElectricalProperties::Status() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a9fb4e4998e0e1d4e27655c46a965f780',1,'egoa::Vertices::GeneratorProperties::Status() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#af2c8123994f05dfc21d47e1da04bf0db',1,'egoa::Vertices::GeneratorProperties::Status()']]], + ['stroke_20',['stroke',['../classegoa_1_1_stroke.html#ab133a8a3397294d5c8aa7f137502c269',1,'egoa::Stroke::Stroke(Stroke::Name name)'],['../classegoa_1_1_stroke.html#a1608ce0c134b7096cfd6bce7a4dc36c3',1,'egoa::Stroke::Stroke()']]], + ['stroke2dotstyle_21',['Stroke2DotStyle',['../classegoa_1_1_power_grid_i_o.html#a2fc9f5440c89b3a0d5d8c6844a040ba2',1,'egoa::PowerGridIO']]], + ['subgraph_22',['subgraph',['../classegoa_1_1_block_cut_tree_1_1_block.html#afdca5da105664f9bfc1b7923937aacc3',1,'egoa::BlockCutTree::Block::Subgraph()'],['../classegoa_1_1_subgraph.html#af3b6b33a7a3c3303fcdb8208f8febc66',1,'egoa::Subgraph::Subgraph()']]], + ['susceptance_23',['susceptance',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html#a6be29eaeb310002c28da022825053bf7',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Susceptance()'],['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html#a5292c6be0796d950be8a9015f2ead88b',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Susceptance()']]], + ['susceptancenorm_24',['susceptancenorm',['../classegoa_1_1_susceptance_norm_label.html#a5cff82dc79b1923534c8012b1c5c1240',1,'egoa::SusceptanceNormLabel::SusceptanceNorm() const'],['../classegoa_1_1_susceptance_norm_label.html#ac6c5dd6aeed74137fee8f3bc1c25821c',1,'egoa::SusceptanceNormLabel::SusceptanceNorm()']]], + ['susceptancenormlabel_25',['susceptancenormlabel',['../classegoa_1_1_susceptance_norm_label.html#a4ea696004da32beace96dba84c01698d',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel()'],['../classegoa_1_1_susceptance_norm_label.html#a2be7a8d041abc7599d9ffcd93db5ba0e',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId)'],['../classegoa_1_1_susceptance_norm_label.html#a743eb1b6f202e51cddc3ccebe00ab26c',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm)'],['../classegoa_1_1_susceptance_norm_label.html#ac4528bda06f4b8562de0f49aa6a02188',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(Types::vertexId vertexId, Types::real susceptanceNorm, TVertexSet vertexSet)'],['../classegoa_1_1_susceptance_norm_label.html#a377c2280a34c1b90191674bebfbf552a',1,'egoa::SusceptanceNormLabel::SusceptanceNormLabel(SusceptanceNormLabel const &label)=default']]], + ['swap_26',['Swap',['../classegoa_1_1_mapping_binary_heap.html#a5980fbdcaaffeed3abbaab27d450188c',1,'egoa::MappingBinaryHeap']]], + ['switchedges_27',['SwitchEdges',['../namespaceegoa.html#a28ffaa4f98802617d5c12c75771d4a5c',1,'egoa']]] +]; diff --git a/search/functions_13.js b/search/functions_13.js new file mode 100644 index 00000000..b55cfd4a --- /dev/null +++ b/search/functions_13.js @@ -0,0 +1,25 @@ +var searchData= +[ + ['terminate_0',['Terminate',['../classegoa_1_1_depth_first_search.html#af5af476811704fcc85bdfc68725686e5',1,'egoa::DepthFirstSearch']]], + ['thetabound_1',['thetabound',['../classegoa_1_1_power_grid.html#ab92be7dd2ca99b9d450beb04f3b525fd',1,'egoa::PowerGrid::ThetaBound() const'],['../classegoa_1_1_power_grid.html#a1097ce9dc78ab883a7a53319e9f2c778',1,'egoa::PowerGrid::ThetaBound()']]], + ['time_2',['Time',['../classegoa_1_1_depth_first_search.html#a2852f7950d64bb54d76826e9dbe08cff',1,'egoa::DepthFirstSearch']]], + ['timestampat_3',['TimestampAt',['../classegoa_1_1_power_grid.html#a752fd2b23d778f2ac4766c8d22e66cc9',1,'egoa::PowerGrid']]], + ['top_4',['top',['../classegoa_1_1_binary_heap.html#a1b20c7366d0799764ce000b8af1e7333',1,'egoa::BinaryHeap::Top()'],['../classegoa_1_1_bucket.html#a815f103723d4d2ff76d63c0e70cefb78',1,'egoa::Bucket::Top()'],['../classegoa_1_1_mapping_binary_heap.html#a0316b89af5cd4dc4befce15fe280be0c',1,'egoa::MappingBinaryHeap::Top()'],['../classegoa_1_1_priority_queue.html#aee4c96105bd1f6fbc77182413ef0b48b',1,'egoa::PriorityQueue::Top()'],['../classegoa_1_1_queue.html#a1e01fbe6d2caf5bc0b00936a2e73fd8f',1,'egoa::Queue::Top()'],['../classegoa_1_1_std_queue.html#a496a2732c537608dfc3c9635ceb89840',1,'egoa::StdQueue::Top()']]], + ['topelement_5',['TopElement',['../classegoa_1_1_mapping_binary_heap.html#aea256d02d2ac158db366c1b851fb20fe',1,'egoa::MappingBinaryHeap']]], + ['topkey_6',['TopKey',['../classegoa_1_1_mapping_binary_heap.html#ae43c05e95479904d4ec9be4b681b4f53',1,'egoa::MappingBinaryHeap']]], + ['totalnumberofpaths_7',['totalnumberofpaths',['../classegoa_1_1_betweenness_centrality.html#adb232cfef1d46ba2911eeadeab574665',1,'egoa::BetweennessCentrality::TotalNumberOfPaths() const'],['../classegoa_1_1_betweenness_centrality.html#a3fa665a692383b7e3141bc3fd5b39603',1,'egoa::BetweennessCentrality::TotalNumberOfPaths(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)']]], + ['totalnumberofpathsthroughedge_8',['TotalNumberOfPathsThroughEdge',['../classegoa_1_1_dominating_theta_path.html#a99e06788e2fa083610d853d3dcdd838b',1,'egoa::DominatingThetaPath']]], + ['totalnumberofpathsthroughvertex_9',['TotalNumberOfPathsThroughVertex',['../classegoa_1_1_dominating_theta_path.html#acfc28500d2c7f2d667f81d03dc70e40b',1,'egoa::DominatingThetaPath']]], + ['totalreactivepowergenerationat_10',['totalreactivepowergenerationat',['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html#a581dde2106576b1eaffc0fab17e1eb96',1,'egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalReactivePowerGenerationAt()'],['../classegoa_1_1_power_grid.html#ad339f9df12e72926a5d5187e2ee1d8c6',1,'egoa::PowerGrid::TotalReactivePowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) const']]], + ['totalreactivepowergenerationboundat_11',['TotalReactivePowerGenerationBoundAt',['../classegoa_1_1_power_grid.html#aa1130efec62586f7a9b6ee12c7d4ca55',1,'egoa::PowerGrid']]], + ['totalreactivepowerloadboundat_12',['TotalReactivePowerLoadBoundAt',['../classegoa_1_1_power_grid.html#af3698d771b79e9fc5f682c9ed49f526b',1,'egoa::PowerGrid']]], + ['totalrealpowergenerationat_13',['totalrealpowergenerationat',['../classegoa_1_1internal_1_1_generation_strategy_differentiation_3_01_network_type_00_01_vertices_1474304627fb13ba734774e9e5540a421.html#a5267da62238da8eef80aba4c5d9e2e04',1,'egoa::internal::GenerationStrategyDifferentiation< NetworkType, Vertices::GenerationStrategyDifferentiationType::totalVertexPowerGenerationPerSnapshot >::TotalRealPowerGenerationAt()'],['../classegoa_1_1_power_grid.html#abeb8fe4e80c4fdaba71421649a541af5',1,'egoa::PowerGrid::TotalRealPowerGenerationAt(Types::vertexId vertexId, Types::index timestampPosition=0) const']]], + ['totalrealpowergenerationboundat_14',['TotalRealPowerGenerationBoundAt',['../classegoa_1_1_power_grid.html#aaf409cf61193b8c8c44363f4a5eb3034',1,'egoa::PowerGrid']]], + ['totalrealpowerloadat_15',['TotalRealPowerLoadAt',['../classegoa_1_1_power_grid.html#aee20fc87deecdfff9736acc1be069db4',1,'egoa::PowerGrid']]], + ['totalrealpowerloadboundat_16',['TotalRealPowerLoadBoundAt',['../classegoa_1_1_power_grid.html#a6cbe3e5938981a9bdee8ffb8e88d9687',1,'egoa::PowerGrid']]], + ['totalrelativenumberofpaths_17',['TotalRelativeNumberOfPaths',['../classegoa_1_1_betweenness_centrality.html#ad8a1bd8db3c4d9f5f13d3f11fef0b953',1,'egoa::BetweennessCentrality']]], + ['traversal_18',['Traversal',['../classegoa_1_1_traversal.html#a50d2313238e7723226d6e8a5d43b08ec',1,'egoa::Traversal']]], + ['treeoutdegree_19',['TreeOutDegree',['../classegoa_1_1_articulation_vertex_detection.html#a9997acc8bd99b4fb684ad191f407e368',1,'egoa::ArticulationVertexDetection']]], + ['type_20',['type',['../classegoa_1_1_vertices_1_1_load_properties.html#a9fcffced8bff34d2012d0a910e021883',1,'egoa::Vertices::LoadProperties::Type()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a9f701de7719711fe0f562704402a4732',1,'egoa::Vertices::LoadProperties::Type() const']]], + ['typifyedge_21',['TypifyEdge',['../classegoa_1_1_depth_first_search.html#a6518e2333138342f23f113229c351f72',1,'egoa::DepthFirstSearch']]] +]; diff --git a/search/functions_14.js b/search/functions_14.js new file mode 100644 index 00000000..9f726c52 --- /dev/null +++ b/search/functions_14.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['underlyinggraph_0',['underlyinggraph',['../classegoa_1_1_subgraph.html#a04af76424e41e3a70d0aa33be626a8a0',1,'egoa::Subgraph::UnderlyingGraph()'],['../classegoa_1_1_subgraph.html#a8396d16535e875c95995f344228cb3d7',1,'egoa::Subgraph::UnderlyingGraph() const']]], + ['union_1',['Union',['../classegoa_1_1_union_find.html#a470ce1c4a136137cf4e5da9f5921249d',1,'egoa::UnionFind']]], + ['updateedges_2',['UpdateEdges',['../classegoa_1_1_dynamic_graph.html#a7c875e9bc4f2d4dccc58d5dc4f71f3f6',1,'egoa::DynamicGraph']]], + ['updategeneratorsnapshotsize_3',['UpdateGeneratorSnapshotSize',['../classegoa_1_1_power_grid.html#a1bcc5072df02b1c7e58b2f7d944d8138',1,'egoa::PowerGrid']]], + ['updatelabelset_4',['UpdateLabelSet',['../classegoa_1_1_dominating_theta_path.html#a4fed38b29e1d5517c4f9000b76dabbf7',1,'egoa::DominatingThetaPath']]], + ['updatelabelsetat_5',['UpdateLabelSetAt',['../classegoa_1_1_dominating_theta_path.html#af8fe087c1b987749679bae66cfe56c61',1,'egoa::DominatingThetaPath']]], + ['updateloadsnapshotsize_6',['UpdateLoadSnapshotSize',['../classegoa_1_1_power_grid.html#a9dddc68fbe06d166d81a7e4cb9366858',1,'egoa::PowerGrid']]], + ['updatequeuewith_7',['UpdateQueueWith',['../classegoa_1_1_dominating_theta_path.html#ae6167bdb4f6bd2ff9acdd1dee2951b66',1,'egoa::DominatingThetaPath']]], + ['updatevertices_8',['UpdateVertices',['../classegoa_1_1_dynamic_graph.html#a9184c56f7a673fa024ff5e41bc65fcc7',1,'egoa::DynamicGraph']]] +]; diff --git a/search/functions_15.js b/search/functions_15.js new file mode 100644 index 00000000..d3e18c13 --- /dev/null +++ b/search/functions_15.js @@ -0,0 +1,21 @@ +var searchData= +[ + ['valid_0',['valid',['../classegoa_1_1_bucket_element.html#aaea7a15250016675f33becf9f5507b82',1,'egoa::BucketElement::Valid()'],['../classegoa_1_1_bucket_element.html#a4053b4114d94b641e968ab570fcddf22',1,'egoa::BucketElement::Valid() const'],['../classegoa_1_1_label.html#a147b0a2c210ea0c7a73960793390630d',1,'egoa::Label::Valid()'],['../classegoa_1_1_label.html#a35da0c2e26608ea848cf88680f2008ad',1,'egoa::Label::Valid() const']]], + ['value_1',['value',['../classegoa_1_1_bucket_element.html#a4231606d36a7c5257723fcd43d82afe8',1,'egoa::BucketElement::Value() const'],['../classegoa_1_1_bucket_element.html#a285e1832cac95403d97eafb5ccaa97f0',1,'egoa::BucketElement::Value()'],['../classegoa_1_1_susceptance_norm_label.html#a25ea356ac216d1d683c4549cccde72ae',1,'egoa::SusceptanceNormLabel::Value()'],['../classegoa_1_1_voltage_angle_difference_label.html#a151040ba01cc2fdfb407aad45e80e0dd',1,'egoa::VoltageAngleDifferenceLabel::Value()']]], + ['vectorbasedcomparator_2',['VectorBasedComparator',['../classegoa_1_1_vector_based_comparator.html#a82c05abbc7fdc0eed7934eb65043621f',1,'egoa::VectorBasedComparator']]], + ['vertex_3',['vertex',['../classegoa_1_1_vertices_1_1_vertex.html#af5a0ad670948c0ebccf30cd5b6910c67',1,'egoa::Vertices::Vertex::Vertex()'],['../classegoa_1_1_label.html#a9080389c29a477c8dd68c636e4dd38b1',1,'egoa::Label::Vertex() const'],['../classegoa_1_1_label.html#a1898e8d0305d3deca7ad3090746f8ba7',1,'egoa::Label::Vertex()']]], + ['vertexat_4',['vertexat',['../classegoa_1_1_dynamic_graph.html#ade98a36f58b62b0ddf18daf57d051646',1,'egoa::DynamicGraph::VertexAt()'],['../classegoa_1_1_static_graph.html#a54d17ec1f4026c0c356f5ce17d8713fb',1,'egoa::StaticGraph::VertexAt(Types::vertexId id) const'],['../classegoa_1_1_static_graph.html#a51e1aa356592e7bbe21178a4a5cfd0e7',1,'egoa::StaticGraph::VertexAt(Types::vertexId id)'],['../classegoa_1_1_dynamic_graph.html#a887f229058748393dc58e2f0437644d0',1,'egoa::DynamicGraph::VertexAt(Types::vertexId id) const']]], + ['vertexexists_5',['vertexexists',['../classegoa_1_1_dynamic_graph.html#a447e856c5763688544e79a5f664c3c96',1,'egoa::DynamicGraph::VertexExists()'],['../classegoa_1_1_static_graph.html#ac2d85291944c45ce4cf84618f4f0a787',1,'egoa::StaticGraph::VertexExists()']]], + ['vertexid_6',['vertexid',['../classegoa_1_1_dynamic_graph.html#aeb5f893f302fe15c653d946b8d16f6ba',1,'egoa::DynamicGraph::VertexId()'],['../classegoa_1_1_static_graph.html#a3c36deb599963446310a797fb018f2e4',1,'egoa::StaticGraph::VertexId()']]], + ['vertexidof_7',['VertexIdOf',['../classegoa_1_1_dominating_theta_path.html#aa9a70d17bf52f16ebff4de1833451873',1,'egoa::DominatingThetaPath']]], + ['vertexset_8',['vertexset',['../classegoa_1_1_susceptance_norm_label.html#a0bd943685a49da7b5135c81f96f7e3e9',1,'egoa::SusceptanceNormLabel::VertexSet()'],['../classegoa_1_1_susceptance_norm_label.html#a68882a1c3a3b5cdea586db8e57aae544',1,'egoa::SusceptanceNormLabel::VertexSet() const']]], + ['vertices_9',['vertices',['../classegoa_1_1_dynamic_graph.html#ac4d3a3fea6a51d15c7574f3e6719659b',1,'egoa::DynamicGraph::Vertices()'],['../classegoa_1_1_dynamic_graph.html#ac7e7dbb3a0c734e8619ed29cf18cbd32',1,'egoa::DynamicGraph::Vertices() const'],['../classegoa_1_1_static_graph.html#a7d7a79c898700c3d9b031609f522911a',1,'egoa::StaticGraph::Vertices()'],['../classegoa_1_1_static_graph.html#a90fa1753ac1b086664972d381679717b',1,'egoa::StaticGraph::Vertices() const'],['../classegoa_1_1_subgraph.html#affb37573ad582f0ac9ccd7dafe49c353',1,'egoa::Subgraph::Vertices()']]], + ['visitblock_10',['VisitBlock',['../classegoa_1_1_block_cut_tree_traversal.html#ab4026c080e71f35c0f3fabf5d0265c10',1,'egoa::BlockCutTreeTraversal']]], + ['visitcutvertex_11',['VisitCutVertex',['../classegoa_1_1_block_cut_tree_traversal.html#a7fc647cc26f7f1e6502748d0b5f951e3',1,'egoa::BlockCutTreeTraversal']]], + ['visitedvertexat_12',['VisitedVertexAt',['../classegoa_1_1_traversal.html#aabe0f0af747b5ac7f21f2972496b2b16',1,'egoa::Traversal']]], + ['visitleaf_13',['VisitLeaf',['../classegoa_1_1_block_cut_tree_traversal.html#a7c18a382b6fe7e660c0239a1380d8f31',1,'egoa::BlockCutTreeTraversal']]], + ['visitroot_14',['VisitRoot',['../classegoa_1_1_block_cut_tree_traversal.html#a3d1fa1d158452d5c4f227f0f6dfa53d1',1,'egoa::BlockCutTreeTraversal']]], + ['voltageangle_15',['voltageangle',['../classegoa_1_1_vertices_1_1_electrical_properties.html#adace8099209c1eadc7de81d59c4c0924',1,'egoa::Vertices::ElectricalProperties::VoltageAngle() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a11ed7e41aaddc1fc8a9a1ada4b1365e3',1,'egoa::Vertices::ElectricalProperties::VoltageAngle()']]], + ['voltageangledifferencelabel_16',['voltageangledifferencelabel',['../classegoa_1_1_voltage_angle_difference_label.html#aa801eea5c8235950224994adadddd006',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel()'],['../classegoa_1_1_voltage_angle_difference_label.html#a3eefff44bbcb051f2780e65d175b7dfc',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId)'],['../classegoa_1_1_voltage_angle_difference_label.html#ab46376d0b9ce897ce539d7051ab28fba',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity)'],['../classegoa_1_1_voltage_angle_difference_label.html#af1b337329be1d8142fd52f15b814412c',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(Types::vertexId vertexId, Types::real susceptanceNorm, Types::real minimumCapacity, TVertexSet vertexSet)'],['../classegoa_1_1_voltage_angle_difference_label.html#aa5f20f84e84876d44a4b75e299cc2e76',1,'egoa::VoltageAngleDifferenceLabel::VoltageAngleDifferenceLabel(VoltageAngleDifferenceLabel const &label)=default']]], + ['voltagemagnitude_17',['voltagemagnitude',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4dfa1f2e2f6c69685991f3f37b8a8ec4',1,'egoa::Vertices::ElectricalProperties::VoltageMagnitude() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#ab7000550c6964165fd2b016d3e4553d3',1,'egoa::Vertices::ElectricalProperties::VoltageMagnitude()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a14da9854523cea434d734f3edf9c2115',1,'egoa::Vertices::GeneratorProperties::VoltageMagnitude() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a719d6a990b6cc8657b7feedb20a14b09',1,'egoa::Vertices::GeneratorProperties::VoltageMagnitude()']]] +]; diff --git a/search/functions_16.js b/search/functions_16.js new file mode 100644 index 00000000..65c2a76a --- /dev/null +++ b/search/functions_16.js @@ -0,0 +1,31 @@ +var searchData= +[ + ['write_0',['write',['../classegoa_1_1_power_grid_i_o.html#a9d292ab44b61782b90a328e029c2fbbb',1,'egoa::PowerGridIO::write(PowerGrid< GraphType > const &network, std::string const &filename, WriterFunctionStreamBasedtionStringBased writer=PowerGridIO< GraphType >::write)'],['../classegoa_1_1_power_grid_i_o.html#a0de2220bd3ec4fbe166f144b3dfb253c',1,'egoa::PowerGridIO::write(PowerGrid< GraphType > const &network, std::ostream &outputStream, WriterFunctionStreamBased writer=PowerGridIO< GraphType >::write)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac75fccb3c94fd9b80cfb4c5569771b62',1,'egoa::IO::GeoJsonWriter::write(TNetwork const &network, std::ostream &outputStream)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a0e763b5f751b54e099f0e6e39ce84a5f',1,'egoa::IO::GeoJsonWriter::write(TNetwork const &network, std::string const &filename)']]], + ['writecollectiontofilewith_1',['WriteCollectionToFileWith',['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#afb041e19ec019ed08e7a2a28579f9a26',1,'egoa::IO::DtpRuntimeCollection']]], + ['writeedgeproperties_2',['WriteEdgeProperties',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a02adb8fcc493ce5db479752c16374d10',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturebegin_3',['WriteFeatureBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a77e7f8383c850754f8f086a534a13e53',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturecollection_4',['WriteFeatureCollection',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a75fce8973e44387a2d4f96efbb88eae1',1,'egoa::IO::GeoJsonWriter']]], + ['writefeatureend_5',['WriteFeatureEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac96da28ab1ce367560d737df061b895e',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturesbegin_6',['WriteFeaturesBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a86cc11fbd32555fd785bc079a8d0ea4f',1,'egoa::IO::GeoJsonWriter']]], + ['writefeaturesend_7',['WriteFeaturesEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a60920d4689a899f580059f23b295b0dc',1,'egoa::IO::GeoJsonWriter']]], + ['writefooter_8',['WriteFooter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a30377deec1f69334b0659d2fffc0fba2',1,'egoa::IO::GeoJsonWriter']]], + ['writegenerators_9',['WriteGenerators',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#aec1d64deff7ea1521dac6ec894f91efb',1,'egoa::IO::GeoJsonWriter']]], + ['writegeojson_10',['writegeojson',['../classegoa_1_1_power_grid_i_o.html#ae172e258427f0015acaf2c56cc8a5732',1,'egoa::PowerGridIO::WriteGeoJson(PowerGrid< GraphType > const &network, std::string const &filename)'],['../classegoa_1_1_power_grid_i_o.html#a7210c5493b1e1eeb422592b78f252b24',1,'egoa::PowerGridIO::WriteGeoJson(PowerGrid< GraphType > const &network, std::ostream &outputStream)']]], + ['writegeometry_11',['WriteGeometry',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a109bc62f14c3d8d93f5195cfea1c4f19',1,'egoa::IO::GeoJsonWriter']]], + ['writegraph_12',['WriteGraph',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac9c65c096f625ef9e6eda614bc72a870',1,'egoa::IO::GeoJsonWriter']]], + ['writegraphdot_13',['WriteGraphDot',['../classegoa_1_1_power_grid_i_o.html#a4ba3661e93a96d37b508de3c4d9a1b2c',1,'egoa::PowerGridIO']]], + ['writegraphgml_14',['writegraphgml',['../classegoa_1_1_power_grid_i_o.html#ab74ff50470deaf3ac2ef6184ea9c0795',1,'egoa::PowerGridIO::WriteGraphGml(PowerGrid< GraphType > const &network, std::ostream &output_stream)'],['../classegoa_1_1_power_grid_i_o.html#a37b1c87e63f0b4f135a884b4cbab218b',1,'egoa::PowerGridIO::WriteGraphGml(PowerGrid< GraphType > const &network, std::string const &filename)']]], + ['writeheader_15',['WriteHeader',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a041233dbb750691b802118256188a7c2',1,'egoa::IO::GeoJsonWriter']]], + ['writeieeecdfmatlab_16',['writeIeeeCdfMatlab',['../classegoa_1_1_power_grid_i_o.html#a4aa74be3dcfee48668f7ca08d05be756',1,'egoa::PowerGridIO']]], + ['writelinecontent_17',['WriteLineContent',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#adc7921567c5f60122e1ac1b793fe6d8c',1,'egoa::IO::GeoJsonWriter']]], + ['writelinefooter_18',['WriteLineFooter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a67d081b57551d6f93b178544cd373236',1,'egoa::IO::GeoJsonWriter']]], + ['writelineheader_19',['WriteLineHeader',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a3dcb4176b6dc9169639fe8de3680bc32',1,'egoa::IO::GeoJsonWriter']]], + ['writelines_20',['WriteLines',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a540ebeccc60beb0fb598ba7bac904fcf',1,'egoa::IO::GeoJsonWriter']]], + ['writelinesgeometryobject_21',['WriteLinesGeometryObject',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ae5b009b3b09079bca4530c4e311dd269',1,'egoa::IO::GeoJsonWriter']]], + ['writepoint_22',['writepoint',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a900fd57fc0067f496e31bb66d26d72a1',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, TGraph const &graph, Types::vertexId vertexId, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a9234cb13b3947c4d7e4e5f96d1cd33dd',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, TVertex const &vertex, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a84bf6a2084d762e25c5eeed5d0078c8a',1,'egoa::IO::GeoJsonWriter::WritePoint(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)']]], + ['writepointcoordinate_23',['writepointcoordinate',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a0c3b81ae05dabf37cfc8476b32f9d59a',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, Types::real xCoordinate, Types::real yCoordinate, Types::count indent=2)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a494bad1941c94315ec0cdae62ffe77d8',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, TGraph const &graph, Types::vertexId vertexId)'],['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a70369703edb90eb75964866639028d8f',1,'egoa::IO::GeoJsonWriter::WritePointCoordinate(std::ostream &os, TVertex const &vertex)']]], + ['writepropertiesbegin_24',['WritePropertiesBegin',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a642863479b23f0e2af1493e5695d0291',1,'egoa::IO::GeoJsonWriter']]], + ['writepropertiesend_25',['WritePropertiesEnd',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5def64f499a544c41fd15a8286ab36c1',1,'egoa::IO::GeoJsonWriter']]], + ['writevertexproperties_26',['WriteVertexProperties',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ac518cb0ce7e2563acca2c1073037f269',1,'egoa::IO::GeoJsonWriter']]], + ['writevertices_27',['WriteVertices',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5fdaab77ac47fa9b4ff87bd4e5f5c6f1',1,'egoa::IO::GeoJsonWriter']]] +]; diff --git a/search/functions_17.js b/search/functions_17.js new file mode 100644 index 00000000..fbcc4465 --- /dev/null +++ b/search/functions_17.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['zone_0',['zone',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a4748db1869c7a89935a0cf1be85e5872',1,'egoa::Vertices::ElectricalProperties::Zone() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a35bc0d019231d0e7ab9262b3aaa8903c',1,'egoa::Vertices::ElectricalProperties::Zone()']]] +]; diff --git a/search/functions_18.js b/search/functions_18.js new file mode 100644 index 00000000..34808062 --- /dev/null +++ b/search/functions_18.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['_7ebetweennesscentrality_0',['~BetweennessCentrality',['../classegoa_1_1_betweenness_centrality.html#a4dea8510cece6f21a3dbb0e8be51fd81',1,'egoa::BetweennessCentrality']]], + ['_7ebucketelement_1',['~BucketElement',['../classegoa_1_1_bucket_element.html#ae6a88619a340d4ba8a657fefb2e348a3',1,'egoa::BucketElement']]], + ['_7elabel_2',['~Label',['../classegoa_1_1_label.html#a4494f59f3612cf96565681d326a83196',1,'egoa::Label']]], + ['_7esusceptancenormlabel_3',['~SusceptanceNormLabel',['../classegoa_1_1_susceptance_norm_label.html#ad3b0233d45b405ed5e54a36bd3a82692',1,'egoa::SusceptanceNormLabel']]], + ['_7evoltageangledifferencelabel_4',['~VoltageAngleDifferenceLabel',['../classegoa_1_1_voltage_angle_difference_label.html#a9520741a9e44209cd308ea3d62f64db0',1,'egoa::VoltageAngleDifferenceLabel']]] +]; diff --git a/search/functions_2.js b/search/functions_2.js new file mode 100644 index 00000000..11905d47 --- /dev/null +++ b/search/functions_2.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['callback_0',['callback',['../classegoa_1_1_callback_empty.html#a4e52f67483c555935413350f0be82187',1,'egoa::CallbackEmpty']]], + ['callbackempty_1',['CallbackEmpty',['../classegoa_1_1_callback_empty.html#a5e0d6546be59310b523f35b9d56ef36c',1,'egoa::CallbackEmpty']]], + ['capitalcost_2',['capitalcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a6b5b57c65f01307a95ecf4a12ef68e01',1,'egoa::Vertices::GeneratorProperties::CapitalCost() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac7d904efcffabd3b1fdf7e85da59324d',1,'egoa::Vertices::GeneratorProperties::CapitalCost()']]], + ['carrier_3',['carrier',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a03064c5c65f5cc172eddb622c3691ab4',1,'egoa::Vertices::ElectricalProperties::Carrier() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a7058b1435a432f2e75e3637be42c2b97',1,'egoa::Vertices::ElectricalProperties::Carrier()']]], + ['changekey_4',['changekey',['../classegoa_1_1_binary_heap.html#a32f301375717a4abda57aeff9aa2b8d7',1,'egoa::BinaryHeap::ChangeKey()'],['../classegoa_1_1_mapping_binary_heap.html#a70b78d6ff717bdb9fdae6546264d9da2',1,'egoa::MappingBinaryHeap::ChangeKey()']]], + ['clear_5',['clear',['../classegoa_1_1_dominating_theta_path.html#aae5af8526bc9d9801b5eec759c0ea570',1,'egoa::DominatingThetaPath::Clear()'],['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#a6610c78a3b19bfcefa408e289dfd0bf5',1,'egoa::IO::DtpRuntimeCollection::Clear()'],['../classegoa_1_1_mapping_binary_heap.html#acbda4dfd6050c4a42e4bfe358dcf2c17',1,'egoa::MappingBinaryHeap::Clear()'],['../classegoa_1_1_bucket.html#a079a770091b121c8f49847808093787e',1,'egoa::Bucket::Clear()'],['../classegoa_1_1_binary_heap.html#ae02a88c3d74658f65aeee90648b80e04',1,'egoa::BinaryHeap::Clear()'],['../classegoa_1_1_traversal.html#a16a8f3d5368e56afc35166b2fc303808',1,'egoa::Traversal::Clear()'],['../classegoa_1_1_betweenness_centrality.html#ad3f95270ddc70955c916bfcfcb2b32ff',1,'egoa::BetweennessCentrality::Clear(TNumberOfPaths &numberOfPaths, TRelativeNumberOfPaths &relativeNumberOfPaths)'],['../classegoa_1_1_betweenness_centrality.html#a726a482ac4015caf4f88e636882069ca',1,'egoa::BetweennessCentrality::Clear()']]], + ['collection_6',['collection',['../classegoa_1_1_betweenness_centrality.html#a6cdf654836aae93382f109c091320c49',1,'egoa::BetweennessCentrality::Collection() const'],['../classegoa_1_1_betweenness_centrality.html#ad7d0e598a45f218bdaa8cfa2b56a58f5',1,'egoa::BetweennessCentrality::Collection()']]], + ['committable_7',['committable',['../classegoa_1_1_vertices_1_1_generator_properties.html#a4c36abad4e60e301625934b6dcd560b2',1,'egoa::Vertices::GeneratorProperties::Committable() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1d6a8938801c4130e2cd3989a8f8673e',1,'egoa::Vertices::GeneratorProperties::Committable()']]], + ['comparator_8',['comparator',['../classegoa_1_1_binary_heap.html#ac263b671464c498a474846c992ea7be0',1,'egoa::BinaryHeap::Comparator()'],['../classegoa_1_1_mapping_binary_heap.html#abb772637c836e22f4a54faa6e569f7cf',1,'egoa::MappingBinaryHeap::Comparator()'],['../classegoa_1_1_binary_heap.html#aad4e0b63b85863dffe5d10f9d662ac6b',1,'egoa::BinaryHeap::Comparator()'],['../classegoa_1_1_mapping_binary_heap.html#a686e4897e64991add589aacbcd1f811f',1,'egoa::MappingBinaryHeap::Comparator()']]], + ['complyheapproperty_9',['complyheapproperty',['../classegoa_1_1_binary_heap.html#a4bb0c3733563757bd2f93a21f463a760',1,'egoa::BinaryHeap::ComplyHeapProperty(Types::index index) const'],['../classegoa_1_1_binary_heap.html#abdb707e89c827b6e85e02b402f8641be',1,'egoa::BinaryHeap::ComplyHeapProperty() const'],['../classegoa_1_1_mapping_binary_heap.html#a3fc10be4cd1134c62633ae4f4485e966',1,'egoa::MappingBinaryHeap::ComplyHeapProperty() const'],['../classegoa_1_1_mapping_binary_heap.html#a4e413014e12198bdb7c0fe3b3b246832',1,'egoa::MappingBinaryHeap::ComplyHeapProperty(Types::index index) const']]], + ['compressstring_10',['CompressString',['../classegoa_1_1_py_psa_parser.html#a4a496bc83188bafb13caad13aaf19cf0',1,'egoa::PyPsaParser']]], + ['conductance_11',['conductance',['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_a_c_01_4.html#ad0df5cdde3487031ac2c8104b7e9e365',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::AC >::Conductance()'],['../classegoa_1_1_edges_1_1_carrier_differentiation_3_01_edges_1_1_carrier_differentiation_type_1_1_d_c_01_4.html#a530d0988b2983ee14dde99a0a1972925',1,'egoa::Edges::CarrierDifferentiation< Edges::CarrierDifferentiationType::DC >::Conductance()']]], + ['control_12',['control',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a8d1579c39b1bb4bb25e4324ec5dc63a6',1,'egoa::Vertices::ElectricalProperties::Control()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aa5348d489ace5975cbd792772a5aff1a',1,'egoa::Vertices::GeneratorProperties::Control()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#af42b85bfea7d5434818bd34c0e3984e9',1,'egoa::Vertices::GeneratorProperties::Control() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a0493d7a5e96c379dc5946a58a52eea4e',1,'egoa::Vertices::ElectricalProperties::Control()']]], + ['country_13',['country',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a488f1c1601f980c4a1bb8f397540842d',1,'egoa::Vertices::ElectricalProperties::Country() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6480106fe6180e5e2d8706a845ea3a57',1,'egoa::Vertices::ElectricalProperties::Country()']]], + ['currentblockid_14',['CurrentBlockId',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#a0418f23a4971f0e310a005869397922c',1,'egoa::internal::BlockCutTreeBuilder']]], + ['cutvertexat_15',['CutVertexAt',['../classegoa_1_1_block_cut_tree.html#aa01116b5db1c97981955bdb543201ee3',1,'egoa::BlockCutTree']]], + ['cutvertices_16',['CutVertices',['../classegoa_1_1_block_cut_tree_1_1_block.html#abb19621690dd330e8b8ef11cb3f7ae02',1,'egoa::BlockCutTree::Block']]] +]; diff --git a/search/functions_3.js b/search/functions_3.js new file mode 100644 index 00000000..e4467377 --- /dev/null +++ b/search/functions_3.js @@ -0,0 +1,14 @@ +var searchData= +[ + ['decreasekey_0',['DecreaseKey',['../classegoa_1_1_binary_heap.html#a356c3c1e41ee36b6e60e5062ce207f76',1,'egoa::BinaryHeap']]], + ['degreeat_1',['degreeat',['../classegoa_1_1_dynamic_graph.html#a2a1b9ba2254788fda5a506e7bd017be9',1,'egoa::DynamicGraph::DegreeAt()'],['../classegoa_1_1_static_graph.html#af3e1e2192a82df308586cd33bcd2ba06',1,'egoa::StaticGraph::DegreeAt()']]], + ['delete_2',['Delete',['../classegoa_1_1_mapping_binary_heap.html#a031670180172a3688c132f3c68e5cd85',1,'egoa::MappingBinaryHeap']]], + ['deletetop_3',['deletetop',['../classegoa_1_1_binary_heap.html#a0d3efd2287a24e752ab10bd69b1b7cdf',1,'egoa::BinaryHeap::DeleteTop()'],['../classegoa_1_1_bucket.html#aa290c3db7f4f6a2867a04a0811864cff',1,'egoa::Bucket::DeleteTop()'],['../classegoa_1_1_mapping_binary_heap.html#a4d741d83c77f4e05c506c66896efb874',1,'egoa::MappingBinaryHeap::DeleteTop()']]], + ['depthfirstsearch_4',['DepthFirstSearch',['../classegoa_1_1_depth_first_search.html#ac4af467357c5d9343548fb0ae933e369',1,'egoa::DepthFirstSearch']]], + ['dequeuevertex_5',['DequeueVertex',['../classegoa_1_1_b_f_s.html#a168fd3b51fe0e1f4f5b9f28d1b513e75',1,'egoa::BFS']]], + ['dominates_6',['Dominates',['../classegoa_1_1_bucket.html#a7e33691f54908fcc6530e41333f0e46e',1,'egoa::Bucket']]], + ['dominatingthetapath_7',['dominatingthetapath',['../classegoa_1_1_dominating_theta_path.html#af8fe08362087e9c8a01875c457c2599c',1,'egoa::DominatingThetaPath::DominatingThetaPath(TGraph const &graph)'],['../classegoa_1_1_dominating_theta_path.html#affe6bf56c3e86b4dd5a9ec4f405c872f',1,'egoa::DominatingThetaPath::DominatingThetaPath(TGraph const &graph, TVertexId source)']]], + ['dumpbranches_8',['DumpBranches',['../classegoa_1_1_static_graph.html#ac436ac9f1ccaf66f05bdd5db6a9207d4',1,'egoa::StaticGraph']]], + ['dumpbuses_9',['DumpBuses',['../classegoa_1_1_static_graph.html#aefcd3022d222d4c6a2dabedc73cb500f',1,'egoa::StaticGraph']]], + ['dynamicgraph_10',['DynamicGraph',['../classegoa_1_1_dynamic_graph.html#a9ee4ffd9898c33853d61c227665da257',1,'egoa::DynamicGraph']]] +]; diff --git a/search/functions_4.js b/search/functions_4.js new file mode 100644 index 00000000..960b1364 --- /dev/null +++ b/search/functions_4.js @@ -0,0 +1,25 @@ +var searchData= +[ + ['edge_0',['edge',['../classegoa_1_1_dynamic_graph.html#abb8fea91b2be3d60fff358f01b5dc7c5',1,'egoa::DynamicGraph::Edge(Types::vertexId source, Types::vertexId target) const'],['../classegoa_1_1_dynamic_graph.html#a32b554140f95c4ac708ce8ce43171a29',1,'egoa::DynamicGraph::Edge(Types::vertexId source, Types::vertexId target)'],['../classegoa_1_1_static_graph.html#a24aa79b734e23ec6cec7cc03e4b91e43',1,'egoa::StaticGraph::Edge(Types::vertexId source, Types::vertexId target) const'],['../classegoa_1_1_static_graph.html#a0c9f6fa55ef57510c79729b99bde929f',1,'egoa::StaticGraph::Edge(Types::vertexId source, Types::vertexId target)']]], + ['edgeat_1',['edgeat',['../classegoa_1_1_dynamic_graph.html#adc8d7afadb434fe0fbe760f0970fdf8d',1,'egoa::DynamicGraph::EdgeAt(Types::edgeId id)'],['../classegoa_1_1_dynamic_graph.html#a3244fc4ae09b639bdbd2e74c9a12aaf8',1,'egoa::DynamicGraph::EdgeAt(Types::edgeId id) const'],['../classegoa_1_1_static_graph.html#a10d486bd8274d1ce8c5ccf0cf47d26a7',1,'egoa::StaticGraph::EdgeAt(Types::edgeId id)'],['../classegoa_1_1_static_graph.html#abfa8efe41c4018083b645b499d4de7e5',1,'egoa::StaticGraph::EdgeAt(Types::edgeId id) const']]], + ['edgeexists_2',['edgeexists',['../classegoa_1_1_dynamic_graph.html#ad149f47e6565706c381c2cfafceb2b51',1,'egoa::DynamicGraph::EdgeExists()'],['../classegoa_1_1_static_graph.html#a7f2495997d905bdb52753866ac790ede',1,'egoa::StaticGraph::EdgeExists()']]], + ['edgeid_3',['edgeid',['../classegoa_1_1_dynamic_graph.html#a1e438958e16b55645d58856750cbfc92',1,'egoa::DynamicGraph::EdgeId()'],['../classegoa_1_1_static_graph.html#a4ed0a34dd2b305dbc8463206972665ea',1,'egoa::StaticGraph::EdgeId()']]], + ['edgeidsat_4',['edgeidsat',['../classegoa_1_1_dynamic_graph.html#a7aa5848a1c287dde558f4135fab13517',1,'egoa::DynamicGraph::EdgeIdsAt()'],['../classegoa_1_1_static_graph.html#a0b4cdfbba3b86015e99fd81eba8766b2',1,'egoa::StaticGraph::EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const'],['../classegoa_1_1_static_graph.html#aa3c01ce2db959c0cd055d5b3ec6e5439',1,'egoa::StaticGraph::EdgeIdsAt(Types::vertexId id) const'],['../classegoa_1_1_dynamic_graph.html#aee19490a79f77a34e85958e56e8e2144',1,'egoa::DynamicGraph::EdgeIdsAt(Types::vertexId id, std::vector< Types::edgeId > &edgeIds) const']]], + ['edges_5',['edges',['../classegoa_1_1_dynamic_graph.html#ac4d6b3c7fa7e6109040afbab966e2430',1,'egoa::DynamicGraph::Edges()'],['../classegoa_1_1_dynamic_graph.html#ae35b1600e1771a861b7ba1b9a02de89d',1,'egoa::DynamicGraph::Edges() const'],['../classegoa_1_1_static_graph.html#a38e67ce8dc03be3dba7dda765b82e87b',1,'egoa::StaticGraph::Edges()'],['../classegoa_1_1_static_graph.html#a7d8adace9442cbddf9ddacc577d49efc',1,'egoa::StaticGraph::Edges() const'],['../classegoa_1_1_subgraph.html#a88d8ecd65b4e1104b6d8b8e46d15964c',1,'egoa::Subgraph::Edges()']]], + ['efficiency_6',['efficiency',['../classegoa_1_1_vertices_1_1_generator_properties.html#ae069e33e6b158f62d1e53f65436870b0',1,'egoa::Vertices::GeneratorProperties::Efficiency()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a97fbddc5183d914c53343d4e61951782',1,'egoa::Vertices::GeneratorProperties::Efficiency() const']]], + ['electricalproperties_7',['ElectricalProperties',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a9bf6a104189abd1c9e7f46ed1bec4c98',1,'egoa::Vertices::ElectricalProperties']]], + ['elementat_8',['ElementAt',['../classegoa_1_1_bucket.html#a147561d4064e0ee6e9aa5c94059a4517',1,'egoa::Bucket']]], + ['emplace_9',['emplace',['../classegoa_1_1_binary_heap.html#a09548553ba14903bbcbdb76d65525560',1,'egoa::BinaryHeap::Emplace()'],['../classegoa_1_1_mapping_binary_heap.html#ad10dedadc40f74caa355981e6920ec0d',1,'egoa::MappingBinaryHeap::Emplace()']]], + ['empty_10',['empty',['../classegoa_1_1_binary_heap.html#a1cb3be2538725fa3507b839685bf8842',1,'egoa::BinaryHeap::Empty()'],['../classegoa_1_1_bucket.html#a520be7a55da5c0e833c7991e28d81d9b',1,'egoa::Bucket::Empty()'],['../classegoa_1_1_mapping_binary_heap.html#ab02fdcef7529f80eed87910f30b26a9b',1,'egoa::MappingBinaryHeap::Empty()'],['../classegoa_1_1_priority_queue.html#abd6d3009ac4bf71bbd07c125ccfb430f',1,'egoa::PriorityQueue::Empty()'],['../classegoa_1_1_queue.html#a85707412da73925d6550f1493d1c99d7',1,'egoa::Queue::Empty()'],['../classegoa_1_1_std_queue.html#a7369bfe19bbd6819d4308d08bad9f521',1,'egoa::StdQueue::Empty()']]], + ['emptyqueue_11',['EmptyQueue',['../classegoa_1_1_bucket.html#a366d0b9fa492768c44a96c990a970df7',1,'egoa::Bucket']]], + ['end_12',['end',['../classegoa_1_1_binary_heap.html#a99391e079755c46f1420ef4456470bab',1,'egoa::BinaryHeap']]], + ['enqueuevertexwith_13',['EnqueueVertexWith',['../classegoa_1_1_b_f_s.html#ab487b4204397892869cb9dd0d7a88e4d',1,'egoa::BFS']]], + ['entrytimeat_14',['EntryTimeAt',['../classegoa_1_1_depth_first_search.html#a9dce9b349b010225c162de99d367c5cf',1,'egoa::DepthFirstSearch']]], + ['exittimeat_15',['ExitTimeAt',['../classegoa_1_1_depth_first_search.html#a11e41dff0d8c2be6ec745f668307aa8c',1,'egoa::DepthFirstSearch']]], + ['extractbusheader_16',['ExtractBusHeader',['../classegoa_1_1_py_psa_parser.html#a32e8d95122b25ec21c03da929a693345',1,'egoa::PyPsaParser']]], + ['extractgeneratorheader_17',['ExtractGeneratorHeader',['../classegoa_1_1_py_psa_parser.html#a0054068f7f6a1907c018b43d697c2915',1,'egoa::PyPsaParser']]], + ['extractgeneratormaximumrealpowerpuheader_18',['ExtractGeneratorMaximumRealPowerPuHeader',['../classegoa_1_1_py_psa_parser.html#a5d7e5a87c8f58b94070ee9dbe3049d04',1,'egoa::PyPsaParser']]], + ['extractlineheader_19',['ExtractLineHeader',['../classegoa_1_1_py_psa_parser.html#ae759e235d270b5684268705973da0cf2',1,'egoa::PyPsaParser']]], + ['extractloadheader_20',['ExtractLoadHeader',['../classegoa_1_1_py_psa_parser.html#a15e8a2ed2af474095e31d3485e7955c5',1,'egoa::PyPsaParser']]], + ['extractloadmaximumrealpowerpuheader_21',['ExtractLoadMaximumRealPowerPuHeader',['../classegoa_1_1_py_psa_parser.html#a029ede340ed897d5084f09e772b2b0fe',1,'egoa::PyPsaParser']]] +]; diff --git a/search/functions_5.js b/search/functions_5.js new file mode 100644 index 00000000..ece667e7 --- /dev/null +++ b/search/functions_5.js @@ -0,0 +1,38 @@ +var searchData= +[ + ['find_0',['Find',['../classegoa_1_1_union_find.html#afc852c1f07799b2459f724e82ef00779',1,'egoa::UnionFind']]], + ['findgenerator_1',['FindGenerator',['../classegoa_1_1_power_grid.html#a256d43c2c8befe79409f9c9fa6263e19',1,'egoa::PowerGrid']]], + ['for_5fall_5fedge_5fidentifiers_2',['for_all_edge_identifiers',['../classegoa_1_1_dynamic_graph.html#a0db535d6ce676f5cd3478d2f339e486c',1,'egoa::DynamicGraph::for_all_edge_identifiers()'],['../classegoa_1_1_static_graph.html#ab32d1f05556899ebcc6a498bad61cbf0',1,'egoa::StaticGraph::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#aab9ec6fd869cb7336854685ec286d289',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a085b9bc5c1ce4e2c869d669b31969a3a',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a46b65d677464470956399fd182be17b3',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#ae5b677549e13b241f9761819d2cefb23',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_identifiers()']]], + ['for_5fall_5fedge_5ftuples_3',['for_all_edge_tuples',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a4466f5d1e50e54bfcfd48f33d2ae6e08',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#add9f5a994ba727e88cb84db45c51a9fd',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a6ff9010bb924b4bd4fab6ecd8962e9c8',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edge_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ac285583b569683d732c970fc4c513285',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edge_tuples()'],['../classegoa_1_1_static_graph.html#ab8c2f88068bf29e5035dbe3acc268a79',1,'egoa::StaticGraph::for_all_edge_tuples()'],['../classegoa_1_1_dynamic_graph.html#a84f9eb4426920b429672bfcffe440ff8',1,'egoa::DynamicGraph::for_all_edge_tuples(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a85ea26e0c59adc440259c1aab98807fd',1,'egoa::DynamicGraph::for_all_edge_tuples(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a704f35ddb41531e6819d8a624ba4a37a',1,'egoa::StaticGraph::for_all_edge_tuples()']]], + ['for_5fall_5fedges_4',['for_all_edges',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#af0d6197aef75ca5163b479a5bfa8b304',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a81419fa17be4f6262394e9a3a997a3b9',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges()'],['../classegoa_1_1_static_graph.html#aefc8cf433d543a27f5370582913e9a34',1,'egoa::StaticGraph::for_all_edges(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a85558eac6502980273f8978ea2f23590',1,'egoa::StaticGraph::for_all_edges(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a87f2ba6ec2afbf45f62ae8fd02d56627',1,'egoa::DynamicGraph::for_all_edges(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a5d252f761a80d2e82ba86c5210e343bc',1,'egoa::DynamicGraph::for_all_edges(FUNCTION function)']]], + ['for_5fall_5fedges_5fat_5',['for_all_edges_at',['../classegoa_1_1_dynamic_graph.html#a4380e9e5d38e08a96d24639b4cea1202',1,'egoa::DynamicGraph::for_all_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#acd6b8abd14d663fbb5c8cc0694fe4352',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a882df05ab717cd11b0f47754f859951d',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ad61755bdc17e393bf2ea9f1f004e0240',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ac907286942ad2f6488f0475140b85898',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#aaf876b41ea6b985473670091f5c4c3ae',1,'egoa::StaticGraph::for_all_edges_at(Types::vertexId const vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a1bd5f0e1067ae1f83da797c357d3f1f3',1,'egoa::StaticGraph::for_all_edges_at(Types::vertexId const vertexId, FUNCTION function)'],['../classegoa_1_1_static_graph.html#afac98456be676c3cd00a77dca3e89184',1,'egoa::StaticGraph::for_all_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#a0675a89b27800b80ce954cdf551aa196',1,'egoa::DynamicGraph::for_all_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a836e06d876dbf323c378361d795120e3',1,'egoa::DynamicGraph::for_all_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_traversal.html#af94c3778ec612022824238d75f5b07ea',1,'egoa::Traversal::for_all_edges_at()'],['../classegoa_1_1_dynamic_graph.html#a5962842d31b050f7d6f5566b1122c834',1,'egoa::DynamicGraph::for_all_edges_at()'],['../classegoa_1_1_static_graph.html#a2cc423a3b75fbef801b91cfb73ce9e69',1,'egoa::StaticGraph::for_all_edges_at()']]], + ['for_5fall_5felements_6',['for_all_elements',['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1sequential_01_4.html#a8dd010f82b1969f4466a69ced894fce6',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::sequential >::for_all_elements()'],['../classegoa_1_1_mapping_binary_heap.html#a269321aad4a6a0b3dae5247447a78e9b',1,'egoa::MappingBinaryHeap::for_all_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a123f9994802f624e4d033bdc10de563a',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_elements()'],['../classegoa_1_1_bucket.html#a9d2ff7a391da969a584f651725c28b5f',1,'egoa::Bucket::for_all_elements(FUNCTION function) const'],['../classegoa_1_1_bucket.html#aebda6283d988bd6e429a20cb2584a262',1,'egoa::Bucket::for_all_elements(FUNCTION function)'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_01const_00_01_execution_policy_1_1breakable_01_4.html#a0d123607a59c7efe14fd401ccc09b1de',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType const, ExecutionPolicy::breakable >::for_all_elements()'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1breakable_01_4.html#a47a694df50a67aa99fd1dc702a77ea74',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::breakable >::for_all_elements()'],['../classegoa_1_1internal_1_1_binary_heap_loop_differentiation_3_01_heap_type_00_01_execution_policy_1_1sequential_01_4.html#a622e22c9eebb80c4288e7c4e95dd0e92',1,'egoa::internal::BinaryHeapLoopDifferentiation< HeapType, ExecutionPolicy::sequential >::for_all_elements()'],['../classegoa_1_1_binary_heap.html#a118ad41218d536db12cf983edc8513cd',1,'egoa::BinaryHeap::for_all_elements(FUNCTION function) const'],['../classegoa_1_1_binary_heap.html#a467eab42a0b77e307faac25b081414a3',1,'egoa::BinaryHeap::for_all_elements(FUNCTION function)']]], + ['for_5fall_5fgenerator_5fidentifiers_5fat_7',['for_all_generator_identifiers_at',['../classegoa_1_1_power_grid.html#a9f15c10128ee3f7b9fe16c43ebfe7337',1,'egoa::PowerGrid::for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#aab0e2095dee9e8d070ce324c46649153',1,'egoa::PowerGrid::for_all_generator_identifiers_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a7793963690cabad12caf17d462d269e1',1,'egoa::PowerGrid::for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#af78a7e6f8681c915b7e57ca9060633dc',1,'egoa::PowerGrid::for_all_generator_identifiers_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a7072516a00a04296bde02cef9dae27d4',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ace15ff65ad72268ee5a91da7c59907e9',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)']]], + ['for_5fall_5fgenerator_5ftuple_8',['for_all_generator_tuple',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a1f124662e0784ad91c0fbc65474afcd3',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple()'],['../classegoa_1_1_power_grid.html#a914604e39470bcb73c5f5d74b406a4d2',1,'egoa::PowerGrid::for_all_generator_tuple()'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ad3b4df097d9b1011c4035e5b5585ab8a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generator_tuple()'],['../classegoa_1_1_power_grid.html#a4bd9d6916c91b481000f8f64ef354835',1,'egoa::PowerGrid::for_all_generator_tuple()']]], + ['for_5fall_5fgenerators_9',['for_all_generators',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a4839dfea41b399d21be7837fb508fc54',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a17635fc42b1de71ccd6b29b5533ac8ea',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#afa5a1f61d19d6553395d86876892167b',1,'egoa::PowerGrid::for_all_generators(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a8fca0b6824734d49ccebf54faf4e5829',1,'egoa::PowerGrid::for_all_generators(FUNCTION function) const']]], + ['for_5fall_5fgenerators_5fat_10',['for_all_generators_at',['../classegoa_1_1_power_grid.html#ae4a792ea4ffc3376dea6dcabb0d0dbda',1,'egoa::PowerGrid::for_all_generators_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a248f9c9f9bba1ef5a77e03945ee41e96',1,'egoa::PowerGrid::for_all_generators_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#aa1f860141ac00eaeefb4685112bf489c',1,'egoa::PowerGrid::for_all_generators_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a786360de24038fb411f815aed0d26252',1,'egoa::PowerGrid::for_all_generators_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a80fbee5fdd9c2dd26d7587b4d2250f14',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a99376951dead16a7078189be98cec379',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(Types::vertexId const vertexId, TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aab0b4332dda6591959c290b84b3a67dd',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8b53975501afff5a061c0b7ff7e8bc76',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_at(TVertex const &vertex, TNetwork &network, FUNCTION function)']]], + ['for_5fall_5fgenerators_5ftuple_11',['for_all_generators_tuple',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a297aa3276bfb6cf135ec140fa7c9a697',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a9529d8e2adc6084dfcf6ab7131e82e38',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_generators_tuple(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab8c2fa98fa9d9da849291547c58f1ca6',1,'egoa::PowerGrid::for_all_generators_tuple(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a9fe0ddf7c0edcac9793c052c999de4f8',1,'egoa::PowerGrid::for_all_generators_tuple(FUNCTION function) const']]], + ['for_5fall_5fload_5fidentifiers_5fat_12',['for_all_load_identifiers_at',['../classegoa_1_1_power_grid.html#a07f32fa9850cc3a8c088afbb4cc73d6a',1,'egoa::PowerGrid::for_all_load_identifiers_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#af74475869bbbe88123691e5499eece26',1,'egoa::PowerGrid::for_all_load_identifiers_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acbe67421dd0a657604c7adf608eb211d',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at(Types::vertexId vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a5e8f6a100c3519d110d4e81300f4797b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_identifiers_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)']]], + ['for_5fall_5fload_5ftuples_13',['for_all_load_tuples',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a7622762b570cbe597fe8c6982986d690',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a72559f9e00d1c9f22ccc295cad680825',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_load_tuples(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab747c5386d374121dc7c8e13a42b637a',1,'egoa::PowerGrid::for_all_load_tuples(FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac0524bf3d82bbf4e48b436d481a6715c',1,'egoa::PowerGrid::for_all_load_tuples(FUNCTION function) const']]], + ['for_5fall_5floads_14',['for_all_loads',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ad05db4c846174801299eed9d1ded98ac',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads(TNetwork &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a4ca3a16313ddc82b1c88eb4acfcc3802',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads(TNetwork const &network, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac0bd33d791239365c809dcc1f8bfdce6',1,'egoa::PowerGrid::for_all_loads(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a151de9659ceb1e7eebdb338f5d9b7a49',1,'egoa::PowerGrid::for_all_loads(FUNCTION function) const']]], + ['for_5fall_5floads_5fat_15',['for_all_loads_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af275f89cc6dbc053bd354f18b18c9356',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at()'],['../classegoa_1_1_power_grid.html#aa1e39abe64701ab59a0fc9c10df304d3',1,'egoa::PowerGrid::for_all_loads_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a8b0ae62c5b93adf4a3f92781ad6d7c5c',1,'egoa::PowerGrid::for_all_loads_at(Types::vertexId const vertexId, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac9e6fe7351b505995b846a39c098ca22',1,'egoa::PowerGrid::for_all_loads_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a56911873b4fff331788930e50d696400',1,'egoa::PowerGrid::for_all_loads_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a10d86ac105c18a29b1347b3602451330',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(Types::vertexId const vertexId, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a467e583d036affc5913b3e4cd8f1aea7',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(TVertex const &vertex, TNetwork const &network, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aea678c72a45bcd278d7e26318d433ee9',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_at(TVertex const &vertex, TNetwork &network, FUNCTION function)']]], + ['for_5fall_5floads_5ftuple_16',['for_all_loads_tuple',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a828e84937c6ac07a2dd1236a07c48f27',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_loads_tuple()'],['../classegoa_1_1_power_grid.html#a51d12376204605f2e6ab1ca5e93610bb',1,'egoa::PowerGrid::for_all_loads_tuple()']]], + ['for_5fall_5foptima_17',['for_all_optima',['../classegoa_1_1_bucket.html#a2757d42dbb9835cb82c7382b84dd6e2d',1,'egoa::Bucket::for_all_optima(FUNCTION function)'],['../classegoa_1_1_bucket.html#a455e56655e99772b31abbfd50e5a018c',1,'egoa::Bucket::for_all_optima(FUNCTION function) const'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#acb9806e18e9d6251a99f0230c93841da',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_optima(BucketType &bucket, FUNCTION function)']]], + ['for_5fall_5fprocessed_5felements_18',['for_all_processed_elements',['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a4a360a7106767d6a90ca17a5fcf6ee74',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_processed_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html#a9685c16e7f128604a0e3d64ae2952d61',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_processed_elements()'],['../classegoa_1_1_bucket.html#ac0ddb8197cd5c0a6c42cb21d78a3868a',1,'egoa::Bucket::for_all_processed_elements(FUNCTION function)'],['../classegoa_1_1_bucket.html#abc7d92a50a659392264bcb73a1099aa7',1,'egoa::Bucket::for_all_processed_elements(FUNCTION function) const']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_19',['for_all_real_power_generator_snapshots',['../classegoa_1_1_power_grid.html#a24bb541d6c03c6a82c2ee390886986ca',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots(FUNCTION function)'],['../classegoa_1_1_power_grid.html#ac3939c8260d8ef2b5f06eb127fcd83c0',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots(FUNCTION function) const'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a26f3a9f3bbb9541c7999b7820ce7060e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots()']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_5fat_20',['for_all_real_power_generator_snapshots_at',['../classegoa_1_1_power_grid.html#a6dc56608af4b8a66020b4bd89b6cdb25',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a6e097493c494f181ec9ee2744c1512db',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a3f2270751eae0ca52bf96d39dbd0c9e1',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ab82056f632d6f654a455add5b6e61684',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a1f4d5d6490c71fd603a27ea7fbf824d8',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#ae75545ac4a43eaef40717188965d72c5',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#af343164f39f28e735f7dad1454a82ceb',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a9ca374d55ea64a0afbc2346d394fced4',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#afc58d667b2000aff6451e2a229c1f04a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af5d1f55afb146f06bdf2c12331f3a72a',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#af04527e74bf1d595e9e6b13dd9a40155',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#ae95233fd172e4ee987b18a27be64b83f',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_at(TNetwork &network, Types::vertexId vertexId, FUNCTION function)']]], + ['for_5fall_5freal_5fpower_5fgenerator_5fsnapshots_5fof_21',['for_all_real_power_generator_snapshots_of',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a41c71bafd9d58ce41cea8cbe11966b1e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of()'],['../classegoa_1_1_power_grid.html#ac5e96be0b0cca689a0759298db7bf7e4',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a1a4c2f3af0f9083785a9d37c8fdb0124',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(TGeneratorProperties const &generatorProperties, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a9eb6bebb9c37bebdc9e06ce59ce003fd',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(Types::vertexId generatorId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#ac0b82a01f9c23816914eb2b35d5b7164',1,'egoa::PowerGrid::for_all_real_power_generator_snapshots_of(Types::generatorId generatorId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acc2630455cd1dc0a92d946e10992c967',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_generator_snapshots_of(TNetwork &network, TGeneratorProperties generatorProperties, FUNCTION function)']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_22',['for_all_real_power_load_snapshots',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8ff69ad22302da58ea0037ed97e2a40b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots()'],['../classegoa_1_1_power_grid.html#adf8c406310a64a35ec11534aa4b2dbdf',1,'egoa::PowerGrid::for_all_real_power_load_snapshots(FUNCTION function)'],['../classegoa_1_1_power_grid.html#aca5b3d7ecc1170dc4954f6103876181a',1,'egoa::PowerGrid::for_all_real_power_load_snapshots(FUNCTION function) const']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_5fat_23',['for_all_real_power_load_snapshots_at',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a8dde318094247fe00105bee852add84f',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at()'],['../classegoa_1_1_power_grid.html#a24989b7a0cf456433c1be71e6a2ab034',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#aae9c104f8927551b784d8c5f58cf604c',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a88654d841924f19935cb00f3171e9002',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a24bfc25ba0ada6d902bc0fe82fc61f63',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a8d57e38322b1d67f4e86fecb1e461f3d',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a338c9d791f322b63852d8d068bb160a4',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#ad7a4ae966fd70ecea1ed3fdcf111f354',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#abf8087cb2c8ffe8bf3e60cf4771714fe',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a76f3ed337cc1a58280b6c4977316d337',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, Types::vertexId vertexId, Types::index timestampPosition, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#aaab0f623992d7ebe3a30ca759331ca93',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_at(TNetwork &network, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a9bad768202ef78692f47db7aa4a3dbfd',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_at(TVertex const &vertex, FUNCTION function)']]], + ['for_5fall_5freal_5fpower_5fload_5fsnapshots_5fof_24',['for_all_real_power_load_snapshots_of',['../classegoa_1_1_power_grid.html#a49a07334084839f5547c5e5e7540cc4a',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(Types::vertexId loadId, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#ac5e14cb65997d0fe8d03b0242eabfdae',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(TLoadProperties const &load, FUNCTION function) const'],['../classegoa_1_1_power_grid.html#a2e04758a4e885b83a985d4e94912e106',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(TLoadProperties load, FUNCTION function)'],['../classegoa_1_1_power_grid.html#a1c8cb331193179d09d00a84b1c9b78c9',1,'egoa::PowerGrid::for_all_real_power_load_snapshots_of(Types::loadId loadId, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a18b00092a9e1725935c37a0afac2333b',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of(TNetwork &network, TLoadProperties const &loadProperties, FUNCTION function)'],['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a925b3a415d978991d3e3a5c2383ece8e',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_real_power_load_snapshots_of(TNetwork &network, Types::loadId loadId, FUNCTION function)']]], + ['for_5fall_5funprocessed_5felements_25',['for_all_unprocessed_elements',['../classegoa_1_1_bucket.html#a4aaa4636ef84d2964c802d38cb8f80c7',1,'egoa::Bucket::for_all_unprocessed_elements(FUNCTION function)'],['../classegoa_1_1_bucket.html#a515c8674de429d0b41f9edbd7bab9c9e',1,'egoa::Bucket::for_all_unprocessed_elements(FUNCTION function) const'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1sequential_01_4.html#a214cd2bc84034470e6be8e0878dfe337',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::sequential >::for_all_unprocessed_elements()'],['../classegoa_1_1internal_1_1_bucket_loop_differentiation_3_01_bucket_type_00_01_execution_policy_1_1breakable_01_4.html#aa4ed3c4a7ebc3387e0430867ce2b0549',1,'egoa::internal::BucketLoopDifferentiation< BucketType, ExecutionPolicy::breakable >::for_all_unprocessed_elements()']]], + ['for_5fall_5fvertex_5fidentifiers_26',['for_all_vertex_identifiers',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#acd8c48ee717298518da952720c5d166c',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#aca586b487c249c599ba3d126278fe2cb',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#af747d46980fb143b1108ef9015c044fc',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_identifiers()'],['../classegoa_1_1_static_graph.html#a1e49bca339e5152a73b4b1c178c45ebc',1,'egoa::StaticGraph::for_all_vertex_identifiers()'],['../classegoa_1_1_dynamic_graph.html#a0d5d739e8639809ad6e915bb5ff32ed5',1,'egoa::DynamicGraph::for_all_vertex_identifiers()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#af5a62d471a7a0b4a0cb8e5cdff156ba5',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_identifiers()']]], + ['for_5fall_5fvertex_5fidentifiers_5fwith_5fgenerator_27',['for_all_vertex_identifiers_with_generator',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#acf452b95df9c16ce9b23e043015bd5ca',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_generator()'],['../classegoa_1_1_power_grid.html#a0738102438224b118d98700501c89555',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_generator(FUNCTION function)'],['../classegoa_1_1_power_grid.html#a4476ae9f47608980f79d879c5aede1e9',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_generator(FUNCTION function) const']]], + ['for_5fall_5fvertex_5fidentifiers_5fwith_5fload_28',['for_all_vertex_identifiers_with_load',['../classegoa_1_1internal_1_1_power_grid_loop_differentiation_3_01_power_grid_type_00_01_execution_policy_1_1sequential_01_4.html#a766371ed685dc01541397c586dad2341',1,'egoa::internal::PowerGridLoopDifferentiation< PowerGridType, ExecutionPolicy::sequential >::for_all_vertex_identifiers_with_load()'],['../classegoa_1_1_power_grid.html#a5d34302d052c006b38a67541b9345784',1,'egoa::PowerGrid::for_all_vertex_identifiers_with_load()']]], + ['for_5fall_5fvertex_5ftuples_29',['for_all_vertex_tuples',['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a4a61f1bab1b240c7e5df03a75a11f8b0',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_static_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a02af5d227fcc9d4ccd703fdd71a48080',1,'egoa::internal::StaticGraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a08041035e1cdad2b1ab6ccfb62bc2d5d',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertex_tuples()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a560b34aa94508c399d248456baed557e',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertex_tuples()'],['../classegoa_1_1_static_graph.html#af471cc880484ccd9568cf8c05aa66c10',1,'egoa::StaticGraph::for_all_vertex_tuples()'],['../classegoa_1_1_dynamic_graph.html#a9b21fb8633493a721dd9fd7c86d67139',1,'egoa::DynamicGraph::for_all_vertex_tuples(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a488395c40b8b1037a48085733a7f7445',1,'egoa::DynamicGraph::for_all_vertex_tuples(FUNCTION function)'],['../classegoa_1_1_static_graph.html#a96ffb6ae4f80dd2d06dd9efa2c7e1bd9',1,'egoa::StaticGraph::for_all_vertex_tuples()']]], + ['for_5fall_5fvertices_30',['for_all_vertices',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a2762f1bd7bf7e8b35d0bdbebf969eec6',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_all_vertices()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#ab28f7676dd95f39989f5cc6efcac0ade',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_all_vertices()'],['../classegoa_1_1_static_graph.html#a05b98249c10ffd77c433b669d0357a3c',1,'egoa::StaticGraph::for_all_vertices(FUNCTION function) const'],['../classegoa_1_1_static_graph.html#ab845eb5468d07073919dc1b63a19ccbb',1,'egoa::StaticGraph::for_all_vertices(FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac6f1c598ba729d55012ed1dbc50afb93',1,'egoa::DynamicGraph::for_all_vertices(FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#af50c64e82afb018e47bb0d1c7424e21f',1,'egoa::DynamicGraph::for_all_vertices(FUNCTION function)']]], + ['for_5feach_31',['for_each',['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html#ad396264ea48693d4782f0fd50c1cd606',1,'egoa::internal::ContainerLoop< ExecutionPolicy::sequential >::for_each()'],['../structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html#a403cf8ee405b7262d2c6d06858baaf85',1,'egoa::internal::ContainerLoop< ExecutionPolicy::breakable >::for_each()']]], + ['for_5fin_5fedges_5fat_32',['for_in_edges_at',['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#aea0ed8ffc5ecbe95f56279a444594881',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at()'],['../classegoa_1_1_dynamic_graph.html#a6e2db098461cd06550600d10df87ffce',1,'egoa::DynamicGraph::for_in_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a8cfa293a4e265927f1f263bb5d49752b',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_in_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a5b5b5aa51474c8f4b2a71235f6ad41d0',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#a73ad21c23671ce859213b9648ced95f3',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_in_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ab1eda96d08c89827e306717c41c0d36a',1,'egoa::StaticGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#a736fe50fc467f6211e9c99d18a197734',1,'egoa::StaticGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#ae734137b1fe18cb9210d8869799ca53d',1,'egoa::StaticGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac1548686c754c60a007ffb515dbfddb7',1,'egoa::DynamicGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a18c7e8e30eb057eb03474d0c0c723a47',1,'egoa::DynamicGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ac01328b45d8f4e1fc693029f0e36043d',1,'egoa::DynamicGraph::for_in_edges_at(TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ad5de34af872cade4d1a646a2f4711fa6',1,'egoa::StaticGraph::for_in_edges_at(Types::vertexId vertexId, FUNCTION function)']]], + ['for_5fout_5fedges_5fat_33',['for_out_edges_at',['../classegoa_1_1_static_graph.html#ae1a29dcc02b48dbad7659efba12e3dda',1,'egoa::StaticGraph::for_out_edges_at()'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a4fca2d6191e681c9f71c9ef014a02561',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1breakable_01_4.html#a96b17ac2763c900cababbb319de9c008',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::breakable >::for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#acb4e60a503b9d3173949f150a83a9f12',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at(TGraph &graph, TVertexId vertexId, FUNCTION function)'],['../classegoa_1_1internal_1_1_graph_loop_differentiation_3_01_graph_type_00_01_execution_policy_1_1sequential_01_4.html#abd4abaa576ca241ed3b933326dd46010',1,'egoa::internal::GraphLoopDifferentiation< GraphType, ExecutionPolicy::sequential >::for_out_edges_at(TGraph &graph, TVertex const &vertex, FUNCTION function)'],['../classegoa_1_1_static_graph.html#ad4400b6856fcdd039b829d596793f7e2',1,'egoa::StaticGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_static_graph.html#aabc529cea06fd71b62aa8ce8e3f9ea74',1,'egoa::StaticGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_static_graph.html#a1ecc1624cc249363a90f5d3eebd90840',1,'egoa::StaticGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#aeed3e030912f13345fcc1cdc96375801',1,'egoa::DynamicGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#a751b57a8917a05543e7cd68919c66885',1,'egoa::DynamicGraph::for_out_edges_at(Types::vertexId vertexId, FUNCTION function)'],['../classegoa_1_1_dynamic_graph.html#ace01de5597a10359bb48dcbf3f1badd6',1,'egoa::DynamicGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function) const'],['../classegoa_1_1_dynamic_graph.html#ab0582ac9a7fccc42e6d64dba7a4ecb44',1,'egoa::DynamicGraph::for_out_edges_at(TVertex const &vertex, FUNCTION function)']]], + ['front_34',['front',['../classegoa_1_1_binary_heap.html#ae73b7103ada405e1a2b46f39c5abbaf3',1,'egoa::BinaryHeap::Front()'],['../classegoa_1_1_binary_heap.html#af7f0adca99fa2e17f7027534d07405b2',1,'egoa::BinaryHeap::Front() const']]] +]; diff --git a/search/functions_6.js b/search/functions_6.js new file mode 100644 index 00000000..20b391cc --- /dev/null +++ b/search/functions_6.js @@ -0,0 +1,16 @@ +var searchData= +[ + ['generatorat_0',['generatorat',['../classegoa_1_1_power_grid.html#a4497f89b77eaff6cc5d216ee560035b7',1,'egoa::PowerGrid::GeneratorAt(Types::generatorId generatorId) const'],['../classegoa_1_1_power_grid.html#a9ea9a0d8a6e911519f0461ee28d46740',1,'egoa::PowerGrid::GeneratorAt(Types::generatorId generatorId)']]], + ['generatorboundtype_1',['generatorboundtype',['../classegoa_1_1_power_grid.html#ab1e0bf2a1218aa798e1af3666e06daed',1,'egoa::PowerGrid::GeneratorBoundType() const'],['../classegoa_1_1_power_grid.html#a742c296a3edc8c6823697b5cb3e8966c',1,'egoa::PowerGrid::GeneratorBoundType()']]], + ['generatorid_2',['GeneratorId',['../classegoa_1_1_power_grid.html#ac053e77dc06debc43a279cd38eb64f49',1,'egoa::PowerGrid']]], + ['generatorids_3',['GeneratorIds',['../classegoa_1_1_power_grid.html#adc6d8fbda08381635645711cbd081a08',1,'egoa::PowerGrid']]], + ['generatorreactivepowersnapshotat_4',['generatorreactivepowersnapshotat',['../classegoa_1_1_power_grid.html#ad94e0678a5dfb01bca7277607c17cd3e',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#aa30259f29d5476178945e79a8d9967a8',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a268d1bcac149f17459a3bad7713c3a5b',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) const'],['../classegoa_1_1_power_grid.html#adc0ef5b1cc08bf55a1398e769a6ed54f',1,'egoa::PowerGrid::GeneratorReactivePowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) const']]], + ['generatorrealpowersnapshotat_5',['generatorrealpowersnapshotat',['../classegoa_1_1_power_grid.html#a3f43bcf6230ccbd0300dcc8d8efacd27',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::index timestampPosition) const'],['../classegoa_1_1_power_grid.html#a346bd4aeee1e26ff7db24ca426547972',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::index timestampPosition) const'],['../classegoa_1_1_power_grid.html#a6f6666208b518a136fe36d861fbef14a',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(TGeneratorProperties const &generator, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#adf10fef395323612441590e6346fa320',1,'egoa::PowerGrid::GeneratorRealPowerSnapshotAt(Types::generatorId generatorId, Types::timestampSnapshot timestamp) const']]], + ['generatorrealpowersnapshotsat_6',['GeneratorRealPowerSnapshotsAt',['../classegoa_1_1_power_grid.html#abe6926c64635811bcbe916ab934f4ee0',1,'egoa::PowerGrid']]], + ['generatorsat_7',['generatorsat',['../classegoa_1_1_power_grid.html#a58ec2214967be277601c7dfd3786457a',1,'egoa::PowerGrid::GeneratorsAt(Types::vertexId vertexId, std::vector< Types::generatorId > &generatorIds) const'],['../classegoa_1_1_power_grid.html#a0ad4b5825688ca7f02754dd5fb6aa7ca',1,'egoa::PowerGrid::GeneratorsAt(Types::vertexId vertexId, std::vector< TGeneratorProperties > &generators) const'],['../classegoa_1_1_power_grid.html#ade6fa8057ba911e08a26c121814ec93c',1,'egoa::PowerGrid::GeneratorsAt(TVertex const &vertex, std::vector< Types::generatorId > &generatorIds) const'],['../classegoa_1_1_power_grid.html#a7855270806af2620e13bf41338928e6c',1,'egoa::PowerGrid::GeneratorsAt(TVertex const &vertex, std::vector< TGeneratorProperties > &generators) const']]], + ['generatortype_8',['generatortype',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8b4a0cbc8f0baa96f078174edfd034e2',1,'egoa::Vertices::GeneratorProperties::GeneratorType() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a1f709c2e8c7baf71f2784fdd6eebd5d5',1,'egoa::Vertices::GeneratorProperties::GeneratorType()']]], + ['geojsonwriter_9',['GeoJsonWriter',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ace0bbb8ba7ac1833797a20b36d4109ac',1,'egoa::IO::GeoJsonWriter']]], + ['gotonextexistingelement_10',['GoToNextExistingElement',['../classegoa_1_1_omitting_iterator.html#ad101979a7c770516904e43845dc04880',1,'egoa::OmittingIterator']]], + ['gotopreviousexistingelement_11',['GoToPreviousExistingElement',['../classegoa_1_1_omitting_iterator.html#a178fbfd2cbaf850bee479578669f710e',1,'egoa::OmittingIterator']]], + ['graph_12',['graph',['../classegoa_1_1_block_cut_tree.html#a5d9382170f6ab487f40562acd72374cd',1,'egoa::BlockCutTree::Graph()'],['../classegoa_1_1_power_grid.html#a6e7271075a42a9b059814f94b3ae11d2',1,'egoa::PowerGrid::Graph() const'],['../classegoa_1_1_power_grid.html#a8e4e25ad797d1ea4df976068a8f38ddd',1,'egoa::PowerGrid::Graph()']]] +]; diff --git a/search/functions_7.js b/search/functions_7.js new file mode 100644 index 00000000..05c880f8 --- /dev/null +++ b/search/functions_7.js @@ -0,0 +1,13 @@ +var searchData= +[ + ['hascorrectsnapshotsizes_0',['HasCorrectSnapshotSizes',['../classegoa_1_1_py_psa_parser.html#a21231a5c4387284f7c2eb499b7ed19c4',1,'egoa::PyPsaParser']]], + ['haselement_1',['HasElement',['../classegoa_1_1_bucket.html#a02384b2094ae4b7d98b6ef5ed13f79bd',1,'egoa::Bucket']]], + ['haselementat_2',['HasElementAt',['../classegoa_1_1_bucket.html#ac68424a9e54d824e1cecb2d3569df16e',1,'egoa::Bucket']]], + ['hasgenerator_3',['hasgenerator',['../classegoa_1_1_power_grid.html#aa5ded3e2eac92539ba34e5f5ad0ce3d3',1,'egoa::PowerGrid::HasGenerator(Types::generatorId generatorId) const'],['../classegoa_1_1_power_grid.html#afb53002e834398e310716788d99d539b',1,'egoa::PowerGrid::HasGenerator(TGeneratorProperties const &generatorProperty) const']]], + ['hasgeneratorat_4',['hasgeneratorat',['../classegoa_1_1_power_grid.html#adbc86848f2a4bb027f2fb80ad5a143d2',1,'egoa::PowerGrid::HasGeneratorAt(Types::vertexId vertexId) const'],['../classegoa_1_1_power_grid.html#afc916a590e65d8db4b4f50914d4a919b',1,'egoa::PowerGrid::HasGeneratorAt(TVertex const &vertex) const']]], + ['haskeyof_5',['HasKeyOf',['../classegoa_1_1_mapping_binary_heap.html#a135da274c0727028ac71a1a77ab7a0ad',1,'egoa::MappingBinaryHeap']]], + ['hasload_6',['hasload',['../classegoa_1_1_power_grid.html#a59dd76eb1f73fc86b0ca995c9f3b61eb',1,'egoa::PowerGrid::HasLoad(Types::loadId loadId) const'],['../classegoa_1_1_power_grid.html#aa742c4990f7183a2bb73f522f45931ca',1,'egoa::PowerGrid::HasLoad(TLoadProperties const &load) const']]], + ['hasloadat_7',['hasloadat',['../classegoa_1_1_power_grid.html#a50de730d9790cf379e5c70d1ed9ae25e',1,'egoa::PowerGrid::HasLoadAt(Types::vertexId vertexId) const'],['../classegoa_1_1_power_grid.html#aebcdd827b1aeee0b3359e473a5752c0c',1,'egoa::PowerGrid::HasLoadAt(TVertex const &vertex) const']]], + ['header_8',['header',['../classegoa_1_1_edges_1_1_electrical_properties.html#a8bf9e9177d3834c6155ad025c1f60a84',1,'egoa::Edges::ElectricalProperties::Header()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a23818e78fedeff768386d484bdbd8614',1,'egoa::Vertices::ElectricalProperties::Header()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a4022450ef27de5aeaaff83509da9f924',1,'egoa::Vertices::GeneratorProperties::Header()']]], + ['headerlong_9',['headerlong',['../classegoa_1_1_edges_1_1_electrical_properties.html#a61088ee88b22229f1a81af9935dea372',1,'egoa::Edges::ElectricalProperties::HeaderLong()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a09f85ee06469825faa1fb17f5462dabb',1,'egoa::Vertices::ElectricalProperties::HeaderLong()']]] +]; diff --git a/search/functions_8.js b/search/functions_8.js new file mode 100644 index 00000000..0e2429ed --- /dev/null +++ b/search/functions_8.js @@ -0,0 +1,25 @@ +var searchData= +[ + ['identifier_0',['identifier',['../classegoa_1_1_block_cut_tree_1_1_cut_vertex.html#a4e7a0eb2be97c669e3d186324736b085',1,'egoa::BlockCutTree::CutVertex::Identifier()'],['../classegoa_1_1_block_cut_tree_1_1_block.html#a997edf90f2c4d171e1f7ad51b08ccced',1,'egoa::BlockCutTree::Block::Identifier()']]], + ['indegreeat_1',['indegreeat',['../classegoa_1_1_dynamic_graph.html#ab9747c844b0ec7e215bf65f791267134',1,'egoa::DynamicGraph::InDegreeAt()'],['../classegoa_1_1_static_graph.html#a0411acd5fae68c32b1602b5ef0134741',1,'egoa::StaticGraph::InDegreeAt()']]], + ['indent_2',['Indent',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a3ab89cd4ca93cde5412b6ad46724e83e',1,'egoa::IO::GeoJsonWriter']]], + ['index_3',['index',['../classegoa_1_1_bucket_element.html#a71cd13dc3146fa8d0bc40e7145432350',1,'egoa::BucketElement::Index() const'],['../classegoa_1_1_bucket_element.html#aaf7fd7a4537ecaad1535033fd10220ef',1,'egoa::BucketElement::Index()'],['../classegoa_1_1_label.html#a9c22b92c0727ecceb9a91affbb76c070',1,'egoa::Label::Index() const'],['../classegoa_1_1_label.html#add6bbd836744f84fd17c68f7262dd164',1,'egoa::Label::Index()']]], + ['inedgeidsat_4',['inedgeidsat',['../classegoa_1_1_dynamic_graph.html#a6f3449ab60c4e5a419d5e38d3c6190d2',1,'egoa::DynamicGraph::InEdgeIdsAt()'],['../classegoa_1_1_static_graph.html#a33d8ff7630386cb00542d1449db60d7e',1,'egoa::StaticGraph::InEdgeIdsAt()']]], + ['insamecomponent_5',['InSameComponent',['../classegoa_1_1_union_find.html#ace93766c66447d2a6c2274fa8da6b227',1,'egoa::UnionFind']]], + ['insert_6',['insert',['../classegoa_1_1_mapping_binary_heap.html#afa7345a90c42597384e114f5383a3f6c',1,'egoa::MappingBinaryHeap::Insert(std::pair< TElement, TKey > pair)'],['../classegoa_1_1_mapping_binary_heap.html#ad9a8f442a5db89f3c086568624b4e8c3',1,'egoa::MappingBinaryHeap::Insert(TElement element, TKey key)'],['../classegoa_1_1_bucket.html#a6b591948f5834e45c5dabb00562c2d55',1,'egoa::Bucket::Insert()'],['../classegoa_1_1_binary_heap.html#a8acf54b49a04ab347dced13c78c12615',1,'egoa::BinaryHeap::Insert(std::vector< TElement > const &elements)'],['../classegoa_1_1_binary_heap.html#af4097764c5c57636f53791b9cf39395a',1,'egoa::BinaryHeap::Insert(TElement &&element)'],['../classegoa_1_1_binary_heap.html#a121a075cafffcd696057c1f6e0020008',1,'egoa::BinaryHeap::Insert(TElement const &element)'],['../classegoa_1_1_dominating_theta_path.html#ae222b087385df5fdf98a77dda157c946',1,'egoa::DominatingThetaPath::Insert()'],['../classegoa_1_1_binary_heap.html#aca3181a858ac6857a8b229ef697aad48',1,'egoa::BinaryHeap::Insert()']]], + ['isactive_7',['isactive',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a51cda5e17e4489f07b4022ae257f0ab2',1,'egoa::Vertices::ElectricalProperties::IsActive()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ab0eb427e28dc3c5c04a3235caef8717a',1,'egoa::Vertices::GeneratorProperties::IsActive()']]], + ['isarticulationvertexat_8',['IsArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a49d34db914899881114731ee0a37d0ae',1,'egoa::ArticulationVertexDetection']]], + ['isbounded_9',['IsBounded',['../classegoa_1_1_power_grid.html#adc565569a76f8fdc9fe8d927c737de3e',1,'egoa::PowerGrid']]], + ['isbridge_10',['IsBridge',['../classegoa_1_1_block_cut_tree_1_1_block.html#af31ff57edfbc5ba6f26c06c79ee8898f',1,'egoa::BlockCutTree::Block']]], + ['isbridgearticulationvertexat_11',['IsBridgeArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a0c0a4d84b9a01876df0468b7c338db46',1,'egoa::ArticulationVertexDetection']]], + ['iscutvertex_12',['IsCutVertex',['../classegoa_1_1_block_cut_tree.html#a0f7d7567e672e533976b3c893e32db80',1,'egoa::BlockCutTree']]], + ['isequalto_13',['isequalto',['../classegoa_1_1_binary_heap.html#a4324db70754d810d32c620b6f715012c',1,'egoa::BinaryHeap::IsEqualTo()'],['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01false_01_4.html#ad5b69c92ad7d82fe71d823d61ea1d183',1,'egoa::internal::BinaryHeapCheck< Type, false >::IsEqualTo()'],['../classegoa_1_1internal_1_1_binary_heap_check_3_01_type_00_01true_01_4.html#afc844e115b9b61f5ad080cb9364affdc',1,'egoa::internal::BinaryHeapCheck< Type, true >::IsEqualTo()']]], + ['isexact_14',['IsExact',['../classegoa_1_1_power_grid.html#aca8655a512c4adbc4ecd3ddd445a8e31',1,'egoa::PowerGrid']]], + ['isextendable_15',['isextendable',['../classegoa_1_1_vertices_1_1_generator_properties.html#a5f7942765ac3788c00eeb647e699992d',1,'egoa::Vertices::GeneratorProperties::IsExtendable() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a84634dd5a9245eac61e0cb3aaae83f6b',1,'egoa::Vertices::GeneratorProperties::IsExtendable()']]], + ['isleaf_16',['IsLeaf',['../classegoa_1_1_block_cut_tree_1_1_block.html#ae426f7b266f6363ed61a0ae73e3bfb80',1,'egoa::BlockCutTree::Block']]], + ['isparentarticulationvertexat_17',['IsParentArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#abfca902ba3d3d9c3443af45272bfe920',1,'egoa::ArticulationVertexDetection']]], + ['ispureunbounded_18',['IsPureUnbounded',['../classegoa_1_1_power_grid.html#a502ed64c2c10baa47c66231391ad4d3a',1,'egoa::PowerGrid']]], + ['isroot_19',['IsRoot',['../classegoa_1_1_articulation_vertex_detection.html#a0eb4836a75b02a4a22809aa170ff85df',1,'egoa::ArticulationVertexDetection']]], + ['isrootarticulationvertexat_20',['IsRootArticulationVertexAt',['../classegoa_1_1_articulation_vertex_detection.html#a54843a91ae68787e5b9bc8d0e461b146',1,'egoa::ArticulationVertexDetection']]], + ['isunbounded_21',['IsUnbounded',['../classegoa_1_1_power_grid.html#a88b549f743a751b00b55c830579ab8d2',1,'egoa::PowerGrid']]] +]; diff --git a/search/functions_9.js b/search/functions_9.js new file mode 100644 index 00000000..748da50e --- /dev/null +++ b/search/functions_9.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['jointhreadbasedresults_0',['JoinThreadBasedResults',['../classegoa_1_1_betweenness_centrality.html#a4cb3aa831da54fd5e362aaf146e9b816',1,'egoa::BetweennessCentrality']]] +]; diff --git a/search/functions_a.js b/search/functions_a.js new file mode 100644 index 00000000..429a888f --- /dev/null +++ b/search/functions_a.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['keyof_0',['KeyOf',['../classegoa_1_1_mapping_binary_heap.html#adb68497a6c9dce260fe1719023337726',1,'egoa::MappingBinaryHeap']]] +]; diff --git a/search/functions_b.js b/search/functions_b.js new file mode 100644 index 00000000..3e25ba9a --- /dev/null +++ b/search/functions_b.js @@ -0,0 +1,16 @@ +var searchData= +[ + ['label_0',['label',['../classegoa_1_1_label.html#a3e821b3e453e91072b75c38489a3920d',1,'egoa::Label::Label(Label const &label)=default'],['../classegoa_1_1_label.html#a899f2c401759a354942c7af96ad54fa7',1,'egoa::Label::Label(Types::vertexId vertexId)']]], + ['labelat_1',['LabelAt',['../classegoa_1_1_dominating_theta_path.html#a4f89c1d235bd7cfedd3673033cfac45c',1,'egoa::DominatingThetaPath']]], + ['labelsetat_2',['labelsetat',['../classegoa_1_1_dominating_theta_path.html#a3f7e76e52337fda7bae785ec4ac9a273',1,'egoa::DominatingThetaPath::LabelSetAt(TVertexId const vertexId) const'],['../classegoa_1_1_dominating_theta_path.html#aec826894182146841bbd1ce14bd482b3',1,'egoa::DominatingThetaPath::LabelSetAt(TVertexId const vertexId)']]], + ['labelsetemptyat_3',['labelsetemptyat',['../classegoa_1_1_dominating_theta_path.html#a3f457944c7e6ad5c8353ae06c6d5aed2',1,'egoa::DominatingThetaPath::LabelSetEmptyAt(TVertexId const vertexId) const'],['../classegoa_1_1_dominating_theta_path.html#a77831c762b0e2224f44789eb1cd6290e',1,'egoa::DominatingThetaPath::LabelSetEmptyAt(TLabel const &label) const']]], + ['line_4',['line',['../classegoa_1_1_edges_1_1_electrical_properties.html#ae0a38017dcfb972afaa8e6eb54427b7d',1,'egoa::Edges::ElectricalProperties::Line()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#aafc3b94378befb4fcef11f4c4462d76f',1,'egoa::Vertices::ElectricalProperties::Line(std::ostream &outputStream, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#ad1cf863d58d7d2e2aa90fa957940726a',1,'egoa::Vertices::ElectricalProperties::Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ac9306f3c683fd6a97473d040f54c010d',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a552e1c524803efcc1074cf49b2c4f59d',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::vertexId identifier, Types::real baseMva=1) const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aa1fdfc955238dd72d69804f756b5f4ef',1,'egoa::Vertices::GeneratorProperties::Line(std::ostream &outputStream, Types::name busName, Types::real baseMva=1) const']]], + ['loadat_5',['loadat',['../classegoa_1_1_power_grid.html#aef83b9d86c21284bda8fb05c0a05a1ae',1,'egoa::PowerGrid::LoadAt(Types::loadId loadId)'],['../classegoa_1_1_power_grid.html#ae7d8eac0e03b1c59832730ffc5e3c322',1,'egoa::PowerGrid::LoadAt(Types::loadId loadId) const']]], + ['loadboundtype_6',['loadboundtype',['../classegoa_1_1_power_grid.html#aec50a4e84a7d09f1ae89641b63a8bfa6',1,'egoa::PowerGrid::LoadBoundType() const'],['../classegoa_1_1_power_grid.html#aeb9a94f222be17d6866e2af688bdb633',1,'egoa::PowerGrid::LoadBoundType()']]], + ['loadid_7',['LoadId',['../classegoa_1_1_power_grid.html#a68b50b4872350c4953c53a9ee7765990',1,'egoa::PowerGrid']]], + ['loadids_8',['loadids',['../classegoa_1_1_power_grid.html#aa42587664cc370be9c268d96aedb3b2a',1,'egoa::PowerGrid::LoadIds(Types::vertexId vertexId, std::vector< Types::loadId > &loadIds) const'],['../classegoa_1_1_power_grid.html#a6878aab3f14e36a8b3aafc2c05b63b3a',1,'egoa::PowerGrid::LoadIds(TVertex const &vertex, std::vector< Types::loadId > &loadIds) const']]], + ['loadproperties_9',['loadproperties',['../classegoa_1_1_vertices_1_1_load_properties.html#a93b0229a945f84ab873855a5d9345469',1,'egoa::Vertices::LoadProperties::LoadProperties()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a9150f032edad146b14aad7aae5335d55',1,'egoa::Vertices::LoadProperties::LoadProperties(Types::name name)']]], + ['loadsat_10',['loadsat',['../classegoa_1_1_power_grid.html#a78120e692bcc0cc0ba601bdc31b05ee6',1,'egoa::PowerGrid::LoadsAt(Types::vertexId vertexId, std::vector< TLoadProperties > &loads) const'],['../classegoa_1_1_power_grid.html#a499bfe653734b72950d6e4ba5a7a5c86',1,'egoa::PowerGrid::LoadsAt(TVertex const &vertex, std::vector< TLoadProperties > &loads) const']]], + ['loadsnapshotof_11',['loadsnapshotof',['../classegoa_1_1_power_grid.html#aa1fb9b83cd4f9aab099d7730b1f9c386',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp)'],['../classegoa_1_1_power_grid.html#a0034e456379bf5342773ad14f2fe4308',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::timestampSnapshot timestamp) const'],['../classegoa_1_1_power_grid.html#a7014febddeee4d7d11253b214dfc7d57',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition)'],['../classegoa_1_1_power_grid.html#ae3a4745b8534e3edbf04806d2bfbff74',1,'egoa::PowerGrid::LoadSnapshotOf(Types::loadId loadId, Types::index timestampPosition) const']]], + ['loadsnapshotsat_12',['loadsnapshotsat',['../classegoa_1_1_power_grid.html#a315d38a57b3940063135582fab01082a',1,'egoa::PowerGrid::LoadSnapshotsAt(Types::vertexId vertexId, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)'],['../classegoa_1_1_power_grid.html#ad526d933caea7fbbe155de87814e4021',1,'egoa::PowerGrid::LoadSnapshotsAt(TVertex const &vertex, Types::index timestampPosition, std::vector< Types::loadSnapshot > &loadSnapshots)'],['../classegoa_1_1_power_grid.html#ac693ae02a22c940e108ea9e928a52a06',1,'egoa::PowerGrid::LoadSnapshotsAt(Types::timestampSnapshot timestamp, std::vector< Types::loadSnapshot > &loadSnapshotsAtTimestamp)']]] +]; diff --git a/search/functions_c.js b/search/functions_c.js new file mode 100644 index 00000000..08fb0fc7 --- /dev/null +++ b/search/functions_c.js @@ -0,0 +1,26 @@ +var searchData= +[ + ['makebounded_0',['MakeBounded',['../classegoa_1_1_power_grid.html#ab0a2711c11ba4570ae42a16f2d431a52',1,'egoa::PowerGrid']]], + ['makeexact_1',['MakeExact',['../classegoa_1_1_power_grid.html#a5ed3492077d249e50fa9d30beb0519c5',1,'egoa::PowerGrid']]], + ['makeheapproperty_2',['makeheapproperty',['../classegoa_1_1_mapping_binary_heap.html#ac356fd6afe187ac205dc620b3231a9f5',1,'egoa::MappingBinaryHeap::MakeHeapProperty()'],['../classegoa_1_1_binary_heap.html#acb0407e2f873eb215c419bb63b9c2911',1,'egoa::BinaryHeap::MakeHeapProperty()']]], + ['makepureunbounded_3',['MakePureUnbounded',['../classegoa_1_1_power_grid.html#a5c9ca6a0426cc04a6a7941bf083d7fad',1,'egoa::PowerGrid']]], + ['makeunbounded_4',['MakeUnbounded',['../classegoa_1_1_power_grid.html#af74cf9dee6225b7d017a9fc553b1802c',1,'egoa::PowerGrid']]], + ['mapedges_5',['mapedges',['../classegoa_1_1_dynamic_graph.html#afce3324d042167ccdba78f26c798ee32',1,'egoa::DynamicGraph::MapEdges()'],['../classegoa_1_1_static_graph.html#affe5646eebfdafd8957c45dd951915c9',1,'egoa::StaticGraph::MapEdges()']]], + ['mappingbinaryheap_6',['mappingbinaryheap',['../classegoa_1_1_mapping_binary_heap.html#ae60fc95c590462d297d019cc84a4e8ce',1,'egoa::MappingBinaryHeap::MappingBinaryHeap(TComparator comparator=std::less< TKey >(), TMap map=TMap())'],['../classegoa_1_1_mapping_binary_heap.html#a90e6d8312ee4ac7cc53182b85dfcff12',1,'egoa::MappingBinaryHeap::MappingBinaryHeap(std::vector< std::pair< TElement, TKey > > elementsKeyPairs, TComparator comparator=std::less< TKey >(), TMap map=TMap())'],['../classegoa_1_1_mapping_binary_heap.html#a2a2b0385b4d8c79291907bc85c10ea3a',1,'egoa::MappingBinaryHeap::MappingBinaryHeap(It first, It last, TComparator comparator=std::less< TKey >(), TMap map=TMap())']]], + ['mapvertices_7',['mapvertices',['../classegoa_1_1_dynamic_graph.html#accd9f93833b9a04d2a6c650224d1043e',1,'egoa::DynamicGraph::MapVertices()'],['../classegoa_1_1_static_graph.html#af0e8456898230772b2d96bb5f9e537de',1,'egoa::StaticGraph::MapVertices()']]], + ['marginalcost_8',['marginalcost',['../classegoa_1_1_vertices_1_1_generator_properties.html#a24dbf28e426a5c38c6fe721c3cd40853',1,'egoa::Vertices::GeneratorProperties::MarginalCost() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ade66c669e302f2eabf4337c2dc3b8f09',1,'egoa::Vertices::GeneratorProperties::MarginalCost()']]], + ['maxdegree_9',['maxdegree',['../classegoa_1_1_dynamic_graph.html#a0e4ba0993cf9cc7bbeb6a50b35741fef',1,'egoa::DynamicGraph::MaxDegree(Types::vertexId &id) const'],['../classegoa_1_1_dynamic_graph.html#acf65ad3153492d929753e3632c4405f9',1,'egoa::DynamicGraph::MaxDegree() const'],['../classegoa_1_1_static_graph.html#a8863c15316782f57249638f40acfb8a5',1,'egoa::StaticGraph::MaxDegree(Types::vertexId &id) const'],['../classegoa_1_1_static_graph.html#ada9c2faac6b9f4abeebd41987797e64e',1,'egoa::StaticGraph::MaxDegree() const']]], + ['maximize_10',['Maximize',['../classegoa_1_1_binary_heap.html#aedc884ad91379005f048105f5d6c2064',1,'egoa::BinaryHeap']]], + ['maximum_11',['maximum',['../classegoa_1_1_bound.html#a67321cd1d7da3f8304e476594c8ca1ae',1,'egoa::Bound::Maximum()'],['../classegoa_1_1_bound.html#a40ea7b759a29b3f69a6d8048ca859aad',1,'egoa::Bound::Maximum() const']]], + ['maximumindex_12',['maximumindex',['../classegoa_1_1_binary_heap.html#a83cb95c271460ba8eec78f2d9677fff6',1,'egoa::BinaryHeap::MaximumIndex()'],['../classegoa_1_1_mapping_binary_heap.html#a8dd16ac0c4f58970c5cbae2814ca000d',1,'egoa::MappingBinaryHeap::MaximumIndex()']]], + ['maximumvoltage_13',['maximumvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a67afe428a3ee38adcbb9883b77303ee0',1,'egoa::Vertices::ElectricalProperties::MaximumVoltage() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a90cf78d44fe85cb098a294b892534466',1,'egoa::Vertices::ElectricalProperties::MaximumVoltage()']]], + ['mergelabelat_14',['MergeLabelAt',['../classegoa_1_1_dominating_theta_path.html#a852fcea5c53353b555be381100e0dbf8',1,'egoa::DominatingThetaPath']]], + ['mindegree_15',['mindegree',['../classegoa_1_1_dynamic_graph.html#a7ad7413ef0b774cf5a9bad6b6a09011e',1,'egoa::DynamicGraph::MinDegree(Types::vertexId &id) const'],['../classegoa_1_1_dynamic_graph.html#a61aa60d20b8321828a9384426a6b63f1',1,'egoa::DynamicGraph::MinDegree() const'],['../classegoa_1_1_static_graph.html#a8018c87cdd76584f431ab953db798742',1,'egoa::StaticGraph::MinDegree(Types::vertexId &id) const'],['../classegoa_1_1_static_graph.html#a7c1f2f0b6e011b71eab90e4ea7e92244',1,'egoa::StaticGraph::MinDegree() const']]], + ['minimize_16',['Minimize',['../classegoa_1_1_binary_heap.html#a9bba6170b0d3a8d3fc952b4b31d855cd',1,'egoa::BinaryHeap']]], + ['minimum_17',['minimum',['../classegoa_1_1_bound.html#a3cd2f766d6978928da6f0cabcbae4280',1,'egoa::Bound::Minimum() const'],['../classegoa_1_1_bound.html#a6a4b726cbeee421b7ed1b6be90d7ead1',1,'egoa::Bound::Minimum()']]], + ['minimumcapacity_18',['minimumcapacity',['../classegoa_1_1_voltage_angle_difference_label.html#a0448c53dad8ab6d31ffef25021be4446',1,'egoa::VoltageAngleDifferenceLabel::MinimumCapacity() const'],['../classegoa_1_1_voltage_angle_difference_label.html#a20a5b76d02f8f53063aaa7c2aaba0199',1,'egoa::VoltageAngleDifferenceLabel::MinimumCapacity()']]], + ['minimumdowntime_19',['minimumdowntime',['../classegoa_1_1_vertices_1_1_generator_properties.html#a1844388ff5d3f5d61578837ac2d2fc6b',1,'egoa::Vertices::GeneratorProperties::MinimumDownTime() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#ad4ff5ef8c0116f5650aeae7ffd6b047c',1,'egoa::Vertices::GeneratorProperties::MinimumDownTime()']]], + ['minimumuptime_20',['minimumuptime',['../classegoa_1_1_vertices_1_1_generator_properties.html#a9f1422d1f8784f03f8e1487a42074d57',1,'egoa::Vertices::GeneratorProperties::MinimumUpTime() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a5a16f00b7f4a45a89885504aae6d4536',1,'egoa::Vertices::GeneratorProperties::MinimumUpTime()']]], + ['minimumvoltage_21',['minimumvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#ac8146b65a35336f8046f8a7d55ddb1b1',1,'egoa::Vertices::ElectricalProperties::MinimumVoltage() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a6021bab4ec8254a07392cfef235cf45c',1,'egoa::Vertices::ElectricalProperties::MinimumVoltage()']]], + ['movetoprocessed_22',['MoveToProcessed',['../classegoa_1_1_bucket.html#a6c60263233e0265deb361625664846aa',1,'egoa::Bucket']]] +]; diff --git a/search/functions_d.js b/search/functions_d.js new file mode 100644 index 00000000..2c58e8f7 --- /dev/null +++ b/search/functions_d.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['name_0',['name',['../classegoa_1_1_static_graph.html#a2a420df640dedf6bf52a5797d3731e4c',1,'egoa::StaticGraph::Name()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a0b13fb28bc969a0de0fcb1b6988d103f',1,'egoa::Vertices::LoadProperties::Name()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a1e4459b7846d1ff950134a9f655d32cf',1,'egoa::Vertices::LoadProperties::Name() const'],['../classegoa_1_1_dynamic_graph.html#af76a2b9a17b83abaa8fafa2829d5a239',1,'egoa::DynamicGraph::Name() const']]], + ['neighborsof_1',['neighborsof',['../classegoa_1_1_dynamic_graph.html#a5633ee4d3e372ca4edef50dece494407',1,'egoa::DynamicGraph::NeighborsOf(Types::vertexId id) const'],['../classegoa_1_1_dynamic_graph.html#ad4d491e741c5187401d8294ab71ba5df',1,'egoa::DynamicGraph::NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const'],['../classegoa_1_1_static_graph.html#a38473d24376a5a77cdf10fda912785de',1,'egoa::StaticGraph::NeighborsOf(Types::vertexId id) const'],['../classegoa_1_1_static_graph.html#a000af065a6eca662c41e0b44eff8e642',1,'egoa::StaticGraph::NeighborsOf(Types::vertexId id, std::vector< Types::vertexId > &vertexIds) const']]], + ['networkboundtype_2',['NetworkBoundType',['../classegoa_1_1_power_grid.html#a4392ec356e91e4bb64c07946c74e73a3',1,'egoa::PowerGrid']]], + ['networktype_3',['NetworkType',['../classegoa_1_1_power_grid.html#a22c34322d376bfd48a68ace260654c66',1,'egoa::PowerGrid']]], + ['newline_4',['NewLine',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#a5677431182ce2a13ae4bbdaae71a554c',1,'egoa::IO::GeoJsonWriter']]], + ['nominalpower_5',['nominalpower',['../classegoa_1_1_vertices_1_1_generator_properties.html#a0c430e37f0fff0b447b9e59533710f67',1,'egoa::Vertices::GeneratorProperties::NominalPower() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8ab23e2ff8350bf4836d78d3bf93725f',1,'egoa::Vertices::GeneratorProperties::NominalPower()']]], + ['nominalrealpowerbound_6',['nominalrealpowerbound',['../classegoa_1_1_vertices_1_1_generator_properties.html#a1cb4cea1223751a4b0a4aff400dad15c',1,'egoa::Vertices::GeneratorProperties::NominalRealPowerBound()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a7ce421682af9dbdf8ee716a560b52522',1,'egoa::Vertices::GeneratorProperties::NominalRealPowerBound() const']]], + ['nominalvoltage_7',['nominalvoltage',['../classegoa_1_1_vertices_1_1_electrical_properties.html#a77b87ce0275164fed50ac909ed2c649e',1,'egoa::Vertices::ElectricalProperties::NominalVoltage() const'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a7b51be20f051f419ac4a1cc701119366',1,'egoa::Vertices::ElectricalProperties::NominalVoltage()']]], + ['numberofblocks_8',['NumberOfBlocks',['../classegoa_1_1_block_cut_tree.html#a301355e10817dc9454fabe685603182f',1,'egoa::BlockCutTree']]], + ['numberofcutvertices_9',['NumberOfCutVertices',['../classegoa_1_1_block_cut_tree.html#a9632b5d0c09c805ec06dda6362fa9d68',1,'egoa::BlockCutTree']]], + ['numberofedges_10',['numberofedges',['../classegoa_1_1_dynamic_graph.html#a721c90423907f562dbbd4eecc2de83cb',1,'egoa::DynamicGraph::NumberOfEdges()'],['../classegoa_1_1_static_graph.html#aad69a3656933a239e1bb75f7df725fb1',1,'egoa::StaticGraph::NumberOfEdges()']]], + ['numberoflabels_11',['NumberOfLabels',['../classegoa_1_1_dominating_theta_path.html#a76b262a59b028eafefbaaf4177b87cb7',1,'egoa::DominatingThetaPath']]], + ['numberofpathsthroughedge_12',['NumberOfPathsThroughEdge',['../classegoa_1_1_dominating_theta_path.html#a40352a0d3e186565fb3a9bc3db5a72b2',1,'egoa::DominatingThetaPath']]], + ['numberofpathsthroughvertex_13',['NumberOfPathsThroughVertex',['../classegoa_1_1_dominating_theta_path.html#acfd8640564100eb2098d9b1880184be0',1,'egoa::DominatingThetaPath']]], + ['numberofprocessedelements_14',['NumberOfProcessedElements',['../classegoa_1_1_bucket.html#a9bdb3f0ab0be29032de6985ebccfaea8',1,'egoa::Bucket']]], + ['numberofunprocessedelements_15',['NumberOfUnprocessedElements',['../classegoa_1_1_bucket.html#a47262dfb1e4d3dfef9fa2ee3a35e69c8',1,'egoa::Bucket']]], + ['numberofvertices_16',['numberofvertices',['../classegoa_1_1_union_find.html#a9255a8cfbb34ae60715733b5c170f6e8',1,'egoa::UnionFind::NumberOfVertices()'],['../classegoa_1_1_dynamic_graph.html#abb92b7483970a5b1184a83a2d9a4ad09',1,'egoa::DynamicGraph::NumberOfVertices()'],['../classegoa_1_1_static_graph.html#a2366b7e2c19337129a0d0e50cb53e746',1,'egoa::StaticGraph::NumberOfVertices()']]] +]; diff --git a/search/functions_e.js b/search/functions_e.js new file mode 100644 index 00000000..da48f9c9 --- /dev/null +++ b/search/functions_e.js @@ -0,0 +1,22 @@ +var searchData= +[ + ['omittingiterator_0',['OmittingIterator',['../classegoa_1_1_omitting_iterator.html#abc7b5b14722c7011924b11981ade8aec',1,'egoa::OmittingIterator']]], + ['omittingvectorview_1',['OmittingVectorView',['../classegoa_1_1_dynamic_graph_1_1_omitting_vector_view.html#a8b7754882c2f5b145cdbedb9aed7c8ab',1,'egoa::DynamicGraph::OmittingVectorView']]], + ['openfile_2',['OpenFile',['../classegoa_1_1_py_psa_parser.html#af9f3c86056d53c6e768ce27fd56c0522',1,'egoa::PyPsaParser']]], + ['operator_21_3d_3',['operator!=',['../classegoa_1_1_binary_heap.html#a6e2e4b1011eb6fc5c941e7821f499b81',1,'egoa::BinaryHeap::operator!=()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a95e2a8abe5ad61172055fd8399dfeabe',1,'egoa::Vertices::ElectricalProperties::operator!=()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a662c025833dce2fbae0d1fa4e9a87e5d',1,'egoa::Vertices::GeneratorProperties::operator!=()'],['../classegoa_1_1_vertices_1_1_load_properties.html#a8fe6ebc3a45d5adb6e419cdeecea3f8a',1,'egoa::Vertices::LoadProperties::operator!=()'],['../classegoa_1_1_bucket_element.html#a13803e1f85f3f0459df51f778357cad9',1,'egoa::BucketElement::operator!=()'],['../classegoa_1_1_susceptance_norm_label.html#ab7cc9d78f4107666fe073191417b7f3f',1,'egoa::SusceptanceNormLabel::operator!=()'],['../classegoa_1_1_voltage_angle_difference_label.html#a5c76be28dd6acf9b4670e235526ecfe0',1,'egoa::VoltageAngleDifferenceLabel::operator!=()']]], + ['operator_2b_4',['operator+',['../classegoa_1_1_bucket_element.html#a8dea837200204f7403d0f414a3e2d604',1,'egoa::BucketElement']]], + ['operator_2b_3d_5',['operator+=',['../classegoa_1_1_binary_heap.html#adb2bfb65ff911ca750969f6cd212db58',1,'egoa::BinaryHeap::operator+=()'],['../classegoa_1_1_i_o_1_1_dtp_runtime_collection.html#ac583de3aa142785d04285431bfa356a3',1,'egoa::IO::DtpRuntimeCollection::operator+=()'],['../classegoa_1_1_voltage_angle_difference_label.html#af5e2e1b3e08439f3ce6254a39c2b3c42',1,'egoa::VoltageAngleDifferenceLabel::operator+=()'],['../classegoa_1_1_susceptance_norm_label.html#a55c657a35bb2539847eb4d634732eb7b',1,'egoa::SusceptanceNormLabel::operator+=()'],['../classegoa_1_1_bucket_element.html#a3e909b638fcb3488c56d5000bcf37354',1,'egoa::BucketElement::operator+=()'],['../classegoa_1_1_mapping_binary_heap.html#a14bcb1a1d010b271363c9b57c8d64b53',1,'egoa::MappingBinaryHeap::operator+=()'],['../classegoa_1_1_binary_heap.html#a4cdd31030d364846945fad833718e185',1,'egoa::BinaryHeap::operator+=()']]], + ['operator_3c_6',['operator<',['../classegoa_1_1_bucket_element.html#a86827612a62c1ae2459c636e4988f829',1,'egoa::BucketElement::operator<()'],['../classegoa_1_1_susceptance_norm_label.html#a893afd3b5e92e9b385c23ddf6fad31fd',1,'egoa::SusceptanceNormLabel::operator<()'],['../classegoa_1_1_voltage_angle_difference_label.html#ad141916e892f5bd00530f7ab5ae777a6',1,'egoa::VoltageAngleDifferenceLabel::operator<()']]], + ['operator_3c_3c_7',['operator<<',['../namespaceegoa.html#a5f54156277004b69798bfdf1548add62',1,'egoa']]], + ['operator_3c_3d_8',['operator<=',['../classegoa_1_1_voltage_angle_difference_label.html#acbac31b31ccf4a3891db37c48289f619',1,'egoa::VoltageAngleDifferenceLabel::operator<=()'],['../classegoa_1_1_bucket_element.html#a5e9f6c74469e7121b12c94fb37be50b6',1,'egoa::BucketElement::operator<=()'],['../classegoa_1_1_susceptance_norm_label.html#a49fd536f5803fe62920ef81672bf3cc9',1,'egoa::SusceptanceNormLabel::operator<=()']]], + ['operator_3d_3d_9',['operator==',['../classegoa_1_1_binary_heap.html#a8b515bc93fc52b1294575de9818f4aa0',1,'egoa::BinaryHeap::operator==()'],['../classegoa_1_1_voltage_angle_difference_label.html#a3508a0a62a327f26f7a632d760d69995',1,'egoa::VoltageAngleDifferenceLabel::operator==()'],['../classegoa_1_1_susceptance_norm_label.html#ad7356566ddf7c3b18293274bdd492366',1,'egoa::SusceptanceNormLabel::operator==()'],['../classegoa_1_1_bucket_element.html#a0acddc0768beaad9718687cdcfb16988',1,'egoa::BucketElement::operator==()'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8cc858d1eaa8c653901a58428004bcc8',1,'egoa::Vertices::GeneratorProperties::operator==()'],['../classegoa_1_1_bound.html#a07ba950cf18d1c51e86d59371f7a3346',1,'egoa::Bound::operator==()'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a5e1c51302b170ce459e8ce95223f5db8',1,'egoa::Vertices::ElectricalProperties::operator==()'],['../classegoa_1_1_vertices_1_1_load_properties.html#af618517002a610e45592f0949ac900e2',1,'egoa::Vertices::LoadProperties::operator==()']]], + ['operator_3e_10',['operator>',['../classegoa_1_1_bucket_element.html#adc7abd4ef0dc7887989d4096aa1f62e9',1,'egoa::BucketElement::operator>()'],['../classegoa_1_1_voltage_angle_difference_label.html#a3915d847607a6ca7defd659a74bfe301',1,'egoa::VoltageAngleDifferenceLabel::operator>()'],['../classegoa_1_1_susceptance_norm_label.html#aeb81bffa61720553785f806cfeb1eaae',1,'egoa::SusceptanceNormLabel::operator>()']]], + ['operator_3e_3d_11',['operator>=',['../classegoa_1_1_bucket_element.html#a96b7f3bb6c12ea44b7db0b8d00b29eb7',1,'egoa::BucketElement::operator>=()'],['../classegoa_1_1_susceptance_norm_label.html#aa8af31381d488d7d6832916068477767',1,'egoa::SusceptanceNormLabel::operator>=()'],['../classegoa_1_1_voltage_angle_difference_label.html#a26132f4531c24d60ef2ab52df177fcd3',1,'egoa::VoltageAngleDifferenceLabel::operator>=()']]], + ['operator_5b_5d_12',['operator[]',['../classegoa_1_1_bucket.html#a55b47966ca7150d2daa2f5499f8e34fc',1,'egoa::Bucket::operator[](Types::index index)'],['../classegoa_1_1_bucket.html#a251a45b6ee5efde0fd015f5e169bf2b1',1,'egoa::Bucket::operator[](Types::index index) const']]], + ['optima_13',['Optima',['../classegoa_1_1_bucket.html#a002053357b5bbfa8f6f81c82002071b4',1,'egoa::Bucket']]], + ['other_14',['Other',['../classegoa_1_1_edges_1_1_edge.html#a9ad20c2e19045ec9a615356862e2244e',1,'egoa::Edges::Edge']]], + ['outdegreeat_15',['outdegreeat',['../classegoa_1_1_dynamic_graph.html#aaa36840ee841fadc63092c6be0a623f0',1,'egoa::DynamicGraph::OutDegreeAt()'],['../classegoa_1_1_static_graph.html#a209c7941ec3d098ca4803aba156d2c3b',1,'egoa::StaticGraph::OutDegreeAt()']]], + ['outedgeidsat_16',['outedgeidsat',['../classegoa_1_1_dynamic_graph.html#ae40c57a847b4c0bc735584eb7c8eb631',1,'egoa::DynamicGraph::OutEdgeIdsAt()'],['../classegoa_1_1_static_graph.html#a5101bb31aafc18f74abde087828d6084',1,'egoa::StaticGraph::OutEdgeIdsAt()']]], + ['outputgeneratorsnaps_17',['OutputGeneratorSnaps',['../classegoa_1_1_power_grid.html#a9371133bd3fe1339111c1b717b0bf336',1,'egoa::PowerGrid']]], + ['outputloadsnaps_18',['OutputLoadSnaps',['../classegoa_1_1_power_grid.html#a7d847e7a4851634bb5a83a2a2c52f90e',1,'egoa::PowerGrid']]] +]; diff --git a/search/functions_f.js b/search/functions_f.js new file mode 100644 index 00000000..6e7f17d4 --- /dev/null +++ b/search/functions_f.js @@ -0,0 +1,23 @@ +var searchData= +[ + ['parentof_0',['ParentOf',['../classegoa_1_1_traversal.html#aacc75d7dbc197114ad3ebff7a9b43489',1,'egoa::Traversal']]], + ['pc1_1',['pc1',['../classegoa_1_1_vertices_1_1_generator_properties.html#a837f2e2d404419f78eae7b0ae6658dc3',1,'egoa::Vertices::GeneratorProperties::Pc1() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a4411578ddd3188b92c8833925b5cd2a6',1,'egoa::Vertices::GeneratorProperties::Pc1()']]], + ['pc2_2',['pc2',['../classegoa_1_1_vertices_1_1_generator_properties.html#addbec61641e682d8a6ef8946e3ef99be',1,'egoa::Vertices::GeneratorProperties::Pc2() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#af99167fb703905d177c6d5d57ff7ab3f',1,'egoa::Vertices::GeneratorProperties::Pc2()']]], + ['pop_3',['pop',['../classegoa_1_1_binary_heap.html#ac895f8167d62a9767f3e319e85fece7c',1,'egoa::BinaryHeap::Pop()'],['../classegoa_1_1_bucket.html#a498efb3fbf9e5a010df1cbde41b13340',1,'egoa::Bucket::Pop()'],['../classegoa_1_1_mapping_binary_heap.html#a2fb041b6866be5b4313def2b529c9959',1,'egoa::MappingBinaryHeap::Pop()']]], + ['popblock_4',['PopBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#ae56d0d1da49b8105b242a8513f1821e1',1,'egoa::internal::BlockCutTreeBuilder']]], + ['popinvalidunprocessedelements_5',['PopInvalidUnprocessedElements',['../classegoa_1_1_bucket.html#a9fb37902e69ac3c4791b041e1ea07765',1,'egoa::Bucket']]], + ['positionof_6',['PositionOf',['../classegoa_1_1_power_grid.html#a56b95993041b44f84dc7b5c104a5487b',1,'egoa::PowerGrid']]], + ['postprocessingedgewith_7',['postprocessingedgewith',['../classegoa_1_1_articulation_vertex_detection.html#a1b0a4a578cf8ade4bccd0f43d8d40328',1,'egoa::ArticulationVertexDetection::PostprocessingEdgeWith()'],['../classegoa_1_1_depth_first_search.html#af91647fa8959f846c7bad3227a34a9c8',1,'egoa::DepthFirstSearch::PostprocessingEdgeWith()']]], + ['postprocessingvertexwith_8',['postprocessingvertexwith',['../classegoa_1_1_articulation_vertex_detection.html#a2fad54d275484feb6f233e2c7d9b9ca3',1,'egoa::ArticulationVertexDetection::PostprocessingVertexWith()'],['../classegoa_1_1_depth_first_search.html#a36e25533cde9364f59e083e5b1221d38',1,'egoa::DepthFirstSearch::PostprocessingVertexWith()']]], + ['powergrid_9',['PowerGrid',['../classegoa_1_1_power_grid.html#a19c62ffecf3b6cfa8d1efa6adcbf0524',1,'egoa::PowerGrid']]], + ['powersign_10',['powersign',['../classegoa_1_1_vertices_1_1_generator_properties.html#a8f1dfba9865d02f454c36e327916f155',1,'egoa::Vertices::GeneratorProperties::PowerSign() const'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a403c85a83ea0581ac239119c4e2fdc43',1,'egoa::Vertices::GeneratorProperties::PowerSign()']]], + ['preprocessingvertexwith_11',['preprocessingvertexwith',['../classegoa_1_1_articulation_vertex_detection.html#a5aa44ab46057229f0f3a8d9eaede960b',1,'egoa::ArticulationVertexDetection::PreprocessingVertexWith()'],['../classegoa_1_1_depth_first_search.html#af1711f72afe88006828f839295b4190b',1,'egoa::DepthFirstSearch::PreprocessingVertexWith()']]], + ['previouslabel_12',['previouslabel',['../classegoa_1_1_label.html#a2fe7325ef63dc2d9b46fcdf1dbbc2b7e',1,'egoa::Label::PreviousLabel() const'],['../classegoa_1_1_label.html#aa9b4adb866c2c18057de32b7d296516e',1,'egoa::Label::PreviousLabel()']]], + ['previousvertex_13',['previousvertex',['../classegoa_1_1_label.html#a15361b688257549ecf4cd50223c312fc',1,'egoa::Label::PreviousVertex() const'],['../classegoa_1_1_label.html#ac956096abbd4c13c2f50be788c1e8877',1,'egoa::Label::PreviousVertex()']]], + ['processedvertexat_14',['ProcessedVertexAt',['../classegoa_1_1_traversal.html#a60cd6af384c9f5c7301e886434825a15',1,'egoa::Traversal']]], + ['processingedgewith_15',['ProcessingEdgeWith',['../classegoa_1_1_articulation_vertex_detection.html#af63e8535adc756d8d121ecdda60303e7',1,'egoa::ArticulationVertexDetection']]], + ['producecycle_16',['ProduceCycle',['../classegoa_1_1_dominating_theta_path.html#ad43c8c05a04271a701b47fe99c30700f',1,'egoa::DominatingThetaPath']]], + ['propertytemplate_17',['PropertyTemplate',['../classegoa_1_1_i_o_1_1_geo_json_writer.html#ad7aefa6f9db1e3573382a1853fb1f7c1',1,'egoa::IO::GeoJsonWriter']]], + ['push_18',['push',['../classegoa_1_1_priority_queue.html#a368f3b8f030ce038447daa031f3c924e',1,'egoa::PriorityQueue::Push()'],['../classegoa_1_1_queue.html#ad9a6293663c6167cd3b831d6511e458b',1,'egoa::Queue::Push()'],['../classegoa_1_1_std_queue.html#a2d5726740c3a7bc0e1cba7e824cb30da',1,'egoa::StdQueue::Push()']]], + ['pushnextblock_19',['PushNextBlock',['../classegoa_1_1internal_1_1_block_cut_tree_builder.html#acba2cff6ea5a6daca0a8ec43c318054e',1,'egoa::internal::BlockCutTreeBuilder']]] +]; diff --git a/search/groups_0.js b/search/groups_0.js new file mode 100644 index 00000000..6ebfe37b --- /dev/null +++ b/search/groups_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['and_20functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/groups_1.js b/search/groups_1.js new file mode 100644 index 00000000..839b4e66 --- /dev/null +++ b/search/groups_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['block_20cut_20tree_20related_20classes_20and_20functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/groups_2.js b/search/groups_2.js new file mode 100644 index 00000000..3d8ad780 --- /dev/null +++ b/search/groups_2.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['classes_20and_20functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]], + ['cut_20tree_20related_20classes_20and_20functions_1',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/groups_3.js b/search/groups_3.js new file mode 100644 index 00000000..6c259f95 --- /dev/null +++ b/search/groups_3.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/groups_4.js b/search/groups_4.js new file mode 100644 index 00000000..cac48e93 --- /dev/null +++ b/search/groups_4.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['related_20classes_20and_20functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/groups_5.js b/search/groups_5.js new file mode 100644 index 00000000..cb3496b3 --- /dev/null +++ b/search/groups_5.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['tree_20related_20classes_20and_20functions_0',['Block-cut tree related classes and functions',['../group__bctree.html',1,'']]] +]; diff --git a/search/mag.svg b/search/mag.svg new file mode 100644 index 00000000..ffb6cf0d --- /dev/null +++ b/search/mag.svg @@ -0,0 +1,24 @@ + + + + + + + diff --git a/search/mag_d.svg b/search/mag_d.svg new file mode 100644 index 00000000..4122773f --- /dev/null +++ b/search/mag_d.svg @@ -0,0 +1,24 @@ + + + + + + + diff --git a/search/mag_sel.svg b/search/mag_sel.svg new file mode 100644 index 00000000..553dba87 --- /dev/null +++ b/search/mag_sel.svg @@ -0,0 +1,31 @@ + + + + + + + + + diff --git a/search/mag_seld.svg b/search/mag_seld.svg new file mode 100644 index 00000000..c906f84c --- /dev/null +++ b/search/mag_seld.svg @@ -0,0 +1,31 @@ + + + + + + + + + diff --git a/search/namespaces_0.js b/search/namespaces_0.js new file mode 100644 index 00000000..0c95a130 --- /dev/null +++ b/search/namespaces_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['egoa_0',['egoa',['../namespaceegoa.html',1,'']]] +]; diff --git a/search/pages_0.js b/search/pages_0.js new file mode 100644 index 00000000..feadd945 --- /dev/null +++ b/search/pages_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['list_0',['Todo List',['../todo.html',1,'']]] +]; diff --git a/search/pages_1.js b/search/pages_1.js new file mode 100644 index 00000000..83220efb --- /dev/null +++ b/search/pages_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['todo_20list_0',['Todo List',['../todo.html',1,'']]] +]; diff --git a/search/related_0.js b/search/related_0.js new file mode 100644 index 00000000..f8de9e29 --- /dev/null +++ b/search/related_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['egoa_3a_3adynamicgraph_0',['DynamicGraph',['../classegoa_1_1_vertices_1_1_vertex.html#a9636035b0c11f531de54e2f038a4f782',1,'egoa::Vertices::Vertex']]] +]; diff --git a/search/related_1.js b/search/related_1.js new file mode 100644 index 00000000..f3213848 --- /dev/null +++ b/search/related_1.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['operator_21_3d_0',['operator!=',['../classegoa_1_1_edges_1_1_electrical_properties.html#ac60413c9f3bc89163e900f65acc727cc',1,'egoa::Edges::ElectricalProperties::operator!='],['../classegoa_1_1_vertices_1_1_vertex.html#aaff90cca8b8b4991ac4e2f33fc4c6502',1,'egoa::Vertices::Vertex::operator!='],['../classegoa_1_1_edges_1_1_edge.html#a3a7d391a881d7e305956a91ea59e7d31',1,'egoa::Edges::Edge::operator!=']]], + ['operator_2b_1',['operator+',['../classegoa_1_1_susceptance_norm_label.html#adbcdbbabeb758c86aeb262a76e5670fc',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#ae8710fe5ffbf887042391e8f0cc6b9f2',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#ae4ada6f0eaf806beed9b1517a3e4288e',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_susceptance_norm_label.html#a03093772f00792746a61a76fee7f8dbd',1,'egoa::SusceptanceNormLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#afe173a6796db67ae93c6d0a323a231b7',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#a5259d94609c7014e83936b0fe7e4e010',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#ad968f3fb33ac3558c2f05a2c03de9412',1,'egoa::VoltageAngleDifferenceLabel::operator+'],['../classegoa_1_1_voltage_angle_difference_label.html#ad452ef4763e1305f678ac97c8b5353ca',1,'egoa::VoltageAngleDifferenceLabel::operator+']]], + ['operator_3c_3c_2',['operator<<',['../classegoa_1_1_edges_1_1_electrical_properties.html#a4952a22fe49cd84a17941a9756e0cc52',1,'egoa::Edges::ElectricalProperties::operator<<'],['../classegoa_1_1_power_grid.html#ac71da4b2f48c667225317ce60555c8ca',1,'egoa::PowerGrid::operator<<'],['../classegoa_1_1_voltage_angle_difference_label.html#ae880ec9359b588940656813a44602077',1,'egoa::VoltageAngleDifferenceLabel::operator<<'],['../classegoa_1_1_susceptance_norm_label.html#afefc5f826b7a22d0ff9c6c6bd5434147',1,'egoa::SusceptanceNormLabel::operator<<'],['../classegoa_1_1_label.html#a8605f408c1b65641e478eb2576cfbca5',1,'egoa::Label::operator<<'],['../classegoa_1_1_bucket_element.html#aa1e10f422d96710227e704c8736a05fa',1,'egoa::BucketElement::operator<<'],['../classegoa_1_1_vertices_1_1_generator_properties.html#a8d288ddb2d4a11f5c5aac8d0d1f3cfcd',1,'egoa::Vertices::GeneratorProperties::operator<<'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#a58f8d91d03482a8e908a9bd5463979ec',1,'egoa::Vertices::ElectricalProperties::operator<<'],['../classegoa_1_1_static_graph.html#aa5c46d95341653c3f92e60d21bc6f570',1,'egoa::StaticGraph::operator<<'],['../classegoa_1_1_binary_heap.html#abf1d9b71852bb62b191eee6db5ee01fb',1,'egoa::BinaryHeap::operator<<']]], + ['operator_3d_3d_3',['operator==',['../classegoa_1_1_edges_1_1_edge.html#a5c7ab13984a79518de6ff1d43db56d95',1,'egoa::Edges::Edge::operator=='],['../classegoa_1_1_edges_1_1_electrical_properties.html#a287f42f66ea28d67f170128df12610a0',1,'egoa::Edges::ElectricalProperties::operator=='],['../classegoa_1_1_vertices_1_1_vertex.html#a578b6a4b9528651ce5ddead6ed87d7ea',1,'egoa::Vertices::Vertex::operator==']]] +]; diff --git a/search/related_2.js b/search/related_2.js new file mode 100644 index 00000000..76c9da2c --- /dev/null +++ b/search/related_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['swap_0',['swap',['../classegoa_1_1_binary_heap.html#a6b765f7e17e0416215f9a66427fdda8e',1,'egoa::BinaryHeap::swap'],['../classegoa_1_1_mapping_binary_heap.html#ad21567eb64c048ce5065fcd52139e266',1,'egoa::MappingBinaryHeap::swap'],['../classegoa_1_1_edges_1_1_edge.html#ae5b6888770eed42df9d62f5c9aa710e7',1,'egoa::Edges::Edge::swap'],['../classegoa_1_1_edges_1_1_electrical_properties.html#af9b76f49462f0aa711df9812c9940adb',1,'egoa::Edges::ElectricalProperties::swap'],['../classegoa_1_1_vertices_1_1_electrical_properties.html#af9b76f49462f0aa711df9812c9940adb',1,'egoa::Vertices::ElectricalProperties::swap'],['../classegoa_1_1_vertices_1_1_generator_properties.html#aac5b0bf3a5bfb0101377c7fd1dc6a474',1,'egoa::Vertices::GeneratorProperties::swap'],['../classegoa_1_1_vertices_1_1_vertex.html#a5a4381592f43687e475c7bc94621229c',1,'egoa::Vertices::Vertex::swap']]] +]; diff --git a/search/search.css b/search/search.css new file mode 100644 index 00000000..19f76f9d --- /dev/null +++ b/search/search.css @@ -0,0 +1,291 @@ +/*---------------- Search Box positioning */ + +#main-menu > li:last-child { + /* This
  • object is the parent of the search bar */ + display: flex; + justify-content: center; + align-items: center; + height: 36px; + margin-right: 1em; +} + +/*---------------- Search box styling */ + +.SRPage * { + font-weight: normal; + line-height: normal; +} + +dark-mode-toggle { + margin-left: 5px; + display: flex; + float: right; +} + +#MSearchBox { + display: inline-block; + white-space : nowrap; + background: var(--search-background-color); + border-radius: 0.65em; + box-shadow: var(--search-box-shadow); + z-index: 102; +} + +#MSearchBox .left { + display: inline-block; + vertical-align: middle; + height: 1.4em; +} + +#MSearchSelect { + display: inline-block; + vertical-align: middle; + width: 20px; + height: 19px; + background-image: var(--search-magnification-select-image); + margin: 0 0 0 0.3em; + padding: 0; +} + +#MSearchSelectExt { + display: inline-block; + vertical-align: middle; + width: 10px; + height: 19px; + background-image: var(--search-magnification-image); + margin: 0 0 0 0.5em; + padding: 0; +} + + +#MSearchField { + display: inline-block; + vertical-align: middle; + width: 7.5em; + height: 19px; + margin: 0 0.15em; + padding: 0; + line-height: 1em; + border:none; + color: var(--search-foreground-color); + outline: none; + font-family: var(--font-family-search); + -webkit-border-radius: 0px; + border-radius: 0px; + background: none; +} + +@media(hover: none) { + /* to avoid zooming on iOS */ + #MSearchField { + font-size: 16px; + } +} + +#MSearchBox .right { + display: inline-block; + vertical-align: middle; + width: 1.4em; + height: 1.4em; +} + +#MSearchClose { + display: none; + font-size: inherit; + background : none; + border: none; + margin: 0; + padding: 0; + outline: none; + +} + +#MSearchCloseImg { + padding: 0.3em; + margin: 0; +} + +.MSearchBoxActive #MSearchField { + color: var(--search-active-color); +} + + + +/*---------------- Search filter selection */ + +#MSearchSelectWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid var(--search-filter-border-color); + background-color: var(--search-filter-background-color); + z-index: 10001; + padding-top: 4px; + padding-bottom: 4px; + -moz-border-radius: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +.SelectItem { + font: 8pt var(--font-family-search); + padding-left: 2px; + padding-right: 12px; + border: 0px; +} + +span.SelectionMark { + margin-right: 4px; + font-family: var(--font-family-monospace); + outline-style: none; + text-decoration: none; +} + +a.SelectItem { + display: block; + outline-style: none; + color: var(--search-filter-foreground-color); + text-decoration: none; + padding-left: 6px; + padding-right: 12px; +} + +a.SelectItem:focus, +a.SelectItem:active { + color: var(--search-filter-foreground-color); + outline-style: none; + text-decoration: none; +} + +a.SelectItem:hover { + color: var(--search-filter-highlight-text-color); + background-color: var(--search-filter-highlight-bg-color); + outline-style: none; + text-decoration: none; + cursor: pointer; + display: block; +} + +/*---------------- Search results window */ + +iframe#MSearchResults { + /*width: 60ex;*/ + height: 15em; +} + +#MSearchResultsWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid var(--search-results-border-color); + background-color: var(--search-results-background-color); + z-index:10000; + width: 300px; + height: 400px; + overflow: auto; +} + +/* ----------------------------------- */ + + +#SRIndex { + clear:both; +} + +.SREntry { + font-size: 10pt; + padding-left: 1ex; +} + +.SRPage .SREntry { + font-size: 8pt; + padding: 1px 5px; +} + +div.SRPage { + margin: 5px 2px; + background-color: var(--search-results-background-color); +} + +.SRChildren { + padding-left: 3ex; padding-bottom: .5em +} + +.SRPage .SRChildren { + display: none; +} + +.SRSymbol { + font-weight: bold; + color: var(--search-results-foreground-color); + font-family: var(--font-family-search); + text-decoration: none; + outline: none; +} + +a.SRScope { + display: block; + color: var(--search-results-foreground-color); + font-family: var(--font-family-search); + font-size: 8pt; + text-decoration: none; + outline: none; +} + +a.SRSymbol:focus, a.SRSymbol:active, +a.SRScope:focus, a.SRScope:active { + text-decoration: underline; +} + +span.SRScope { + padding-left: 4px; + font-family: var(--font-family-search); +} + +.SRPage .SRStatus { + padding: 2px 5px; + font-size: 8pt; + font-style: italic; + font-family: var(--font-family-search); +} + +.SRResult { + display: none; +} + +div.searchresults { + margin-left: 10px; + margin-right: 10px; +} + +/*---------------- External search page results */ + +.pages b { + color: white; + padding: 5px 5px 3px 5px; + background-image: var(--nav-gradient-active-image-parent); + background-repeat: repeat-x; + text-shadow: 0 1px 1px #000000; +} + +.pages { + line-height: 17px; + margin-left: 4px; + text-decoration: none; +} + +.hl { + font-weight: bold; +} + +#searchresults { + margin-bottom: 20px; +} + +.searchpages { + margin-top: 10px; +} + diff --git a/search/search.js b/search/search.js new file mode 100644 index 00000000..6fd40c67 --- /dev/null +++ b/search/search.js @@ -0,0 +1,840 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file + */ +function convertToId(search) +{ + var result = ''; + for (i=0;i do a search + { + this.Search(); + } + } + + this.OnSearchSelectKey = function(evt) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==40 && this.searchIndex0) // Up + { + this.searchIndex--; + this.OnSelectItem(this.searchIndex); + } + else if (e.keyCode==13 || e.keyCode==27) + { + e.stopPropagation(); + this.OnSelectItem(this.searchIndex); + this.CloseSelectionWindow(); + this.DOMSearchField().focus(); + } + return false; + } + + // --------- Actions + + // Closes the results window. + this.CloseResultsWindow = function() + { + this.DOMPopupSearchResultsWindow().style.display = 'none'; + this.DOMSearchClose().style.display = 'none'; + this.Activate(false); + } + + this.CloseSelectionWindow = function() + { + this.DOMSearchSelectWindow().style.display = 'none'; + } + + // Performs a search. + this.Search = function() + { + this.keyTimeout = 0; + + // strip leading whitespace + var searchValue = this.DOMSearchField().value.replace(/^ +/, ""); + + var code = searchValue.toLowerCase().charCodeAt(0); + var idxChar = searchValue.substr(0, 1).toLowerCase(); + if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair + { + idxChar = searchValue.substr(0, 2); + } + + var jsFile; + + var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar); + if (idx!=-1) + { + var hexCode=idx.toString(16); + jsFile = this.resultsPath + indexSectionNames[this.searchIndex] + '_' + hexCode + '.js'; + } + + var loadJS = function(url, impl, loc){ + var scriptTag = document.createElement('script'); + scriptTag.src = url; + scriptTag.onload = impl; + scriptTag.onreadystatechange = impl; + loc.appendChild(scriptTag); + } + + var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow(); + var domSearchBox = this.DOMSearchBox(); + var domPopupSearchResults = this.DOMPopupSearchResults(); + var domSearchClose = this.DOMSearchClose(); + var resultsPath = this.resultsPath; + + var handleResults = function() { + document.getElementById("Loading").style.display="none"; + if (typeof searchData !== 'undefined') { + createResults(resultsPath); + document.getElementById("NoMatches").style.display="none"; + } + + if (idx!=-1) { + searchResults.Search(searchValue); + } else { // no file with search results => force empty search results + searchResults.Search('===='); + } + + if (domPopupSearchResultsWindow.style.display!='block') + { + domSearchClose.style.display = 'inline-block'; + var left = getXPos(domSearchBox) + 150; + var top = getYPos(domSearchBox) + 20; + domPopupSearchResultsWindow.style.display = 'block'; + left -= domPopupSearchResults.offsetWidth; + var maxWidth = document.body.clientWidth; + var maxHeight = document.body.clientHeight; + var width = 300; + if (left<10) left=10; + if (width+left+8>maxWidth) width=maxWidth-left-8; + var height = 400; + if (height+top+8>maxHeight) height=maxHeight-top-8; + domPopupSearchResultsWindow.style.top = top + 'px'; + domPopupSearchResultsWindow.style.left = left + 'px'; + domPopupSearchResultsWindow.style.width = width + 'px'; + domPopupSearchResultsWindow.style.height = height + 'px'; + } + } + + if (jsFile) { + loadJS(jsFile, handleResults, this.DOMPopupSearchResultsWindow()); + } else { + handleResults(); + } + + this.lastSearchValue = searchValue; + } + + // -------- Activation Functions + + // Activates or deactivates the search panel, resetting things to + // their default values if necessary. + this.Activate = function(isActive) + { + if (isActive || // open it + this.DOMPopupSearchResultsWindow().style.display == 'block' + ) + { + this.DOMSearchBox().className = 'MSearchBoxActive'; + this.searchActive = true; + } + else if (!isActive) // directly remove the panel + { + this.DOMSearchBox().className = 'MSearchBoxInactive'; + this.searchActive = false; + this.lastSearchValue = '' + this.lastResultsPage = ''; + this.DOMSearchField().value = ''; + } + } +} + +// ----------------------------------------------------------------------- + +// The class that handles everything on the search results page. +function SearchResults(name) +{ + // The number of matches from the last run of . + this.lastMatchCount = 0; + this.lastKey = 0; + this.repeatOn = false; + + // Toggles the visibility of the passed element ID. + this.FindChildElement = function(id) + { + var parentElement = document.getElementById(id); + var element = parentElement.firstChild; + + while (element && element!=parentElement) + { + if (element.nodeName.toLowerCase() == 'div' && element.className == 'SRChildren') + { + return element; + } + + if (element.nodeName.toLowerCase() == 'div' && element.hasChildNodes()) + { + element = element.firstChild; + } + else if (element.nextSibling) + { + element = element.nextSibling; + } + else + { + do + { + element = element.parentNode; + } + while (element && element!=parentElement && !element.nextSibling); + + if (element && element!=parentElement) + { + element = element.nextSibling; + } + } + } + } + + this.Toggle = function(id) + { + var element = this.FindChildElement(id); + if (element) + { + if (element.style.display == 'block') + { + element.style.display = 'none'; + } + else + { + element.style.display = 'block'; + } + } + } + + // Searches for the passed string. If there is no parameter, + // it takes it from the URL query. + // + // Always returns true, since other documents may try to call it + // and that may or may not be possible. + this.Search = function(search) + { + if (!search) // get search word from URL + { + search = window.location.search; + search = search.substring(1); // Remove the leading '?' + search = unescape(search); + } + + search = search.replace(/^ +/, ""); // strip leading spaces + search = search.replace(/ +$/, ""); // strip trailing spaces + search = search.toLowerCase(); + search = convertToId(search); + + var resultRows = document.getElementsByTagName("div"); + var matches = 0; + + var i = 0; + while (i < resultRows.length) + { + var row = resultRows.item(i); + if (row.className == "SRResult") + { + var rowMatchName = row.id.toLowerCase(); + rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_' + + if (search.length<=rowMatchName.length && + rowMatchName.substr(0, search.length)==search) + { + row.style.display = 'block'; + matches++; + } + else + { + row.style.display = 'none'; + } + } + i++; + } + document.getElementById("Searching").style.display='none'; + if (matches == 0) // no results + { + document.getElementById("NoMatches").style.display='block'; + } + else // at least one result + { + document.getElementById("NoMatches").style.display='none'; + } + this.lastMatchCount = matches; + return true; + } + + // return the first item with index index or higher that is visible + this.NavNext = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index++; + } + return focusItem; + } + + this.NavPrev = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index--; + } + return focusItem; + } + + this.ProcessKeys = function(e) + { + if (e.type == "keydown") + { + this.repeatOn = false; + this.lastKey = e.keyCode; + } + else if (e.type == "keypress") + { + if (!this.repeatOn) + { + if (this.lastKey) this.repeatOn = true; + return false; // ignore first keypress after keydown + } + } + else if (e.type == "keyup") + { + this.lastKey = 0; + this.repeatOn = false; + } + return this.lastKey!=0; + } + + this.Nav = function(evt,itemIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + var newIndex = itemIndex-1; + var focusItem = this.NavPrev(newIndex); + if (focusItem) + { + var child = this.FindChildElement(focusItem.parentNode.parentNode.id); + if (child && child.style.display == 'block') // children visible + { + var n=0; + var tmpElem; + while (1) // search for last child + { + tmpElem = document.getElementById('Item'+newIndex+'_c'+n); + if (tmpElem) + { + focusItem = tmpElem; + } + else // found it! + { + break; + } + n++; + } + } + } + if (focusItem) + { + focusItem.focus(); + } + else // return focus to search field + { + document.getElementById("MSearchField").focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = itemIndex+1; + var focusItem; + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem && elem.style.display == 'block') // children visible + { + focusItem = document.getElementById('Item'+itemIndex+'_c0'); + } + if (!focusItem) focusItem = this.NavNext(newIndex); + if (focusItem) focusItem.focus(); + } + else if (this.lastKey==39) // Right + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'block'; + } + else if (this.lastKey==37) // Left + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'none'; + } + else if (this.lastKey==27) // Escape + { + e.stopPropagation(); + searchBox.CloseResultsWindow(); + document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } + + this.NavChild = function(evt,itemIndex,childIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + if (childIndex>0) + { + var newIndex = childIndex-1; + document.getElementById('Item'+itemIndex+'_c'+newIndex).focus(); + } + else // already at first child, jump to parent + { + document.getElementById('Item'+itemIndex).focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = childIndex+1; + var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex); + if (!elem) // last child, jump to parent next parent + { + elem = this.NavNext(itemIndex+1); + } + if (elem) + { + elem.focus(); + } + } + else if (this.lastKey==27) // Escape + { + e.stopPropagation(); + searchBox.CloseResultsWindow(); + document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } +} + +function setKeyActions(elem,action) +{ + elem.setAttribute('onkeydown',action); + elem.setAttribute('onkeypress',action); + elem.setAttribute('onkeyup',action); +} + +function setClassAttr(elem,attr) +{ + elem.setAttribute('class',attr); + elem.setAttribute('className',attr); +} + +function createResults(resultsPath) +{ + var results = document.getElementById("SRResults"); + results.innerHTML = ''; + for (var e=0; e + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::Auxiliary::MatchPathSeparator Member List
    +
    +
    + +

    This is the complete list of members for egoa::Auxiliary::MatchPathSeparator, including all inherited members.

    + + +
    operator()(char ch) const (defined in egoa::Auxiliary::MatchPathSeparator)egoa::Auxiliary::MatchPathSeparatorinline
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1_auxiliary_1_1_match_path_separator.html b/structegoa_1_1_auxiliary_1_1_match_path_separator.html new file mode 100644 index 00000000..1a74c9fa --- /dev/null +++ b/structegoa_1_1_auxiliary_1_1_match_path_separator.html @@ -0,0 +1,136 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::Auxiliary::MatchPathSeparator Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    egoa::Auxiliary::MatchPathSeparator Struct Reference
    +
    +
    + +

    Path separator in UNIX systems. + More...

    + +

    #include <Auxiliary.hpp>

    + + + + +

    +Public Member Functions

    bool operator() (char ch) const
     
    +

    Detailed Description

    +

    Path separator in UNIX systems.

    +

    https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path

    Todo:
    Put in system dependent header
    + +

    Definition at line 109 of file Auxiliary.hpp.

    +

    Member Function Documentation

    + +

    ◆ operator()()

    + +
    +
    + + + + + +
    + + + + + + + + +
    bool egoa::Auxiliary::MatchPathSeparator::operator() (char ch) const
    +     		+inline
    +
    + +

    Definition at line 111 of file Auxiliary.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1_i_o_1_1_solver_runtime_row-members.html b/structegoa_1_1_i_o_1_1_solver_runtime_row-members.html new file mode 100644 index 00000000..d4b60c4c --- /dev/null +++ b/structegoa_1_1_i_o_1_1_solver_runtime_row-members.html @@ -0,0 +1,114 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::IO::SolverRuntimeRow Member List
    +
    +
    + +

    This is the complete list of members for egoa::IO::SolverRuntimeRow, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    BuildingRuntimeSecondsegoa::IO::SolverRuntimeRow
    Content(std::ostream &os) const (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    Header(std::ostream &os) (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinlinestatic
    LowerBoundegoa::IO::SolverRuntimeRow
    Max(const SolverRuntimeRow &rhs) (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    Min(const SolverRuntimeRow &rhs) (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    MipGapegoa::IO::SolverRuntimeRow
    Nameegoa::IO::SolverRuntimeRow
    NameOfProblemegoa::IO::SolverRuntimeRow
    NumberOfBinaryVarsegoa::IO::SolverRuntimeRow
    NumberOfConstraintsegoa::IO::SolverRuntimeRow
    NumberOfEdgesegoa::IO::SolverRuntimeRow
    NumberOfGenConstrainsegoa::IO::SolverRuntimeRow
    NumberOfIntVarsegoa::IO::SolverRuntimeRow
    NumberOfNZsegoa::IO::SolverRuntimeRow
    NumberOfQConstrainsegoa::IO::SolverRuntimeRow
    NumberOfSoSegoa::IO::SolverRuntimeRow
    NumberOfVariablesegoa::IO::SolverRuntimeRow
    NumberOfVerticesegoa::IO::SolverRuntimeRow
    operator+=(const SolverRuntimeRow &rhs) (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    operator/=(int rhs) (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    OptimizationRuntimeSecondsegoa::IO::SolverRuntimeRow
    Solutionegoa::IO::SolverRuntimeRow
    SolverRuntimeRow() (defined in egoa::IO::SolverRuntimeRow)egoa::IO::SolverRuntimeRowinline
    Statusegoa::IO::SolverRuntimeRow
    UpperBoundegoa::IO::SolverRuntimeRow
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1_i_o_1_1_solver_runtime_row.html b/structegoa_1_1_i_o_1_1_solver_runtime_row.html new file mode 100644 index 00000000..6139fc19 --- /dev/null +++ b/structegoa_1_1_i_o_1_1_solver_runtime_row.html @@ -0,0 +1,684 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::IO::SolverRuntimeRow Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Member Functions | +Static Public Member Functions | +Public Attributes | +List of all members
    +
    egoa::IO::SolverRuntimeRow Struct Reference
    +
    +
    + +

    A struct representing one row of the statistics for mathematical models. + More...

    + +

    #include <SolverRuntimeRow.hpp>

    + + + + + + + + + + + + +

    +Public Member Functions

    void Content (std::ostream &os) const
     
    SolverRuntimeRow & operator+= (const SolverRuntimeRow &rhs)
     
    SolverRuntimeRow & operator/= (int rhs)
     
    void Min (const SolverRuntimeRow &rhs)
     
    void Max (const SolverRuntimeRow &rhs)
     
    + + + +

    +Static Public Member Functions

    static void Header (std::ostream &os)
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Attributes

    Types::name NameOfProblem
     
    Types::name Name
     
    Types::count NumberOfVertices
     
    Types::count NumberOfEdges
     
    Types::real Solution
     
    Types::real OptimizationRuntimeSeconds
     
    Types::real BuildingRuntimeSeconds
     
    Types::string Status
     
    Types::real MipGap
     
    Types::real UpperBound
     
    Types::real LowerBound
     
    Types::count NumberOfVariables
     
    Types::count NumberOfConstraints
     
    Types::count NumberOfSoS
     
    Types::count NumberOfQConstrains
     
    Types::count NumberOfGenConstrains
     
    Types::count NumberOfNZs
     
    Types::count NumberOfIntVars
     
    Types::count NumberOfBinaryVars
     
    +

    Detailed Description

    +

    A struct representing one row of the statistics for mathematical models.

    +
    See also
    GurobiRuntimeCollection A collection of SolverRuntimeRow objects
    + +

    Definition at line 23 of file SolverRuntimeRow.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ SolverRuntimeRow()

    + +
    +
    + + + + + +
    + + + + + + + +
    egoa::IO::SolverRuntimeRow::SolverRuntimeRow ()
    +     		+inline
    +
    + +

    Definition at line 48 of file SolverRuntimeRow.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ Content()

    + +
    +
    + + + + + +
    + + + + + + + + +
    void egoa::IO::SolverRuntimeRow::Content (std::ostream & os) const
    +     		+inline
    +
    + +

    Definition at line 102 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Header()

    + +
    +
    + + + + + +
    + + + + + + + + +
    static void egoa::IO::SolverRuntimeRow::Header (std::ostream & os)
    +     		+inlinestatic
    +
    + +

    Definition at line 74 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Max()

    + +
    +
    + + + + + +
    + + + + + + + + +
    void egoa::IO::SolverRuntimeRow::Max (const SolverRuntimeRow & rhs)
    +     		+inline
    +
    + +

    Definition at line 187 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Min()

    + +
    +
    + + + + + +
    + + + + + + + + +
    void egoa::IO::SolverRuntimeRow::Min (const SolverRuntimeRow & rhs)
    +     		+inline
    +
    + +

    Definition at line 170 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ operator+=()

    + +
    +
    + + + + + +
    + + + + + + + + +
    SolverRuntimeRow & egoa::IO::SolverRuntimeRow::operator+= (const SolverRuntimeRow & rhs)
    +     		+inline
    +
    + +

    Definition at line 130 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ operator/=()

    + +
    +
    + + + + + +
    + + + + + + + + +
    SolverRuntimeRow & egoa::IO::SolverRuntimeRow::operator/= (int rhs)
    +     		+inline
    +
    + +

    Definition at line 150 of file SolverRuntimeRow.hpp.

    + +
    +
    +

    Member Data Documentation

    + +

    ◆ BuildingRuntimeSeconds

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::BuildingRuntimeSeconds
    +
    +

    Current time in the whole gurobi program

    + +

    Definition at line 33 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ LowerBound

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::LowerBound
    +
    +

    Lower bound

    + +

    Definition at line 38 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ MipGap

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::MipGap
    +
    +

    MIP gap in %

    + +

    Definition at line 36 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Name

    + +
    +
    + + + + +
    Types::name egoa::IO::SolverRuntimeRow::Name
    +
    +

    Name of the instance

    + +

    Definition at line 26 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NameOfProblem

    + +
    +
    + + + + +
    Types::name egoa::IO::SolverRuntimeRow::NameOfProblem
    +
    +

    Problem solved

    + +

    Definition at line 25 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfBinaryVars

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfBinaryVars
    +
    +

    Number of variables

    + +

    Definition at line 46 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfConstraints

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfConstraints
    +
    +

    Number of variables

    + +

    Definition at line 40 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfEdges

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfEdges
    +
    +

    Number of edges

    + +

    Definition at line 29 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfGenConstrains

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfGenConstrains
    +
    +

    Number of variables

    + +

    Definition at line 43 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfIntVars

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfIntVars
    +
    +

    Number of variables

    + +

    Definition at line 45 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfNZs

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfNZs
    +
    +

    Number of variables

    + +

    Definition at line 44 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfQConstrains

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfQConstrains
    +
    +

    Number of variables

    + +

    Definition at line 42 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfSoS

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfSoS
    +
    +

    Number of variables

    + +

    Definition at line 41 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfVariables

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfVariables
    +
    +

    Number of variables

    + +

    Definition at line 39 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ NumberOfVertices

    + +
    +
    + + + + +
    Types::count egoa::IO::SolverRuntimeRow::NumberOfVertices
    +
    +

    Number of vertices

    + +

    Definition at line 28 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ OptimizationRuntimeSeconds

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::OptimizationRuntimeSeconds
    +
    +

    Current time in the whole gurobi program

    + +

    Definition at line 32 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Solution

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::Solution
    +
    +

    Current solution's cost

    + +

    Definition at line 31 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ Status

    + +
    +
    + + + + +
    Types::string egoa::IO::SolverRuntimeRow::Status
    +
    +

    Gurobi solution status; see https://www.gurobi.com/documentation/8.0/refman/optimization_status_codes.html#sec:StatusCodes

    + +

    Definition at line 35 of file SolverRuntimeRow.hpp.

    + +
    +
    + +

    ◆ UpperBound

    + +
    +
    + + + + +
    Types::real egoa::IO::SolverRuntimeRow::UpperBound
    +
    +

    Upper bound

    + +

    Definition at line 37 of file SolverRuntimeRow.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction-members.html b/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction-members.html new file mode 100644 index 00000000..a5d95a59 --- /dev/null +++ b/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction-members.html @@ -0,0 +1,96 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction Member List
    +
    +
    + +

    This is the complete list of members for egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction, including all inherited members.

    + + + + + + + + + +
    BlockUnderConstruction(Types::blockId id, TTime time) (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstructioninline
    cutVertices (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    edges (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    identifier (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    TBlock typedef (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    timeOfOldestVertex (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    ToBlock(TGraph const &graph) && (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstructioninline
    vertices (defined in egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction)egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction.html b/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction.html new file mode 100644 index 00000000..d84503bf --- /dev/null +++ b/structegoa_1_1internal_1_1_block_cut_tree_builder_1_1_block_under_construction.html @@ -0,0 +1,305 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +Public Attributes | +List of all members
    +
    egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction Struct Reference
    +
    +
    + + + + +

    +Public Types

    using TBlock = typename BlockCutTree< TGraph >::Block
     
    + + + + + +

    +Public Member Functions

     BlockUnderConstruction (Types::blockId id, TTime time)
     
    TBlock ToBlock (TGraph const &graph) &&
     
    + + + + + + + + + + + +

    +Public Attributes

    Types::blockId identifier
     
    TTime timeOfOldestVertex
     
    std::vector< TVertexId > vertices
     
    std::vector< TEdgeId > edges
     
    std::vector< TVertexId > cutVertices
     
    +

    Detailed Description

    +
    template<typename GraphType>
    +struct egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction
    +

    Definition at line 564 of file BlockCutTree.hpp.

    +

    Member Typedef Documentation

    + +

    ◆ TBlock

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    using egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::TBlock = typename BlockCutTree<TGraph>::Block
    +
    + +

    Definition at line 565 of file BlockCutTree.hpp.

    + +
    +
    +

    Constructor & Destructor Documentation

    + +

    ◆ BlockUnderConstruction()

    + +
    +
    +
    +template<typename GraphType >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::BlockUnderConstruction (Types::blockId id,
    TTime time 
    )
    +     		+inline
    +
    + +

    Definition at line 567 of file BlockCutTree.hpp.

    + +
    +
    +

    Member Function Documentation

    + +

    ◆ ToBlock()

    + +
    +
    +
    +template<typename GraphType >
    + + + + + +
    + + + + + + + + +
    TBlock egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::ToBlock (TGraph const & graph) &&
    +     		+inline
    +
    + +

    Definition at line 578 of file BlockCutTree.hpp.

    + +
    +
    +

    Member Data Documentation

    + +

    ◆ cutVertices

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    std::vector<TVertexId> egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::cutVertices
    +
    + +

    Definition at line 576 of file BlockCutTree.hpp.

    + +
    +
    + +

    ◆ edges

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    std::vector<TEdgeId> egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::edges
    +
    + +

    Definition at line 575 of file BlockCutTree.hpp.

    + +
    +
    + +

    ◆ identifier

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    Types::blockId egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::identifier
    +
    + +

    Definition at line 572 of file BlockCutTree.hpp.

    + +
    +
    + +

    ◆ timeOfOldestVertex

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    TTime egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::timeOfOldestVertex
    +
    + +

    Definition at line 573 of file BlockCutTree.hpp.

    + +
    +
    + +

    ◆ vertices

    + +
    +
    +
    +template<typename GraphType >
    + + + + +
    std::vector<TVertexId> egoa::internal::BlockCutTreeBuilder< GraphType >::BlockUnderConstruction::vertices
    +
    + +

    Definition at line 574 of file BlockCutTree.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop.html b/structegoa_1_1internal_1_1_container_loop.html new file mode 100644 index 00000000..889ebaad --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop.html @@ -0,0 +1,102 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::ContainerLoop< Policy > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::internal::ContainerLoop< Policy > Struct Template Reference
    +
    +
    + +

    Loops over containers. + More...

    +

    Detailed Description

    +
    template<ExecutionPolicy Policy>
    +struct egoa::internal::ContainerLoop< Policy >

    Loops over containers.

    +
    Template Parameters
    + + +
    PolicyThe execution policy.
    +
    +
    + +

    Definition at line 28 of file ContainerLoop.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4-members.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4-members.html new file mode 100644 index 00000000..0578caf9 --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4-members.html @@ -0,0 +1,89 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::breakable > Member List
    +
    +
    + +

    This is the complete list of members for egoa::internal::ContainerLoop< ExecutionPolicy::breakable >, including all inherited members.

    + + +
    for_each(Container const &container, FUNCTION function)egoa::internal::ContainerLoop< ExecutionPolicy::breakable >inlinestatic
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html new file mode 100644 index 00000000..6214eece --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1breakable_01_4.html @@ -0,0 +1,165 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::ContainerLoop< ExecutionPolicy::breakable > Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Static Public Member Functions | +List of all members
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::breakable > Struct Reference
    +
    +
    + +

    Breakable loop over all elements in the container. + More...

    + +

    #include <ContainerLoop.hpp>

    + + + + + + +

    +Static Public Member Functions

    template<typename Container , typename FUNCTION >
    static void for_each (Container const &container, FUNCTION function)
     Breakable loop over all elements in the container.
     
    +

    Detailed Description

    +

    Breakable loop over all elements in the container.

    + +

    Definition at line 58 of file ContainerLoop.hpp.

    +

    Member Function Documentation

    + +

    ◆ for_each()

    + +
    +
    +
    +template<typename Container , typename FUNCTION >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    static void egoa::internal::ContainerLoop< ExecutionPolicy::breakable >::for_each (Container const & container,
    FUNCTION function 
    )
    +     		+inlinestatic
    +
    + +

    Breakable loop over all elements in the container.

    +
    Parameters
    + + + +
    containerThe container.
    [in]functionThe function to call for all elements in @ container.
    +
    +
    +
    Template Parameters
    + + + +
    ContainerThe type of the container.
    FUNCTIONThe type of the function object.
    +
    +
    + +

    Definition at line 70 of file ContainerLoop.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4-members.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4-members.html new file mode 100644 index 00000000..6f441d7d --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4-members.html @@ -0,0 +1,89 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::parallel > Member List
    +
    +
    + +

    This is the complete list of members for egoa::internal::ContainerLoop< ExecutionPolicy::parallel >, including all inherited members.

    + + +
    for_each(Container const &container, FUNCTION function)egoa::internal::ContainerLoop< ExecutionPolicy::sequential >inlinestatic
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.html new file mode 100644 index 00000000..62eac679 --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.html @@ -0,0 +1,117 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::ContainerLoop< ExecutionPolicy::parallel > Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +List of all members
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::parallel > Struct Reference
    +
    +
    + +

    If OpenMP is not available, the sequential loops are used. + More...

    + +

    #include <ContainerLoop.hpp>

    +
    +Inheritance diagram for egoa::internal::ContainerLoop< ExecutionPolicy::parallel >:
    +
    +
    + + +egoa::internal::ContainerLoop< ExecutionPolicy::sequential > + +
    + + + + + + + +

    +Additional Inherited Members

    - Static Public Member Functions inherited from egoa::internal::ContainerLoop< ExecutionPolicy::sequential >
    template<typename Container , typename FUNCTION >
    static void for_each (Container const &container, FUNCTION function)
     Sequential loop over all elements in the container.
     
    +

    Detailed Description

    +

    If OpenMP is not available, the sequential loops are used.

    + +

    Definition at line 120 of file ContainerLoop.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.png b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.png new file mode 100644 index 00000000..3ec7d479 Binary files /dev/null and b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1parallel_01_4.png differ diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4-members.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4-members.html new file mode 100644 index 00000000..d6c8b491 --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4-members.html @@ -0,0 +1,89 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::sequential > Member List
    +
    +
    + +

    This is the complete list of members for egoa::internal::ContainerLoop< ExecutionPolicy::sequential >, including all inherited members.

    + + +
    for_each(Container const &container, FUNCTION function)egoa::internal::ContainerLoop< ExecutionPolicy::sequential >inlinestatic
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html new file mode 100644 index 00000000..3f9ee2a3 --- /dev/null +++ b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.html @@ -0,0 +1,175 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): egoa::internal::ContainerLoop< ExecutionPolicy::sequential > Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Static Public Member Functions | +List of all members
    +
    egoa::internal::ContainerLoop< ExecutionPolicy::sequential > Struct Reference
    +
    +
    + +

    Sequential loop over all elements in the container. + More...

    + +

    #include <ContainerLoop.hpp>

    +
    +Inheritance diagram for egoa::internal::ContainerLoop< ExecutionPolicy::sequential >:
    +
    +
    + + +egoa::internal::ContainerLoop< ExecutionPolicy::parallel > + +
    + + + + + + +

    +Static Public Member Functions

    template<typename Container , typename FUNCTION >
    static void for_each (Container const &container, FUNCTION function)
     Sequential loop over all elements in the container.
     
    +

    Detailed Description

    +

    Sequential loop over all elements in the container.

    + +

    Definition at line 34 of file ContainerLoop.hpp.

    +

    Member Function Documentation

    + +

    ◆ for_each()

    + +
    +
    +
    +template<typename Container , typename FUNCTION >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    static void egoa::internal::ContainerLoop< ExecutionPolicy::sequential >::for_each (Container const & container,
    FUNCTION function 
    )
    +     		+inlinestatic
    +
    + +

    Sequential loop over all elements in the container.

    +

    Equivalent to std::for_each.

    +
    Parameters
    + + + +
    containerThe container.
    [in]functionThe function to call for all elements in @ container.
    +
    +
    +
    Template Parameters
    + + + +
    ContainerThe type of the container.
    FUNCTIONThe type of the function object.
    +
    +
    + +

    Definition at line 47 of file ContainerLoop.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.png b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.png new file mode 100644 index 00000000..9149226b Binary files /dev/null and b/structegoa_1_1internal_1_1_container_loop_3_01_execution_policy_1_1sequential_01_4.png differ diff --git a/sync_off.png b/sync_off.png new file mode 100644 index 00000000..3b443fc6 Binary files /dev/null and b/sync_off.png differ diff --git a/sync_on.png b/sync_on.png new file mode 100644 index 00000000..e08320fb Binary files /dev/null and b/sync_on.png differ diff --git a/tab_a.png b/tab_a.png new file mode 100644 index 00000000..3b725c41 Binary files /dev/null and b/tab_a.png differ diff --git a/tab_ad.png b/tab_ad.png new file mode 100644 index 00000000..e34850ac Binary files /dev/null and b/tab_ad.png differ diff --git a/tab_b.png b/tab_b.png new file mode 100644 index 00000000..e2b4a863 Binary files /dev/null and b/tab_b.png differ diff --git a/tab_bd.png b/tab_bd.png new file mode 100644 index 00000000..91c25249 Binary files /dev/null and b/tab_bd.png differ diff --git a/tab_h.png b/tab_h.png new file mode 100644 index 00000000..fd5cb705 Binary files /dev/null and b/tab_h.png differ diff --git a/tab_hd.png b/tab_hd.png new file mode 100644 index 00000000..2489273d Binary files /dev/null and b/tab_hd.png differ diff --git a/tab_s.png b/tab_s.png new file mode 100644 index 00000000..ab478c95 Binary files /dev/null and b/tab_s.png differ diff --git a/tab_sd.png b/tab_sd.png new file mode 100644 index 00000000..757a565c Binary files /dev/null and b/tab_sd.png differ diff --git a/tabs.css b/tabs.css new file mode 100644 index 00000000..71c8a470 --- /dev/null +++ b/tabs.css @@ -0,0 +1 @@ +.sm{position:relative;z-index:9999}.sm,.sm ul,.sm li{display:block;list-style:none;margin:0;padding:0;line-height:normal;direction:ltr;text-align:left;-webkit-tap-highlight-color:rgba(0,0,0,0)}.sm-rtl,.sm-rtl ul,.sm-rtl li{direction:rtl;text-align:right}.sm>li>h1,.sm>li>h2,.sm>li>h3,.sm>li>h4,.sm>li>h5,.sm>li>h6{margin:0;padding:0}.sm ul{display:none}.sm li,.sm a{position:relative}.sm a{display:block}.sm a.disabled{cursor:not-allowed}.sm:after{content:"\00a0";display:block;height:0;font:0/0 serif;clear:both;visibility:hidden;overflow:hidden}.sm,.sm *,.sm *:before,.sm *:after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.main-menu-btn{position:relative;display:inline-block;width:36px;height:36px;text-indent:36px;margin-left:8px;white-space:nowrap;overflow:hidden;cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0)}.main-menu-btn-icon,.main-menu-btn-icon:before,.main-menu-btn-icon:after{position:absolute;top:50%;left:2px;height:2px;width:24px;background:var(--nav-menu-button-color);-webkit-transition:all .25s;transition:all .25s}.main-menu-btn-icon:before{content:'';top:-7px;left:0}.main-menu-btn-icon:after{content:'';top:7px;left:0}#main-menu-state:checked ~ .main-menu-btn .main-menu-btn-icon{height:0}#main-menu-state:checked ~ .main-menu-btn .main-menu-btn-icon:before{top:0;-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}#main-menu-state:checked ~ .main-menu-btn .main-menu-btn-icon:after{top:0;-webkit-transform:rotate(45deg);transform:rotate(45deg)}#main-menu-state{position:absolute;width:1px;height:1px;margin:-1px;border:0;padding:0;overflow:hidden;clip:rect(1px,1px,1px,1px)}#main-menu-state:not(:checked) ~ #main-menu{display:none}#main-menu-state:checked ~ #main-menu{display:block}@media(min-width:768px){.main-menu-btn{position:absolute;top:-99999px}#main-menu-state:not(:checked) ~ #main-menu{display:block}}.sm-dox{background-image:var(--nav-gradient-image)}.sm-dox a,.sm-dox a:focus,.sm-dox a:hover,.sm-dox a:active{padding:0 12px;padding-right:43px;font-family:var(--font-family-nav);font-size:13px;font-weight:bold;line-height:36px;text-decoration:none;text-shadow:var(--nav-text-normal-shadow);color:var(--nav-text-normal-color);outline:0}.sm-dox a:hover{background-image:var(--nav-gradient-active-image);background-repeat:repeat-x;color:var(--nav-text-hover-color);text-shadow:var(--nav-text-hover-shadow)}.sm-dox a.current{color:#d23600}.sm-dox a.disabled{color:#bbb}.sm-dox a span.sub-arrow{position:absolute;top:50%;margin-top:-14px;left:auto;right:3px;width:28px;height:28px;overflow:hidden;font:bold 12px/28px monospace !important;text-align:center;text-shadow:none;background:var(--nav-menu-toggle-color);-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.sm-dox a span.sub-arrow:before{display:block;content:'+'}.sm-dox a.highlighted span.sub-arrow:before{display:block;content:'-'}.sm-dox>li:first-child>a,.sm-dox>li:first-child>:not(ul) a{-moz-border-radius:5px 5px 0 0;-webkit-border-radius:5px;border-radius:5px 5px 0 0}.sm-dox>li:last-child>a,.sm-dox>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul{-moz-border-radius:0 0 5px 5px;-webkit-border-radius:0;border-radius:0 0 5px 5px}.sm-dox>li:last-child>a.highlighted,.sm-dox>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted{-moz-border-radius:0;-webkit-border-radius:0;border-radius:0}.sm-dox ul{background:var(--nav-menu-background-color)}.sm-dox ul a,.sm-dox ul a:focus,.sm-dox ul a:hover,.sm-dox ul a:active{font-size:12px;border-left:8px solid transparent;line-height:36px;text-shadow:none;background-color:var(--nav-menu-background-color);background-image:none}.sm-dox ul a:hover{background-image:var(--nav-gradient-active-image);background-repeat:repeat-x;color:var(--nav-text-hover-color);text-shadow:0 1px 1px black}.sm-dox ul ul a,.sm-dox ul ul a:hover,.sm-dox ul ul a:focus,.sm-dox ul ul a:active{border-left:16px solid transparent}.sm-dox ul ul ul a,.sm-dox ul ul ul a:hover,.sm-dox ul ul ul a:focus,.sm-dox ul ul ul a:active{border-left:24px solid transparent}.sm-dox ul ul ul ul a,.sm-dox ul ul ul ul a:hover,.sm-dox ul ul ul ul a:focus,.sm-dox ul ul ul ul a:active{border-left:32px solid transparent}.sm-dox ul ul ul ul ul a,.sm-dox ul ul ul ul ul a:hover,.sm-dox ul ul ul ul ul a:focus,.sm-dox ul ul ul ul ul a:active{border-left:40px solid transparent}@media(min-width:768px){.sm-dox ul{position:absolute;width:12em}.sm-dox li{float:left}.sm-dox.sm-rtl li{float:right}.sm-dox ul li,.sm-dox.sm-rtl ul li,.sm-dox.sm-vertical li{float:none}.sm-dox a{white-space:nowrap}.sm-dox ul a,.sm-dox.sm-vertical a{white-space:normal}.sm-dox .sm-nowrap>li>a,.sm-dox .sm-nowrap>li>:not(ul) a{white-space:nowrap}.sm-dox{padding:0 10px;background-image:var(--nav-gradient-image);line-height:36px}.sm-dox a span.sub-arrow{top:50%;margin-top:-2px;right:12px;width:0;height:0;border-width:4px;border-style:solid dashed dashed dashed;border-color:var(--nav-text-normal-color) transparent transparent transparent;background:transparent;-moz-border-radius:0;-webkit-border-radius:0;border-radius:0}.sm-dox a,.sm-dox a:focus,.sm-dox a:active,.sm-dox a:hover,.sm-dox a.highlighted{padding:0 12px;background-image:var(--nav-separator-image);background-repeat:no-repeat;background-position:right;-moz-border-radius:0 !important;-webkit-border-radius:0;border-radius:0 !important}.sm-dox a:hover{background-image:var(--nav-gradient-active-image);background-repeat:repeat-x;color:var(--nav-text-hover-color);text-shadow:var(--nav-text-hover-shadow)}.sm-dox a:hover span.sub-arrow{border-color:var(--nav-text-hover-color) transparent transparent transparent}.sm-dox a.has-submenu{padding-right:24px}.sm-dox li{border-top:0}.sm-dox>li>ul:before,.sm-dox>li>ul:after{content:'';position:absolute;top:-18px;left:30px;width:0;height:0;overflow:hidden;border-width:9px;border-style:dashed dashed solid dashed;border-color:transparent transparent #bbb transparent}.sm-dox>li>ul:after{top:-16px;left:31px;border-width:8px;border-color:transparent transparent var(--nav-menu-background-color) transparent}.sm-dox ul{border:1px solid #bbb;padding:5px 0;background:var(--nav-menu-background-color);-moz-border-radius:5px !important;-webkit-border-radius:5px;border-radius:5px !important;-moz-box-shadow:0 5px 9px rgba(0,0,0,0.2);-webkit-box-shadow:0 5px 9px rgba(0,0,0,0.2);box-shadow:0 5px 9px rgba(0,0,0,0.2)}.sm-dox ul a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-color:transparent transparent transparent var(--nav-menu-foreground-color);border-style:dashed dashed dashed solid}.sm-dox ul a,.sm-dox ul a:hover,.sm-dox ul a:focus,.sm-dox ul a:active,.sm-dox ul a.highlighted{color:var(--nav-menu-foreground-color);background-image:none;border:0 !important;color:var(--nav-menu-foreground-color);background-image:none}.sm-dox ul a:hover{background-image:var(--nav-gradient-active-image);background-repeat:repeat-x;color:var(--nav-text-hover-color);text-shadow:var(--nav-text-hover-shadow)}.sm-dox ul a:hover span.sub-arrow{border-color:transparent transparent transparent var(--nav-text-hover-color)}.sm-dox span.scroll-up,.sm-dox span.scroll-down{position:absolute;display:none;visibility:hidden;overflow:hidden;background:var(--nav-menu-background-color);height:36px}.sm-dox span.scroll-up:hover,.sm-dox span.scroll-down:hover{background:#eee}.sm-dox span.scroll-up:hover span.scroll-up-arrow,.sm-dox span.scroll-up:hover span.scroll-down-arrow{border-color:transparent transparent #d23600 transparent}.sm-dox span.scroll-down:hover span.scroll-down-arrow{border-color:#d23600 transparent transparent transparent}.sm-dox span.scroll-up-arrow,.sm-dox span.scroll-down-arrow{position:absolute;top:0;left:50%;margin-left:-6px;width:0;height:0;overflow:hidden;border-width:6px;border-style:dashed dashed solid dashed;border-color:transparent transparent var(--nav-menu-foreground-color) transparent}.sm-dox span.scroll-down-arrow{top:8px;border-style:solid dashed dashed dashed;border-color:var(--nav-menu-foreground-color) transparent transparent transparent}.sm-dox.sm-rtl a.has-submenu{padding-right:12px;padding-left:24px}.sm-dox.sm-rtl a span.sub-arrow{right:auto;left:12px}.sm-dox.sm-rtl.sm-vertical a.has-submenu{padding:10px 20px}.sm-dox.sm-rtl.sm-vertical a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-rtl>li>ul:before{left:auto;right:30px}.sm-dox.sm-rtl>li>ul:after{left:auto;right:31px}.sm-dox.sm-rtl ul a.has-submenu{padding:10px 20px !important}.sm-dox.sm-rtl ul a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-vertical{padding:10px 0;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.sm-dox.sm-vertical a{padding:10px 20px}.sm-dox.sm-vertical a:hover,.sm-dox.sm-vertical a:focus,.sm-dox.sm-vertical a:active,.sm-dox.sm-vertical a.highlighted{background:#fff}.sm-dox.sm-vertical a.disabled{background-image:var(--nav-gradient-image)}.sm-dox.sm-vertical a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-style:dashed dashed dashed solid;border-color:transparent transparent transparent #555}.sm-dox.sm-vertical>li>ul:before,.sm-dox.sm-vertical>li>ul:after{display:none}.sm-dox.sm-vertical ul a{padding:10px 20px}.sm-dox.sm-vertical ul a:hover,.sm-dox.sm-vertical ul a:focus,.sm-dox.sm-vertical ul a:active,.sm-dox.sm-vertical ul a.highlighted{background:#eee}.sm-dox.sm-vertical ul a.disabled{background:var(--nav-menu-background-color)}} \ No newline at end of file diff --git a/todo.html b/todo.html new file mode 100644 index 00000000..b6072959 --- /dev/null +++ b/todo.html @@ -0,0 +1,134 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Todo List + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    +
    Todo List
    +
    +
    +
    +
    Member egoa::ArticulationVertexDetection< GraphType, IsDirected >::TreeOutDegree (TVertexId const vertex) const
    +
    description
    +
    Struct egoa::Auxiliary::MatchPathSeparator
    +

    Put in system dependent header

    +

    +
    +
    Class egoa::BlockCutTree< GraphType >
    +
    Example how a block-cut tree is constructed and how it can be used.
    +
    Member egoa::Bucket< PriorityQueue >::HasElement (TElement const &newElement, TElement &existingElement)
    +
    Think about it
    +
    Member egoa::Bucket< PriorityQueue >::Optima () const
    +
    Is this loop sufficient for unprocessed labels only?
    +
    Member egoa::DepthFirstSearch< GraphType, IsDirected, Recursive >::TypifyEdge (TVertexId source, TVertexId target)
    +
    Cross edge is only possible in directed case -> check for graph type
    +
    Class egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >
    +
    Usage example
    +
    Member egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughEdge (TVertexId target, std::vector< Types::count > &numberOfPathsPerEdge, std::vector< Types::real > &relativeNumberOfPathsPerEdge)
    +
    Use DAG property of label paths.
    +
    Member egoa::DominatingThetaPath< GraphType, LabelType, QueueType, LabelSetType, Domination >::NumberOfPathsThroughVertex (TVertexId target, std::vector< Types::count > &numberOfPathsPerVertex, std::vector< Types::real > &relativeNumberOfPathsPerVertex)
    +
    Use DAG property of label paths.
    +
    Member egoa::IeeeCdfMatlabParser< GraphType >::readNetwork (TNetwork &network)
    +
    add both possible function types
    +
    Member egoa::Label< ElementType, VertexSetContainer, PointerType >::Index () const
    +
    For the vertices and edges the equivalent function is called Identifier(), which is more in line with the nomenclature in the comments. However, the paramters are usually called index.
    +
    Member egoa::Label< ElementType, VertexSetContainer, PointerType >::PreviousLabel ()
    +
    It seems to be strange to call this a setter because it can also be used to "get" the value, e.g., the following code calls this member function but does not change the value:
    +
    Member egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId, Types::index timestampPosition) const
    +
    Logic for reactive power if data allows it. This is not clean.
    +
    Member egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorReactivePowerSnapshotAt (Types::generatorId generatorId, Types::timestampSnapshot timestamp) const
    +
    Reactive power is not supported in that way.
    +
    Member egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::GeneratorRealPowerSnapshotsAt (Types::timestampSnapshot timestamp, std::vector< Types::generatorSnapshot > &snapshotsAtTimestamp) const
    +
    Add the same for reactive power?
    +
    Member egoa::PowerGrid< GraphType, GeneratorProperty, LoadProperty >::TotalReactivePowerGenerationAt (Types::vertexId vertexId, Types::index timestampPosition=0) const
    +
    Use the same logic as in Real Power using snapshot -> GeneratorRealPowerSnapshotAt( generator, timestampPosition );
    +
    Member egoa::PowerGridIO< GraphType >::WriteGraphDot (PowerGrid< GraphType > const &network, std::ostream &outputStream)
    +
    Improve and put in its own file.
    +
    Member egoa::PyPsaParser< GraphType >::AddMaximumRealPowerSnapshotPuToGenerator (Types::name const &maximumRealPowerPu, TNetwork &network, Types::vertexId generatorId)
    +
    Check if the number of timestamps are correct
    +
    Member egoa::PyPsaParser< GraphType >::AddTimestampOfGenerator (Types::name const &name, TNetwork &network)
    +
    What happens if load timestamps does not exist?
    +
    Class egoa::SusceptanceNormLabel< ElementType, VertexSetContainer, PointerType >
    +
    What are the formal requirements for ElementType? From what I can see below, the following expressions must be valid:
    +
    Member egoa::Vertices::GeneratorProperties< VertexType >::PowerSign ()
    +
    make enum
    +
    Member egoa::Vertices::GeneratorProperties< VertexType >::PowerSign () const
    +
    make enum
    +
    Member egoa::Vertices::GeneratorProperties< VertexType >::Status ()
    +
    USE DIFFERENT TYPE see bus
    +
    Member egoa::Vertices::GeneratorProperties< VertexType >::Status () const
    +
    USE DIFFERENT TYPE see bus
    +
    +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + + diff --git a/topics.html b/topics.html new file mode 100644 index 00000000..cd0eca76 --- /dev/null +++ b/topics.html @@ -0,0 +1,86 @@ + + + + + + + +Energy Grid Optimization & Analysis (EGOA): Topics + + + + + + + + + +
    +
    + + + + + + +
    +
    Energy Grid Optimization & Analysis (EGOA) 1.0 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + +
    +
    Topics
    +
    +
    +
    Here is a list of all topics with brief descriptions:
    + + +
     Block-cut tree related classes and functions
    +
    +
    + +
    +Generated by doxygen 1.9.8 +
    + +