stani/sim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed memory leak

Browse Source 
Added logging
This commit is contained in:
Stanislaus Cichcoki
2025-03-10 22:59:54 +01:00
parent efe5b1c0da
commit edbc301c02
10 changed files with 162 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -24,4 +24,5 @@ add_executable(Sim_C__
src/helper/Curry.h src/helper/Curry.h
) )
find_package(doctest CONFIG REQUIRED) find_package(doctest CONFIG REQUIRED)
target_link_libraries(Sim_C__ PRIVATE doctest::doctest) find_package(spdlog CONFIG REQUIRED)
target_link_libraries(Sim_C__ PRIVATE doctest::doctest spdlog::spdlog)

108
src/model/Building.cpp
View File

@ -4,184 +4,148 @@
#include "Building.h" #include "Building.h"
float Building::Cost::special_rate_consumption() const float Building::Cost::special_rate_consumption() const {
{
return SpecialRateConsumption; return SpecialRateConsumption;
} }
void Building::Cost::set_special_rate_consumption(float special_rate_consumption) void Building::Cost::set_special_rate_consumption(float special_rate_consumption) {
{
SpecialRateConsumption = special_rate_consumption; SpecialRateConsumption = special_rate_consumption;
} }
float Building::Cost::special_rate_generation() const float Building::Cost::special_rate_generation() const {
{
return SpecialRateGeneration; return SpecialRateGeneration;
} }
void Building::Cost::set_special_rate_generation(float special_rate_generation) void Building::Cost::set_special_rate_generation(float special_rate_generation) {
{
SpecialRateGeneration = special_rate_generation; SpecialRateGeneration = special_rate_generation;
} }
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::community_coverage() std::vector<std::unique_ptr<float> > &Building::Simulation_Values::community_coverage() {
{
return CommunityCoverage; return CommunityCoverage;
} }
void Building::Simulation_Values:: void Building::Simulation_Values::
set_community_coverage(std::vector<std::unique_ptr<float>> community_coverage) set_community_coverage(std::vector<std::unique_ptr<float> > community_coverage) {
{
CommunityCoverage = std::move(community_coverage); CommunityCoverage = std::move(community_coverage);
} }
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::own_usage() std::vector<std::unique_ptr<float> > &Building::Simulation_Values::own_usage() {
{
return OwnUsage; return OwnUsage;
} }
void Building::Simulation_Values::set_own_usage(std::vector<std::unique_ptr<float>> own_usage) void Building::Simulation_Values::set_own_usage(std::vector<std::unique_ptr<float> > own_usage) {
{
OwnUsage = std::move(own_usage); OwnUsage = std::move(own_usage);
} }
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::needed_con() std::vector<std::unique_ptr<float> > &Building::Simulation_Values::needed_con() {
{
return Needed_con; return Needed_con;
} }
void Building::Simulation_Values::set_needed_con(std::vector<std::unique_ptr<float>> needed_con) void Building::Simulation_Values::set_needed_con(std::vector<std::unique_ptr<float> > needed_con) {
{
Needed_con = std::move(needed_con); Needed_con = std::move(needed_con);
} }
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::needed_gen() std::vector<std::unique_ptr<float> > &Building::Simulation_Values::needed_gen() {
{
return NeededGen; return NeededGen;
} }
void Building::Simulation_Values::set_needed_gen(std::vector<std::unique_ptr<float>> needed_gen) void Building::Simulation_Values::set_needed_gen(std::vector<std::unique_ptr<float> > needed_gen) {
{
NeededGen = std::move(needed_gen); NeededGen = std::move(needed_gen);
} }
std::string Building::Metadata::name() const std::string Building::Metadata::name() const {
{
return Name; return Name;
} }
void Building::Metadata::set_name(const std::string& name) void Building::Metadata::set_name(const std::string &name) {
{
Name = name; Name = name;
} }
float Building::Metadata::annual_consumption() const float Building::Metadata::annual_consumption() const {
{
return AnnualConsumption; return AnnualConsumption;
} }
void Building::Metadata::set_annual_consumption(float annual_consumption) void Building::Metadata::set_annual_consumption(float annual_consumption) {
{
AnnualConsumption = annual_consumption; AnnualConsumption = annual_consumption;
} }
float Building::Metadata::annual_generation() const float Building::Metadata::annual_generation() const {
{
return AnnualGeneration; return AnnualGeneration;
} }
void Building::Metadata::set_annual_generation(float annual_generation) void Building::Metadata::set_annual_generation(float annual_generation) {
{
AnnualGeneration = annual_generation; AnnualGeneration = annual_generation;
} }
std::vector<std::unique_ptr<float>>& Building::Metadata::consumption_profile() std::vector<std::unique_ptr<float> > &Building::Metadata::consumption_profile() {
{
return ConsumptionProfile; return ConsumptionProfile;
} }
void Building::Metadata::set_consumption_profile(std::vector<std::unique_ptr<float>> consumption_profile) void Building::Metadata::set_consumption_profile(std::vector<std::unique_ptr<float> > consumption_profile) {
{
ConsumptionProfile = std::move(consumption_profile); ConsumptionProfile = std::move(consumption_profile);
} }
std::vector<std::unique_ptr<float>>& Building::Metadata::generation_profile() std::vector<std::unique_ptr<float> > &Building::Metadata::generation_profile() {
{
return GenerationProfile; return GenerationProfile;
} }
void Building::Metadata::set_generation_profile(std::vector<std::unique_ptr<float>> generation_profile) void Building::Metadata::set_generation_profile(std::vector<std::unique_ptr<float> > generation_profile) {
{
GenerationProfile = std::move(generation_profile); GenerationProfile = std::move(generation_profile);
} }
std::string Building::Metadata::consumption_profile_name() const std::string Building::Metadata::consumption_profile_name() const {
{
return ConsumptionProfileName; return ConsumptionProfileName;
} }
void Building::Metadata::set_consumption_profile_name(const std::string& consumption_profile_name) void Building::Metadata::set_consumption_profile_name(const std::string &consumption_profile_name) {
{
ConsumptionProfileName = consumption_profile_name; ConsumptionProfileName = consumption_profile_name;
} }
std::string Building::Metadata::generation_profile_name() const std::string Building::Metadata::generation_profile_name() const {
{
return GenerationProfileName; return GenerationProfileName;
} }
void Building::Metadata::set_generation_profile_name(const std::string& generation_profile_name) void Building::Metadata::set_generation_profile_name(const std::string &generation_profile_name) {
{
GenerationProfileName = generation_profile_name; GenerationProfileName = generation_profile_name;
} }
short Building::Metadata::connection_power() const short Building::Metadata::connection_power() const {
{
return ConnectionPower; return ConnectionPower;
} }
void Building::Metadata::set_connection_power(short connection_power) void Building::Metadata::set_connection_power(short connection_power) {
{
ConnectionPower = connection_power; ConnectionPower = connection_power;
} }
short Building::Metadata::grid_power() const short Building::Metadata::grid_power() const {
{
return GridPower; return GridPower;
} }
void Building::Metadata::set_grid_power(short grid_power) void Building::Metadata::set_grid_power(short grid_power) {
{
GridPower = grid_power; GridPower = grid_power;
} }
std::unique_ptr<Building::Cost>& Building::Base::cost() std::unique_ptr<Building::Cost> &Building::Base::cost() {
{
return Cost; return Cost;
} }
void Building::Base::set_cost(std::unique_ptr<Building::Cost> cost) void Building::Base::set_cost(std::unique_ptr<Building::Cost> cost) {
{
Cost = std::move(cost); Cost = std::move(cost);
} }
std::unique_ptr<Building::Simulation_Values>& Building::Base::values() std::unique_ptr<Building::Simulation_Values> &Building::Base::values() {
{
return Values; return Values;
} }
void Building::Base::set_values(std::unique_ptr<Simulation_Values> values) void Building::Base::set_values(std::unique_ptr<Simulation_Values> values) {
{
Values = std::move(values); Values = std::move(values);
} }
std::unique_ptr<Building::Metadata>& Building::Base::metadata() std::unique_ptr<Building::Metadata> &Building::Base::metadata() {
{
return Metadata; return Metadata;
} }
void Building::Base::set_metadata(std::unique_ptr<Building::Metadata> metadata) void Building::Base::set_metadata(std::unique_ptr<Building::Metadata> metadata) {
{
Metadata = std::move(metadata); Metadata = std::move(metadata);
} }

