fixed errors in cost calculation

src/model/Building.cpp

@@ -162,7 +162,7 @@ float Building::Simulation_Values::own_usage_sum() const {
     return OwnUsageSum;
 }
 
-void Building::Simulation_Values::set_ownUsageSum(const float value) {
+void Building::Simulation_Values::set_own_usage_sum(const float value) {
     OwnUsageSum = value;
 }
 
@@ -170,7 +170,7 @@ float Building::Simulation_Values::needed_con_sum() const {
     return NeededConSum;
 }
 
-void Building::Simulation_Values::set_neededConSum(const float value) {
+void Building::Simulation_Values::set_needed_con_sum(const float value) {
     NeededConSum = value;
 }
 
@@ -178,7 +178,7 @@ float Building::Simulation_Values::needed_gen_sum() const {
     return NeededGenSum;
 }
 
-void Building::Simulation_Values::set_neededGenSum(const float value) {
+void Building::Simulation_Values::set_needed_gen_sum(const float value) {
     NeededGenSum = value;
 }
 

src/model/Building.h

@@ -105,11 +105,11 @@ namespace Building
         [[nodiscard]] float consumption_after_own_coverage_sum() const;
         void set_consumption_after_own_coverage_sum(float value);
         [[nodiscard]] float own_usage_sum() const;
-        void set_ownUsageSum(float value);
+        void set_own_usage_sum(float value);
         [[nodiscard]] float needed_con_sum() const;
-        void set_neededConSum(float value);
+        void set_needed_con_sum(float value);
         [[nodiscard]] float needed_gen_sum() const;
-        void set_neededGenSum(float value);
+        void set_needed_gen_sum(float value);
         [[nodiscard]] float consumption_after_community_sum() const;
         void set_consumption_after_community_sum(float value);
         [[nodiscard]] float generation_after_community_sum() const;

src/model/Energy_Tariff.h

@@ -8,10 +8,10 @@
 
 class Energy_Tariff {
 public:
-    float consumption_tariff{1.0f};
+    float consumption_tariff{0.0f};
-    float generation_tariff{1.0f};
+    float generation_tariff{0.0f};
-    float bill_charge{1.0f};
+    float bill_charge{0.0f};
-    float service_charge{1.0f};
+    float service_charge{0.0f};
 };
 
 

src/services/Cost/CalculateFinalSums.cpp

@@ -14,5 +14,5 @@ void CalculateFinalSums::apply(std::unique_ptr<Building::Base>& building, std::u
 
     metadata->set_total_cost_without(valuesWithout->total_cost());
     metadata->set_total_by_category_without(valuesWithout->calculateCategories());
-    community->total = valuesWithout->total_cost();
+    community->total += valuesWithout->total_cost();
 }

src/services/Cost/CostPipeline.cpp

@@ -10,11 +10,14 @@ void CostPipeline::addCostComponent(const std::shared_ptr<ICostComponent> &compo
 }
 
 void CostPipeline::calculateFinalCost() {
-    for (auto &component: this->components) {
+    for (size_t i = 0; i < this->components.size() - 1; i++) {
-        iterateCommunity(component);
+        iterateCommunity(this->components[i]);
     }
+    // Ensure CalculateFinalSums is last
+    iterateCommunity(this->components.back());
 }
 
+
 void CostPipeline::iterateCommunity(std::shared_ptr<ICostComponent> &component) const {
     for (auto &community: this->communities) {
         iterateBuilding(community, component);

src/services/Surplus.cpp

@@ -161,7 +161,7 @@ void Surplus::CalculateSurplusCommunity(Community &community, Building::Base &ba
         con_after = needed_c - con_from;
         gen_after = needed_g - gen_to;
     }
-
+    CalculateSums(base);
     if (base.metadata()->annual_consumption() != 0) {
         base.values()->set_con_from_community_relative(
             std::accumulate(base.values()->consumption_from_community().begin(),
@@ -175,3 +175,15 @@ void Surplus::CalculateSurplusCommunity(Community &community, Building::Base &ba
                             0.0f) / base.metadata()->annual_generation());
     }
 }
+
+void  Surplus::CalculateSums(Building::Base &base) {
+    const auto& values = base.values();
+    values->set_consumption_after_own_coverage_sum(std::accumulate(values->consumption_after_own_coverage().begin(),values->consumption_after_own_coverage().end(),0.f));
+    values->set_own_usage_sum(std::accumulate(values->own_usage().begin(),values->own_usage().end(),0.f));
+    values->set_needed_con_sum(std::accumulate(values->needed_con().begin(),values->needed_con().end(),0.f));
+    values->set_needed_gen_sum(std::accumulate(values->needed_gen().begin(),values->needed_gen().end(),0.f));
+    values->set_consumption_after_community_sum(std::accumulate(values->consumption_after_community().begin(),values->consumption_after_community().end(),0.f));
+    values->set_generation_after_community_sum(std::accumulate(values->generation_after_community().begin(),values->generation_after_community().end(),0.f));
+    values->set_consumption_from_community_sum(std::accumulate(values->consumption_from_community().begin(),values->consumption_from_community().end(),0.f));
+    values->set_generation_to_community_sum(std::accumulate(values->generation_to_community().begin(),values->generation_to_community().end(),0.f));
+}

src/services/Surplus.h

@@ -27,7 +27,9 @@ public:
 
     void CalculateBuildingSurplus(Community &community, Building::Base &);
 
-    static void CalculateSurplusCommunity(Community &community, Building::Base &base);
+    void CalculateSurplusCommunity(Community &community, Building::Base &base);
+
+    void CalculateSums(Building::Base &base);
 };
 
 

tests/model/Factory.h

@@ -8,6 +8,7 @@
 #include "../../src/model/Building.h"
 #include "../../src/model/Community.h"
 #include "../../src/model/Energy_Tariff.h"
+#include "../../src/Config.h"
 
 namespace Building {
     class Cost;
@@ -43,12 +44,14 @@ public:
     std::unique_ptr<Building::Metadata> static create_test_metadata() {
         auto metadata = std::make_unique<Building::Metadata>();
         metadata->set_name("Test Building");
-        metadata->set_annual_consumption(12000.0f);
+        metadata->set_annual_consumption(3000.0f);
-        metadata->set_annual_generation(5000.0f);
+        metadata->set_annual_generation(0.0f);
         metadata->set_consumption_profile_name("Profile_1");
         metadata->set_generation_profile_name("Profile_2");
-        metadata->set_connection_power(100);
+        metadata->set_connection_power(1);
         metadata->set_grid_power(50);
+        metadata->set_consumption_net_price(0.10f);
+        metadata->set_generation_net_price(0.12f);
 
         metadata->set_special_rate_consumption(0.15f);
         metadata->set_special_rate_generation(0.10f);
@@ -56,10 +59,11 @@ public:
         auto consumptionProfile = std::vector<float>();
         auto generationProfile = std::vector<float>();
 
-        for (int i = 0; i < 5; i++) {
+        for (int i = 0; i < VALUE_COUNT; i++) {
             // Populate with test values
-            consumptionProfile.push_back(static_cast<float>(i) * 100.0f);
+            consumptionProfile.push_back(static_cast<float>(i) * (VALUE_COUNT % 100));
-            generationProfile.push_back(static_cast<float>(i) * 50.0f);
+
+            generationProfile.push_back(static_cast<float>(i) * (VALUE_COUNT % 50));
         }
 
         metadata->set_consumption_profile(std::move(consumptionProfile));
@@ -84,7 +88,6 @@ public:
     std::unique_ptr<Community> static create_test_community() {
         auto community = std::make_unique<Community>();
         community->set_name("Test Community");
-
         std::vector<std::unique_ptr<Building::Base> > buildings;
         for (int i = 0; i < 10; i++) {
             buildings.push_back(create_test_building());

tests/services/test_Surplus.cpp

@@ -23,6 +23,8 @@ TEST_CASE("Testing add function") {
     }
     Surplus surplus(communities);
     surplus.CalculateSurplus();
+
+    LOG_DEBUG_INFO("Add components");
     CostPipeline costPipeline(communities);
     costPipeline.addCostComponent(std::make_shared<NetworkProvider>());
     costPipeline.addCostComponent(std::make_shared<BillCharge>());