From 072f25cc0e4a5220cd6c649bc844681a02f6d5e2 Mon Sep 17 00:00:00 2001 From: StanislausCichocki Date: Tue, 11 Mar 2025 17:49:14 +0100 Subject: [PATCH] Cleaned up --- CMakeLists.txt | 2 + src/Config.h | 16 +++++ src/enums/Aut.h | 28 ++++++++ src/model/Building.cpp | 39 +++++++---- src/model/Building.h | 44 +++++++------ src/model/Community.cpp | 33 ++++++++-- src/model/Community.h | 23 ++++++- src/services/Surplus.cpp | 111 +++++++++++++++++++++----------- src/services/Surplus.h | 11 ++-- tests/model/Factory.h | 24 +++---- tests/services/test_Surplus.cpp | 12 ++-- 11 files changed, 249 insertions(+), 94 deletions(-) create mode 100644 src/Config.h create mode 100644 src/enums/Aut.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2c2f00a..cc479b0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,6 +21,8 @@ add_executable(Sim_C__ src/services/Cost/TaxComponent.cpp src/services/Cost/TaxComponent.h src/helper/Curry.h + src/enums/Aut.h + src/config.h ) find_package(doctest CONFIG REQUIRED) find_package(spdlog CONFIG REQUIRED) diff --git a/src/Config.h b/src/Config.h new file mode 100644 index 0000000..f2b3373 --- /dev/null +++ b/src/Config.h @@ -0,0 +1,16 @@ +// +// Created by StanislausCichocki on 11.03.2025. +// + +#ifndef CONFIG_H +#define CONFIG_H +#ifdef NDEBUG // Release mode + #define LOG_DEBUG_INFO(...) + #define LOG_DEBUG_ERROR(...) +#else + #define LOG_DEBUG_INFO(...) spdlog::info(__VA_ARGS__) + #define LOG_DEBUG_ERROR(...) spdlog::error(__VA_ARGS__) +#endif +#define VALUE_COUNT (4*24*365) + +#endif //CONFIG_H diff --git a/src/enums/Aut.h b/src/enums/Aut.h new file mode 100644 index 0000000..aad13c1 --- /dev/null +++ b/src/enums/Aut.h @@ -0,0 +1,28 @@ +// +// Created by StanislausCichocki on 11.03.2025. +// + +#ifndef AUT_H +#define AUT_H + + namespace Enums::AUT { + enum GridLevel { + GridLevel1, + GridLevel2, + GridLevel3, + GridLevel4, + GridLevel5, + GridLevel6, + GridLevel7WithP, + GridLevel7WithoutP, + GridLevel7Interruptable, + }; + enum EegType { + GEA, + LocalEeg, + RegionalEeg, + BEG + }; + } + +#endif //AUT_H diff --git a/src/model/Building.cpp b/src/model/Building.cpp index 5063f44..d722db2 100644 --- a/src/model/Building.cpp +++ b/src/model/Building.cpp @@ -20,39 +20,54 @@ void Building::Cost::set_special_rate_generation(float special_rate_generation) SpecialRateGeneration = special_rate_generation; } -std::vector > &Building::Simulation_Values::community_coverage() { +std::vector &Building::Simulation_Values::community_coverage() { return CommunityCoverage; } void Building::Simulation_Values:: -set_community_coverage(std::vector > community_coverage) { +set_community_coverage(std::vector community_coverage) { CommunityCoverage = std::move(community_coverage); } -std::vector > &Building::Simulation_Values::own_usage() { +std::vector &Building::Simulation_Values::own_usage() { return OwnUsage; } -void Building::Simulation_Values::set_own_usage(std::vector > own_usage) { +void Building::Simulation_Values::set_own_usage(std::vector own_usage) { OwnUsage = std::move(own_usage); } -std::vector > &Building::Simulation_Values::needed_con() { +std::vector &Building::Simulation_Values::needed_con() { return Needed_con; } -void Building::Simulation_Values::set_needed_con(std::vector > needed_con) { +void Building::Simulation_Values::set_needed_con(std::vector needed_con) { Needed_con = std::move(needed_con); } -std::vector > &Building::Simulation_Values::needed_gen() { +std::vector &Building::Simulation_Values::needed_gen() { return NeededGen; } -void Building::Simulation_Values::set_needed_gen(std::vector > needed_gen) { +void Building::Simulation_Values::set_needed_gen(std::vector needed_gen) { NeededGen = std::move(needed_gen); } +float Building::Simulation_Values::relativeSelfConsumption() const { + return RelativeSelfConsumption; +} + +void Building::Simulation_Values::set_relativeSelfConsumption(float const relativeSelfConsumption) { + this->RelativeSelfConsumption = relativeSelfConsumption; +} + +float Building::Simulation_Values::relativeSelfGeneration() const { + return RelativeGeneration; +} + +void Building::Simulation_Values::set_relativeSelfGeneration(float const relativeSelfGeneration) { + this->RelativeGeneration = relativeSelfGeneration; +} std::string Building::Metadata::name() const { return Name; } @@ -77,19 +92,19 @@ void Building::Metadata::set_annual_generation(float annual_generation) { AnnualGeneration = annual_generation; } -std::vector > &Building::Metadata::consumption_profile() { +std::vector &Building::Metadata::consumption_profile() { return ConsumptionProfile; } -void Building::Metadata::set_consumption_profile(std::vector > consumption_profile) { +void Building::Metadata::set_consumption_profile(std::vector consumption_profile) { ConsumptionProfile = std::move(consumption_profile); } -std::vector > &Building::Metadata::generation_profile() { +std::vector &Building::Metadata::generation_profile() { return GenerationProfile; } -void Building::Metadata::set_generation_profile(std::vector > generation_profile) { +void Building::Metadata::set_generation_profile(std::vector generation_profile) { GenerationProfile = std::move(generation_profile); } diff --git a/src/model/Building.h b/src/model/Building.h index 093902d..0ff4cd1 100644 --- a/src/model/Building.h +++ b/src/model/Building.h @@ -25,31 +25,39 @@ namespace Building { float special_rate_generation() const; void set_special_rate_generation(float special_rate_generation); + }; class Simulation_Values { private: - std::vector > CommunityCoverage; - std::vector > OwnUsage; - std::vector > Needed_con; - std::vector > NeededGen; + std::vector CommunityCoverage; + std::vector OwnUsage; + std::vector Needed_con; + std::vector NeededGen; + float RelativeSelfConsumption{0.0f}; + float RelativeGeneration{0.0f}; public: - std::vector > &community_coverage(); + std::vector &community_coverage(); - void set_community_coverage(std::vector > community_coverage); + void set_community_coverage(std::vector community_coverage); - std::vector > &own_usage(); + std::vector &own_usage(); - void set_own_usage(std::vector > own_usage); + void set_own_usage(std::vector own_usage); - std::vector > &needed_con(); + std::vector &needed_con(); - void set_needed_con(std::vector > needed_con); + void set_needed_con(std::vector needed_con); - std::vector > &needed_gen(); + std::vector &needed_gen(); - void set_needed_gen(std::vector > needed_gen); + void set_needed_gen(std::vector needed_gen); + + float relativeSelfConsumption() const; + void set_relativeSelfConsumption(float relativeSelfConsumption); + float relativeSelfGeneration() const; + void set_relativeSelfGeneration(float relativeSelfGeneration); }; class Metadata { @@ -57,8 +65,8 @@ namespace Building { std::string Name; float AnnualConsumption; float AnnualGeneration; - std::vector > ConsumptionProfile; - std::vector > GenerationProfile; + std::vector ConsumptionProfile; + std::vector GenerationProfile; std::string ConsumptionProfileName; std::string GenerationProfileName; short ConnectionPower; @@ -77,13 +85,13 @@ namespace Building { void set_annual_generation(float annual_generation); - std::vector > &consumption_profile(); + std::vector &consumption_profile(); - void set_consumption_profile(std::vector > consumption_profile); + void set_consumption_profile(std::vector consumption_profile); - std::vector > &generation_profile(); + std::vector &generation_profile(); - void set_generation_profile(std::vector > generation_profile); + void set_generation_profile(std::vector generation_profile); std::string consumption_profile_name() const; diff --git a/src/model/Community.cpp b/src/model/Community.cpp index 16570a0..dd34f1f 100644 --- a/src/model/Community.cpp +++ b/src/model/Community.cpp @@ -27,16 +27,41 @@ void Community::set_energy_tariff(const Energy_Tariff &energy_tariff) { energy_Tariff = energy_tariff; } +std::vector Community::GenerationAvailable() const { + return generationAvailable; +} + +void Community::set_generation_available(std::vector &generationAvailable) { + this->generationAvailable = generationAvailable; +} + +std::vector Community::ConsumptionAvailable() const { + return consumptionAvailable; +} + +void Community::set_consumption_available(std::vector &consumptionAvailable) { + this->consumptionAvailable = consumptionAvailable; +} + +std::vector Community::IsGenBiggerThanCon() const { + return isGenBiggerThanCon; +} + +void Community::set_is_gen_bigger_than_con(std::vector &isGenBiggerThanCon) { + this->isGenBiggerThanCon=isGenBiggerThanCon; +} + auto Community::iterateBuildings( - std::vector > &Communities) -> std::function &)>(const std::function &)> { + std::vector > &Communities) + -> std::function &)>(const std::function &)> { return [&](const std::function &func1) { - return [&, func1](const std::function &func2) { + return [&, func1](const std::function &func2) { iterateVector(Communities, func1); iterateVector(Communities, [&](Community &community) { for (auto &building: community.buildings()) { - func2(*building); + func2(community, *building); } }); }; diff --git a/src/model/Community.h b/src/model/Community.h index d9d3373..3b19250 100644 --- a/src/model/Community.h +++ b/src/model/Community.h @@ -7,12 +7,14 @@ #include #include +#include "../Config.h" #include "Building.h" #include "Energy_Tariff.h" class Community : public Model { public: + Community():generationAvailable(VALUE_COUNT, 0.0f),consumptionAvailable(VALUE_COUNT,0.0f){}; std::string name() const; void set_name(const std::string &name); @@ -25,13 +27,30 @@ public: void set_energy_tariff(const Energy_Tariff &energy_tariff); - static std::function &)> - (const std::function &)> + std::vector GenerationAvailable() const; + + void set_generation_available(std::vector &generationAvailable); + + std::vector ConsumptionAvailable() const; + + void set_consumption_available(std::vector &consumptionAvailable); + + std::vector IsGenBiggerThanCon() const; + + void set_is_gen_bigger_than_con(std::vector &isGenBiggerThanCon); + + static std::function &)>(const std:: + function &)> iterateBuildings(std::vector > &Communities); private: std::string Name; std::vector > Buildings; + std::vector generationAvailable; + std::vector consumptionAvailable; + std::vector isGenBiggerThanCon; + Energy_Tariff energy_Tariff; }; diff --git a/src/services/Surplus.cpp b/src/services/Surplus.cpp index fe38bc2..24d2e92 100644 --- a/src/services/Surplus.cpp +++ b/src/services/Surplus.cpp @@ -3,39 +3,48 @@ // #include -#ifdef NDEBUG // Release mode - #define LOG_DEBUG_INFO(...) - #define LOG_DEBUG_ERROR(...) -#else - #define LOG_DEBUG_INFO(...) spdlog::info(__VA_ARGS__) - #define LOG_DEBUG_ERROR(...) spdlog::error(__VA_ARGS__) -#endif #include "Surplus.h" #include "../model/Building.h" #include #include - +#include +#include void Surplus::CalculateSurplus() { auto iterateFunc = Community::iterateBuildings(communities); - auto modifyCommunity = [](Community &c) { + auto modifyCommunity = [this](Community &c) { + this->consumptionAvailable=std::vector(VALUE_COUNT, 00.f); + this->generationAvailable=std::vector(VALUE_COUNT, 00.f); + this->isGenBigger=std::vector(VALUE_COUNT, false); LOG_DEBUG_INFO("Calculating Surplus for Community: {}", c.name()); }; - auto modifyBuilding = [this](Building::Base &building) { - LOG_DEBUG_INFO("Calculating Surplus for Community: {}", building.metadata()->name()); - CalculateBuildingSurplus(building); + auto modifyBuildingSurplus = [this](Community &community, Building::Base &building) { + LOG_DEBUG_INFO("Calculating Surplus for Building: {} in Community: {}", + building.metadata()->name(), community.name()); + CalculateBuildingSurplus(community, building); }; - iterateFunc(modifyCommunity)(modifyBuilding); - - //TODO Calculate Relative Values + auto modifyBuildingSurplusCommunity = [this](Community &community, Building::Base &building) { + LOG_DEBUG_INFO("Calculating Surplus for Building: {} in Community: {}", + building.metadata()->name(), community.name()); + CalculateSurplusCommunity(community, building); + }; + iterateFunc(modifyCommunity)(modifyBuildingSurplus); + iterateFunc(modifyCommunity)(modifyBuildingSurplusCommunity); + auto addCommunityValues = [this](Community &community) { + community.set_consumption_available(this->consumptionAvailable); + community.set_generation_available(this->generationAvailable); + community.set_is_gen_bigger_than_con(this->isGenBigger); + }; + iterateFunc(addCommunityValues); } -void Surplus::CalculateBuildingSurplus(Building::Base &building) { - std::vector > ownCoverage; - std::vector > neededConsumption; - std::vector > neededGeneration; - std::vector > ownUsage; + +void Surplus::CalculateBuildingSurplus(Community &community, Building::Base &building) { + std::vector ownCoverage; + std::vector neededConsumption; + std::vector neededGeneration; + std::vector ownUsage; const auto &consumption = building.metadata()->consumption_profile(); const auto &generation = building.metadata()->generation_profile(); @@ -45,28 +54,58 @@ void Surplus::CalculateBuildingSurplus(Building::Base &building) { neededGeneration.reserve(consumption.size()); ownUsage.reserve(consumption.size()); - std::transform(consumption.begin(), consumption.end(), - generation.begin(), std::back_inserter(ownCoverage), - [&](const std::unique_ptr &c, const std::unique_ptr &g) { - auto own_cov = std::make_unique((c ? *c : 0.0f) - (g ? *g : 0.0f)); - ownCoverage.push_back(std::make_unique(*own_cov)); + std::ranges::for_each(consumption, [&](auto c_ptr) { + static size_t i = 0; // Keep track of index + const float c = c_ptr ? c_ptr : 0.0f; + const float g = (i < generation.size() && generation[i]) ? generation[i] : 0.0f; + const float c_community = (i < consumptionAvailable.size() && consumptionAvailable[i]) + ? consumptionAvailable[i] + : 0.0f; + const float g_community = (i < generationAvailable.size() && generationAvailable[i]) + ? generationAvailable[i] + : 0.0f; - neededConsumption.push_back(std::make_unique(c && *c > 0.0f ? *c : 0.0f)); - neededGeneration.push_back(std::make_unique(g && *g < 0.0f ? -*g : 0.0f)); - ownUsage.push_back(std::make_unique((c ? *c : 0.0f) - *neededConsumption.back())); + const auto ownCov = (c - g); + const auto neededCons = ((c > 0.0f) ? c : 0.0f); + const auto neededGen = ((g < 0.0f) ? -g : 0.0f); + const auto ownUs = (c - neededCons); + + const auto communityConsumption = c_community + neededCons; + const auto generationConsumption = g_community + neededGen; + + ownCoverage.push_back(ownCov); + neededConsumption.push_back(neededCons); + neededGeneration.push_back(neededGen); + ownUsage.push_back(ownUs); + this->consumptionAvailable[i] = communityConsumption; + this->generationAvailable[i] = generationConsumption; + this->isGenBigger[i] = generationAvailable[i] > consumptionAvailable[i]; + ++i; + }); - 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_con(std::move(neededConsumption)); 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; }); + if (building.metadata()->annual_consumption() > 0.0f) { + building.values()->set_relativeSelfConsumption( + std::accumulate(building.values()->own_usage().begin(), building.values()->own_usage().end(), 0.0f) / + std::accumulate(building.metadata()->consumption_profile().begin(), + building.metadata()->consumption_profile().end(), 0.0f)); + } else { + building.values()->set_relativeSelfConsumption(0.0f); + } + if (building.metadata()->annual_generation() > 0.0f) { + building.values()->set_relativeSelfGeneration( + std::accumulate(building.values()->own_usage().begin(), building.values()->own_usage().end(), 0.0f) / + std::accumulate(building.metadata()->generation_profile().begin(), + building.metadata()->generation_profile().end(), 0.0f)); + } else { + building.values()->set_relativeSelfGeneration(0.0f); + } } +void Surplus::CalculateSurplusCommunity(const Community &community, const Building::Base &base) { - - +} diff --git a/src/services/Surplus.h b/src/services/Surplus.h index 6cffd62..e000b5e 100644 --- a/src/services/Surplus.h +++ b/src/services/Surplus.h @@ -4,14 +4,13 @@ #ifndef SURPLUS_H #define SURPLUS_H -#define VALUE_COUNT (4*24*365) -#include + #include "../model/Community.h" +#include "../Config.h" +#include #include -class Community; - class Surplus { private: std::vector > &communities; @@ -28,7 +27,9 @@ public: void CalculateSurplus(); - void CalculateBuildingSurplus(Building::Base &); + void CalculateBuildingSurplus(Community &community, Building::Base &); + + void CalculateSurplusCommunity(const Community & community, const Building::Base & base); }; diff --git a/tests/model/Factory.h b/tests/model/Factory.h index 6b0839e..cd9ac42 100644 --- a/tests/model/Factory.h +++ b/tests/model/Factory.h @@ -25,17 +25,17 @@ public: std::unique_ptr static create_test_simulation_values() { auto values = std::make_unique(); - auto communityCoverage = std::vector >(); - auto ownUsage = std::vector >(); - auto neededCon = std::vector >(); - auto neededGen = std::vector >(); + auto communityCoverage = std::vector(); + auto ownUsage = std::vector(); + auto neededCon = std::vector(); + auto neededGen = std::vector(); for (int i = 0; i < 5; i++) { // Populate with test values - communityCoverage.push_back(std::make_unique(i * 10.0f)); - ownUsage.push_back(std::make_unique(i * 5.0f)); - neededCon.push_back(std::make_unique(i * 3.0f)); - neededGen.push_back(std::make_unique(i * 2.0f)); + communityCoverage.push_back(i * 10.0f); + ownUsage.push_back(i * 5.0f); + neededCon.push_back(i * 3.0f); + neededGen.push_back(i * 2.0f); } values->set_community_coverage(std::move(communityCoverage)); @@ -56,13 +56,13 @@ public: metadata->set_connection_power(100); metadata->set_grid_power(50); - auto consumptionProfile = std::vector >(); - auto generationProfile = std::vector >(); + auto consumptionProfile = std::vector(); + auto generationProfile = std::vector(); for (int i = 0; i < 5; i++) { // Populate with test values - consumptionProfile.push_back(std::make_unique(i * 100.0f)); - generationProfile.push_back(std::make_unique(i * 50.0f)); + consumptionProfile.push_back(i * 100.0f); + generationProfile.push_back(i * 50.0f); } metadata->set_consumption_profile(std::move(consumptionProfile)); diff --git a/tests/services/test_Surplus.cpp b/tests/services/test_Surplus.cpp index 806d2c6..31542fe 100644 --- a/tests/services/test_Surplus.cpp +++ b/tests/services/test_Surplus.cpp @@ -7,9 +7,11 @@ #include "../model/Factory.h" TEST_CASE("Testing add function") { - std::vector > communities; - communities.push_back(Factory::create_test_community()); - Surplus surplus(communities); - surplus.CalculateSurplus(); - CHECK(true); + std::vector > communities; + for (int i = 0; i < 1000; i++) { + communities.push_back(Factory::create_test_community()); + } + Surplus surplus(communities); + surplus.CalculateSurplus(); + CHECK(true); }