47
src/model/Building.h
View File

@ -11,23 +11,23 @@
#include "Model.h" #include "Model.h"
namespace Building namespace Building {
{ class Cost {
class Cost
{
private: private:
float SpecialRateConsumption; float SpecialRateConsumption;
float SpecialRateGeneration; float SpecialRateGeneration;
public: public:
float special_rate_consumption() const; float special_rate_consumption() const;
void set_special_rate_consumption(float special_rate_consumption); void set_special_rate_consumption(float special_rate_consumption);
float special_rate_generation() const; float special_rate_generation() const;
void set_special_rate_generation(float special_rate_generation); void set_special_rate_generation(float special_rate_generation);
}; };
class Simulation_Values class Simulation_Values {
{
private: private:
std::vector<std::unique_ptr<float> > CommunityCoverage; std::vector<std::unique_ptr<float> > CommunityCoverage;
std::vector<std::unique_ptr<float> > OwnUsage; std::vector<std::unique_ptr<float> > OwnUsage;
@ -36,17 +36,23 @@ namespace Building
public: public:
std::vector<std::unique_ptr<float> > &community_coverage(); std::vector<std::unique_ptr<float> > &community_coverage();
void set_community_coverage(std::vector<std::unique_ptr<float> > community_coverage); void set_community_coverage(std::vector<std::unique_ptr<float> > community_coverage);
std::vector<std::unique_ptr<float> > &own_usage(); std::vector<std::unique_ptr<float> > &own_usage();
void set_own_usage(std::vector<std::unique_ptr<float> > own_usage); void set_own_usage(std::vector<std::unique_ptr<float> > own_usage);
std::vector<std::unique_ptr<float> > &needed_con(); std::vector<std::unique_ptr<float> > &needed_con();
void set_needed_con(std::vector<std::unique_ptr<float> > needed_con); void set_needed_con(std::vector<std::unique_ptr<float> > needed_con);
std::vector<std::unique_ptr<float> > &needed_gen(); std::vector<std::unique_ptr<float> > &needed_gen();
void set_needed_gen(std::vector<std::unique_ptr<float> > needed_gen); void set_needed_gen(std::vector<std::unique_ptr<float> > needed_gen);
}; };
class Metadata class Metadata {
{
private: private:
std::string Name; std::string Name;
float AnnualConsumption; float AnnualConsumption;
@ -60,27 +66,43 @@ namespace Building
public: public:
std::string name() const; std::string name() const;
void set_name(const std::string &name); void set_name(const std::string &name);
float annual_consumption() const; float annual_consumption() const;
void set_annual_consumption(float annual_consumption); void set_annual_consumption(float annual_consumption);
float annual_generation() const; float annual_generation() const;
void set_annual_generation(float annual_generation); void set_annual_generation(float annual_generation);
std::vector<std::unique_ptr<float> > &consumption_profile(); std::vector<std::unique_ptr<float> > &consumption_profile();
void set_consumption_profile(std::vector<std::unique_ptr<float> > consumption_profile); void set_consumption_profile(std::vector<std::unique_ptr<float> > consumption_profile);
std::vector<std::unique_ptr<float> > &generation_profile(); std::vector<std::unique_ptr<float> > &generation_profile();
void set_generation_profile(std::vector<std::unique_ptr<float> > generation_profile); void set_generation_profile(std::vector<std::unique_ptr<float> > generation_profile);
std::string consumption_profile_name() const; std::string consumption_profile_name() const;
void set_consumption_profile_name(const std::string &consumption_profile_name); void set_consumption_profile_name(const std::string &consumption_profile_name);
std::string generation_profile_name() const; std::string generation_profile_name() const;
void set_generation_profile_name(const std::string &generation_profile_name); void set_generation_profile_name(const std::string &generation_profile_name);
short connection_power() const; short connection_power() const;
void set_connection_power(short connection_power); void set_connection_power(short connection_power);
short grid_power() const; short grid_power() const;
void set_grid_power(short grid_power); void set_grid_power(short grid_power);
}; };
class Base : public Model<Base> class Base : public Model<Base> {
{
private: private:
std::unique_ptr<Cost> Cost; std::unique_ptr<Cost> Cost;
std::unique_ptr<Simulation_Values> Values; std::unique_ptr<Simulation_Values> Values;
@ -88,10 +110,15 @@ namespace Building
public: public:
std::unique_ptr<Building::Cost> &cost(); std::unique_ptr<Building::Cost> &cost();
void set_cost(std::unique_ptr<Building::Cost> cost); void set_cost(std::unique_ptr<Building::Cost> cost);
std::unique_ptr<Simulation_Values> &values(); std::unique_ptr<Simulation_Values> &values();
void set_values(std::unique_ptr<Simulation_Values> values); void set_values(std::unique_ptr<Simulation_Values> values);
std::unique_ptr<Building::Metadata> &metadata(); std::unique_ptr<Building::Metadata> &metadata();
void set_metadata(std::unique_ptr<Building::Metadata> metadata); void set_metadata(std::unique_ptr<Building::Metadata> metadata);
}; };
} }

