Added logic surplus calculation intrabuilding wise

CMakeLists.txt

@@ -7,8 +7,13 @@ add_executable(Sim_C__
         src/main.cpp
         src/model/Community.cpp
         src/model/Community.h
-        src/model/building/Building.cpp
-        src/model/building/Building.h
+        src/model/Building.cpp
+        src/model/Building.h
         src/model/Energy_Tariff.cpp
         src/model/Energy_Tariff.h
+        src/services/Surplus.cpp
+        src/services/Surplus.h
+        tests/services/test_Surplus.cpp
 )
+find_package(doctest CONFIG REQUIRED)
+target_link_libraries(Sim_C__ PRIVATE doctest::doctest)

src/main.cpp

@@ -2,4 +2,3 @@
 // Created by Stani on 09/03/2025.
 //
 
-int main(){}

src/model/Building.cpp

@@ -148,3 +148,12 @@ std::unique_ptr<Building::Metadata>& Building::Base::metadata() {
 void Building::Base::set_metadata(std::unique_ptr<Building::Metadata>  &metadata) {
     Metadata = std::move(metadata);
 }
+
+void Building::Base::iterateBuildings(std::vector<std::unique_ptr<Building::Base>> &buildings,
+const std::function<void(Building::Base &)>& function) {
+    for (auto &building : buildings) {
+        function(*building);
+    }
+}
+
+

src/model/Building.h

@@ -4,6 +4,7 @@
 
     #ifndef BUILDING_H
     #define BUILDING_H
+#include <functional>
     #include <memory>
     #include <vector>
 
@@ -79,6 +80,9 @@
             void set_values(std::unique_ptr<Simulation_Values>  &values);
             std::unique_ptr<Building::Metadata> & metadata();
             void set_metadata(std::unique_ptr<Building::Metadata>  &metadata);
+
+            static void iterateBuildings(std::vector<std::unique_ptr<Building::Base> > &buildings,
+                                         const std::function<void(Building::Base &)>& function);
         };
     }
 

src/model/Community.cpp

@@ -24,3 +24,10 @@ Energy_Tariff Community::energy_tariff() const {
 void Community::set_energy_tariff(const Energy_Tariff& energy_tariff) {
     energy_Tariff = energy_tariff;
 }
+
+void Community::iterateCommunities(std::vector<std::shared_ptr<Community>> &communities,
+                                 const std::function<void(std::shared_ptr<Community>&)> &function) {
+    for (auto &community : communities) {
+        function(community);
+    }
+}

src/model/Community.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <vector>
 
-#include "building/Building.h"
+#include "Building.h"
 #include "Energy_Tariff.h"
 
 
@@ -25,6 +25,9 @@ public:
 
     void set_energy_tariff(const Energy_Tariff &energy_tariff);
 
+    static void iterateCommunities(std::vector<std::shared_ptr<Community>> &communities,
+                                   const std::function<void(std::shared_ptr<Community> &)> &function);
+
 private:
     std::string Name;
     std::vector<std::unique_ptr<Building::Base>> Buildings;

src/services/Surplus.cpp

@@ -0,0 +1,47 @@
+//
+// Created by StanislausCichocki on 10.03.2025.
+//
+
+#define VALUE_COUNT (4*24*365)
+#include "Surplus.h"
+#include "../model/Building.h"
+#include <algorithm>
+#include <execution>
+#include <vector>
+
+
+void Surplus::CalculateSurplus(std::vector<std::shared_ptr<Community>> &communities) {
+    std::vector<float> consumptionAvailable(VALUE_COUNT, 0.0);
+    std::vector<float> generationAvailable(VALUE_COUNT, 0.0);
+
+     Community::iterateCommunities(communities, [&](const std::shared_ptr<Community>& community) {
+        auto &buildings = community->buildings();
+
+        Building::Base::iterateBuildings(buildings, [&](Building::Base &building) {
+            CalculateBuildingSurplus(building);
+        });
+    });
+}
+
+void Surplus::CalculateBuildingSurplus(Building::Base& building) {
+    std::vector ownCoverage(VALUE_COUNT, 0.0f);
+    std::vector neededConsumption(VALUE_COUNT, 0.0f);
+    std::vector neededGeneration(VALUE_COUNT, 0.0f);
+    std::vector ownUsage(VALUE_COUNT, 0.0f);
+
+    const auto& consumption = building.metadata()->consumption_profile();
+    const auto& generation = building.metadata()->generation_profile();
+
+    std::transform(consumption.begin(), consumption.end(),
+                   generation.begin(), ownCoverage.begin(),
+                   [&](const std::unique_ptr<float>& c, const std::unique_ptr<float>& g) {
+                       ownCoverage.push_back((c ? *c : 0.0f) - (g ? *g : 0.0f));
+                       neededConsumption.push_back((c && *c> 0.0f?*c:0.0f));
+                       neededGeneration.push_back((g && *g<0.0f?-*g:0.0f));
+                       ownUsage.push_back((c ? *c : 0.0f) - (neededConsumption.back()));
+                       return 0.0f;
+                   });
+}
+
+
+

src/services/Surplus.h

@@ -0,0 +1,28 @@
+//
+// Created by StanislausCichocki on 10.03.2025.
+//
+
+#ifndef SURPLUS_H
+#define SURPLUS_H
+#include <functional>
+#include <memory>
+#include "../model/Community.h"
+#include <vector>
+
+
+class Community;
+
+class Surplus {
+private:
+    std::vector<std::shared_ptr<Community>> &communities;
+    public:
+    Surplus(std::vector<std::shared_ptr<Community>> &communities):communities(communities){};
+
+    void CalculateSurplus(std::vector<std::shared_ptr<Community>> &communities);
+
+    void CalculateBuildingSurplus(Building::Base&);
+};
+
+
+
+#endif //SURPLUS_H

tests/services/test_Surplus.cpp

@@ -0,0 +1,9 @@
+//
+// Created by StanislausCichocki on 10.03.2025.
+//
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include "doctest/doctest.h"
+
+TEST_CASE("Testing add function") {
+ CHECK(true);
+}