finished intra calculation

src/services/Surplus.cpp

@@ -2,7 +2,6 @@
 // Created by StanislausCichocki on 10.03.2025.
 //
 
-#define VALUE_COUNT (4*24*365)
 #include "Surplus.h"
 #include "../model/Building.h"
 #include <algorithm>
@@ -11,44 +10,61 @@
 #include <vector>
 
 
-void Surplus::CalculateSurplus(std::vector<std::unique_ptr<Community>>& communities)
+void Surplus::CalculateSurplus()
 {
-    std::vector<float> consumptionAvailable(VALUE_COUNT, 0.0);
-    std::vector<float> generationAvailable(VALUE_COUNT, 0.0);
     auto iterateFunc = Community::iterateBuildings(communities);
     auto modifyCommunity = [](Community& c)
     {
         std::cout << "Processing Community\n";
     };
-    auto modifyBuilding = [](Building::Base& building)
+    auto modifyBuilding = [this](Building::Base& building)
     {
         std::cout << "Processing Building\n";
         CalculateBuildingSurplus(building);
     };
     iterateFunc(modifyCommunity)(modifyBuilding);
+
+    //TODO Calculate Relative Values
 }
 
 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);
+    std::vector<std::unique_ptr<float>> ownCoverage;
+    std::vector<std::unique_ptr<float>> neededConsumption;
+    std::vector<std::unique_ptr<float>> neededGeneration;
+    std::vector<std::unique_ptr<float>> ownUsage;
 
     const auto& consumption = building.metadata()->consumption_profile();
     const auto& generation = building.metadata()->generation_profile();
 
+    ownCoverage.reserve(consumption.size());
+    neededConsumption.reserve(consumption.size());
+    neededGeneration.reserve(consumption.size());
+    ownUsage.reserve(consumption.size());
+
     std::transform(consumption.begin(), consumption.end(),
-                   generation.begin(), ownCoverage.begin(),
+                   generation.begin(), std::back_inserter(ownCoverage),
                    [&](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;
+                       auto own_cov = std::make_unique<float>((c ? *c : 0.0f) - (g ? *g : 0.0f));
+                       ownCoverage.push_back(std::make_unique<float>(*own_cov));
+
+                       neededConsumption.push_back(std::make_unique<float>(c && *c > 0.0f ? *c : 0.0f));
+                       neededGeneration.push_back(std::make_unique<float>(g && *g < 0.0f ? -*g : 0.0f));
+                       ownUsage.push_back(std::make_unique<float>((c ? *c : 0.0f) - *neededConsumption.back()));
+
+                       return std::move(own_cov);
                    });
+    building.values()->set_community_coverage(std::move(ownCoverage));
+    building.values()->set_needed_con(std::move(neededGeneration));
+    building.values()->set_needed_gen(std::move(neededGeneration));
+    building.values()->set_own_usage(std::move(ownUsage));
+
+
+    std::transform(generationAvailable.begin(), generationAvailable.end(), consumptionAvailable.begin(),
+                   isGenBigger.begin(), [&](const float a, const float b) { return a > b; });
 }
 
 
 
+

src/services/Surplus.h

@@ -4,7 +4,7 @@
 
 #ifndef SURPLUS_H
 #define SURPLUS_H
-#include <functional>
+#define VALUE_COUNT (4*24*365)
 #include <memory>
 #include "../model/Community.h"
 #include <vector>
@@ -16,15 +16,21 @@ class Surplus
 {
 private:
     std::vector<std::unique_ptr<Community>>& communities;
+    std::vector<float> consumptionAvailable;
+    std::vector<float> generationAvailable;
+    std::vector<bool> isGenBigger;
 
 public:
-    Surplus(std::vector<std::unique_ptr<Community>>& communities) : communities(communities)
+    Surplus(std::vector<std::unique_ptr<Community>>& communities) : communities(communities),
+                                                                    consumptionAvailable(VALUE_COUNT, 0.0f),
+                                                                    generationAvailable(VALUE_COUNT, 0.0f),
+                                                                    isGenBigger((VALUE_COUNT, false))
     {
     }
 
-    void static CalculateSurplus(std::vector<std::unique_ptr<Community>>& communities);
+    void CalculateSurplus();
 
-    void static CalculateBuildingSurplus(Building::Base&);
+    void CalculateBuildingSurplus(Building::Base&);
 };