33
src/model/Community.cpp
View File

@ -2,51 +2,40 @@
#include "../helper/Curry.h" #include "../helper/Curry.h"
std::string Community::name() const std::string Community::name() const {
{
return Name; return Name;
} }
void Community::set_name(const std::string& name) void Community::set_name(const std::string &name) {
{
Name = name; Name = name;
} }
std::vector<std::unique_ptr<Building::Base>>& Community::buildings() std::vector<std::unique_ptr<Building::Base> > &Community::buildings() {
{
return Buildings; return Buildings;
} }
// Use move semantics for efficiency // Use move semantics for efficiency
void Community::set_buildings(std::vector<std::unique_ptr<Building::Base>> buildings) void Community::set_buildings(std::vector<std::unique_ptr<Building::Base> > buildings) {
{
Buildings = std::move(buildings); Buildings = std::move(buildings);
} }
Energy_Tariff Community::energy_tariff() const Energy_Tariff Community::energy_tariff() const {
{
return energy_Tariff; return energy_Tariff;
} }
void Community::set_energy_tariff(const Energy_Tariff& energy_tariff) void Community::set_energy_tariff(const Energy_Tariff &energy_tariff) {
{
energy_Tariff = energy_tariff; energy_Tariff = energy_tariff;
} }
auto Community::iterateBuildings( auto Community::iterateBuildings(
std::vector<std::unique_ptr<Community> > &Communities) -> std::function<std::function<void( std::vector<std::unique_ptr<Community> > &Communities) -> std::function<std::function<void(
const std::function<void(Building::Base&)>&)>(const std::function<void(Community&)>&)> const std::function<void(Building::Base &)> &)>(const std::function<void(Community &)> &)> {
{ return [&](const std::function<void(Community &)> &func1) {
return [&](const std::function<void(Community&)>& func1) return [&, func1](const std::function<void(Building::Base &)> &func2) {
{
return [&, func1](const std::function<void(Building::Base&)>& func2)
{
iterateVector(Communities, func1); iterateVector(Communities, func1);
iterateVector(Communities, [&](Community& community) iterateVector(Communities, [&](Community &community) {
{ for (auto &building: community.buildings()) {
for (auto& building : community.buildings())
{
func2(*building); func2(*building);
} }
}); });

3
src/model/Community.h
View File

@ -11,8 +11,7 @@
#include "Energy_Tariff.h" #include "Energy_Tariff.h"
class Community : public Model<Community> class Community : public Model<Community> {
{
public: public:
std::string name() const; std::string name() const;

3
src/model/Energy_Tariff.h
View File

@ -6,8 +6,7 @@
#define ENERGY_TARIFF_H #define ENERGY_TARIFF_H
class Energy_Tariff class Energy_Tariff {
{
}; };

22
src/services/Surplus.cpp
View File

@ -5,21 +5,17 @@
#include "Surplus.h" #include "Surplus.h"
#include "../model/Building.h" #include "../model/Building.h"
#include <algorithm> #include <algorithm>
#include <execution>
#include <iostream>
#include <vector> #include <vector>
#include <spdlog/spdlog.h>
void Surplus::CalculateSurplus() void Surplus::CalculateSurplus() {
{
auto iterateFunc = Community::iterateBuildings(communities); auto iterateFunc = Community::iterateBuildings(communities);
auto modifyCommunity = [](Community& c) auto modifyCommunity = [](Community &c) {
{ spdlog::info("Calculating Surplus for Community: {}", c.name());
std::cout << "Processing Community\n";
}; };
auto modifyBuilding = [this](Building::Base& building) auto modifyBuilding = [this](Building::Base &building) {
{ spdlog::info("Calculating Surplus for Community: {}", building.metadata()->name());
std::cout << "Processing Building\n";
CalculateBuildingSurplus(building); CalculateBuildingSurplus(building);
}; };
iterateFunc(modifyCommunity)(modifyBuilding); iterateFunc(modifyCommunity)(modifyBuilding);
@ -27,8 +23,7 @@ void Surplus::CalculateSurplus()
//TODO Calculate Relative Values //TODO Calculate Relative Values
} }
void Surplus::CalculateBuildingSurplus(Building::Base& building) void Surplus::CalculateBuildingSurplus(Building::Base &building) {
{
std::vector<std::unique_ptr<float> > ownCoverage; std::vector<std::unique_ptr<float> > ownCoverage;
std::vector<std::unique_ptr<float> > neededConsumption; std::vector<std::unique_ptr<float> > neededConsumption;
std::vector<std::unique_ptr<float> > neededGeneration; std::vector<std::unique_ptr<float> > neededGeneration;
@ -44,8 +39,7 @@ void Surplus::CalculateBuildingSurplus(Building::Base& building)
std::transform(consumption.begin(), consumption.end(), std::transform(consumption.begin(), consumption.end(),
generation.begin(), std::back_inserter(ownCoverage), generation.begin(), std::back_inserter(ownCoverage),
[&](const std::unique_ptr<float>& c, const std::unique_ptr<float>& g) [&](const std::unique_ptr<float> &c, const std::unique_ptr<float> &g) {
{
auto own_cov = std::make_unique<float>((c ? *c : 0.0f) - (g ? *g : 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)); ownCoverage.push_back(std::make_unique<float>(*own_cov));

6
src/services/Surplus.h
View File

@ -12,8 +12,7 @@
class Community; class Community;
class Surplus class Surplus {
{
private: private:
std::vector<std::unique_ptr<Community> > &communities; std::vector<std::unique_ptr<Community> > &communities;
std::vector<float> consumptionAvailable; std::vector<float> consumptionAvailable;
@ -24,8 +23,7 @@ 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), consumptionAvailable(VALUE_COUNT, 0.0f),
generationAvailable(VALUE_COUNT, 0.0f), generationAvailable(VALUE_COUNT, 0.0f),
isGenBigger((VALUE_COUNT, false)) isGenBigger(VALUE_COUNT, false) {
{
} }
void CalculateSurplus(); void CalculateSurplus();

33
tests/model/Factory.h
View File

@ -9,24 +9,20 @@
#include "../../src/model/Community.h" #include "../../src/model/Community.h"
#include "../../src/model/Energy_Tariff.h" #include "../../src/model/Energy_Tariff.h"
namespace Building namespace Building {
{
class Cost; class Cost;
} }
class Factory class Factory {
{
public: public:
std::unique_ptr<Building::Cost> static create_test_cost() std::unique_ptr<Building::Cost> static create_test_cost() {
{
auto cost = std::make_unique<Building::Cost>(); auto cost = std::make_unique<Building::Cost>();
cost->set_special_rate_consumption(0.15f); cost->set_special_rate_consumption(0.15f);
cost->set_special_rate_generation(0.10f); cost->set_special_rate_generation(0.10f);
return cost; return cost;
} }
std::unique_ptr<Building::Simulation_Values> static create_test_simulation_values() std::unique_ptr<Building::Simulation_Values> static create_test_simulation_values() {
{
auto values = std::make_unique<Building::Simulation_Values>(); auto values = std::make_unique<Building::Simulation_Values>();
auto communityCoverage = std::vector<std::unique_ptr<float> >(); auto communityCoverage = std::vector<std::unique_ptr<float> >();
@ -34,8 +30,7 @@ public:
auto neededCon = std::vector<std::unique_ptr<float> >(); auto neededCon = std::vector<std::unique_ptr<float> >();
auto neededGen = std::vector<std::unique_ptr<float> >(); auto neededGen = std::vector<std::unique_ptr<float> >();
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++) {
{
// Populate with test values // Populate with test values
communityCoverage.push_back(std::make_unique<float>(i * 10.0f)); communityCoverage.push_back(std::make_unique<float>(i * 10.0f));
ownUsage.push_back(std::make_unique<float>(i * 5.0f)); ownUsage.push_back(std::make_unique<float>(i * 5.0f));
@ -51,8 +46,7 @@ public:
return values; return values;
} }
std::unique_ptr<Building::Metadata> static create_test_metadata() std::unique_ptr<Building::Metadata> static create_test_metadata() {
{
auto metadata = std::make_unique<Building::Metadata>(); auto metadata = std::make_unique<Building::Metadata>();
metadata->set_name("Test Building"); metadata->set_name("Test Building");
metadata->set_annual_consumption(12000.0f); metadata->set_annual_consumption(12000.0f);
@ -65,8 +59,7 @@ public:
auto consumptionProfile = std::vector<std::unique_ptr<float> >(); auto consumptionProfile = std::vector<std::unique_ptr<float> >();
auto generationProfile = std::vector<std::unique_ptr<float> >(); auto generationProfile = std::vector<std::unique_ptr<float> >();
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++) {
{
// Populate with test values // Populate with test values
consumptionProfile.push_back(std::make_unique<float>(i * 100.0f)); consumptionProfile.push_back(std::make_unique<float>(i * 100.0f));
generationProfile.push_back(std::make_unique<float>(i * 50.0f)); generationProfile.push_back(std::make_unique<float>(i * 50.0f));
@ -78,8 +71,7 @@ public:
return metadata; return metadata;
} }
std::unique_ptr<Building::Base> static create_test_building() std::unique_ptr<Building::Base> static create_test_building() {
{
auto building = std::make_unique<Building::Base>(); auto building = std::make_unique<Building::Base>();
building->set_cost(create_test_cost()); building->set_cost(create_test_cost());
@ -89,19 +81,16 @@ public:
return building; return building;
} }
Energy_Tariff static create_test_energy_tariff() Energy_Tariff static create_test_energy_tariff() {
{
return {}; return {};
} }
std::unique_ptr<Community> static create_test_community() std::unique_ptr<Community> static create_test_community() {
{
auto community = std::make_unique<Community>(); auto community = std::make_unique<Community>();
community->set_name("Test Community"); community->set_name("Test Community");
std::vector<std::unique_ptr<Building::Base> > buildings; std::vector<std::unique_ptr<Building::Base> > buildings;
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++) {
{
buildings.push_back(create_test_building()); buildings.push_back(create_test_building());
} }

3
tests/services/test_Surplus.cpp
View File

@ -6,8 +6,7 @@
#include "doctest/doctest.h" #include "doctest/doctest.h"
#include "../model/Factory.h" #include "../model/Factory.h"
TEST_CASE("Testing add function") TEST_CASE("Testing add function") {
{
std::vector<std::unique_ptr<Community> > communities; std::vector<std::unique_ptr<Community> > communities;
communities.push_back(Factory::create_test_community()); communities.push_back(Factory::create_test_community());
Surplus surplus(communities); Surplus surplus(communities);