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
)
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"
float Building::Cost::special_rate_consumption() const
{
float Building::Cost::special_rate_consumption() const {
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;
}
float Building::Cost::special_rate_generation() const
{
float Building::Cost::special_rate_generation() const {
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;
}
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::community_coverage()
{
std::vector<std::unique_ptr<float> > &Building::Simulation_Values::community_coverage() {
return CommunityCoverage;
}
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);
}
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::own_usage()
{
std::vector<std::unique_ptr<float> > &Building::Simulation_Values::own_usage() {
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);
}
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;
}
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);
}
std::vector<std::unique_ptr<float>>& Building::Simulation_Values::needed_gen()
{
std::vector<std::unique_ptr<float> > &Building::Simulation_Values::needed_gen() {
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);
}
std::string Building::Metadata::name() const
{
std::string Building::Metadata::name() const {
return Name;
}
void Building::Metadata::set_name(const std::string& name)
{
void Building::Metadata::set_name(const std::string &name) {
Name = name;
}
float Building::Metadata::annual_consumption() const
{
float Building::Metadata::annual_consumption() const {
return AnnualConsumption;
}
void Building::Metadata::set_annual_consumption(float annual_consumption)
{
void Building::Metadata::set_annual_consumption(float annual_consumption) {
AnnualConsumption = annual_consumption;
}
float Building::Metadata::annual_generation() const
{
float Building::Metadata::annual_generation() const {
return AnnualGeneration;
}
void Building::Metadata::set_annual_generation(float annual_generation)
{
void Building::Metadata::set_annual_generation(float 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;
}
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);
}
std::vector<std::unique_ptr<float>>& Building::Metadata::generation_profile()
{
std::vector<std::unique_ptr<float> > &Building::Metadata::generation_profile() {
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);
}
std::string Building::Metadata::consumption_profile_name() const
{
std::string Building::Metadata::consumption_profile_name() const {
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;
}
std::string Building::Metadata::generation_profile_name() const
{
std::string Building::Metadata::generation_profile_name() const {
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;
}
short Building::Metadata::connection_power() const
{
short Building::Metadata::connection_power() const {
return ConnectionPower;
}
void Building::Metadata::set_connection_power(short connection_power)
{
void Building::Metadata::set_connection_power(short connection_power) {
ConnectionPower = connection_power;
}
short Building::Metadata::grid_power() const
{
short Building::Metadata::grid_power() const {
return GridPower;
}
void Building::Metadata::set_grid_power(short grid_power)
{
void Building::Metadata::set_grid_power(short grid_power) {
GridPower = grid_power;
}
std::unique_ptr<Building::Cost>& Building::Base::cost()
{
std::unique_ptr<Building::Cost> &Building::Base::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);
}
std::unique_ptr<Building::Simulation_Values>& Building::Base::values()
{
std::unique_ptr<Building::Simulation_Values> &Building::Base::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);
}
std::unique_ptr<Building::Metadata>& Building::Base::metadata()
{
std::unique_ptr<Building::Metadata> &Building::Base::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);
}

95
src/model/Building.h
View File

@ -11,48 +11,54 @@
#include "Model.h"
namespace Building
{
class Cost
{
namespace Building {
class Cost {
private:
float SpecialRateConsumption;
float SpecialRateGeneration;
public:
float special_rate_consumption() const;
void set_special_rate_consumption(float special_rate_consumption);
float special_rate_generation() const;
void set_special_rate_generation(float special_rate_generation);
};
class Simulation_Values
{
class Simulation_Values {
private:
std::vector<std::unique_ptr<float>> CommunityCoverage;
std::vector<std::unique_ptr<float>> OwnUsage;
std::vector<std::unique_ptr<float>> Needed_con;
std::vector<std::unique_ptr<float>> NeededGen;
std::vector<std::unique_ptr<float> > CommunityCoverage;
std::vector<std::unique_ptr<float> > OwnUsage;
std::vector<std::unique_ptr<float> > Needed_con;
std::vector<std::unique_ptr<float> > NeededGen;
public:
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();
void set_own_usage(std::vector<std::unique_ptr<float>> own_usage);
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();
void set_needed_gen(std::vector<std::unique_ptr<float>> needed_gen);
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();
void set_own_usage(std::vector<std::unique_ptr<float> > own_usage);
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();
void set_needed_gen(std::vector<std::unique_ptr<float> > needed_gen);
};
class Metadata
{
class Metadata {
private:
std::string Name;
float AnnualConsumption;
float AnnualGeneration;
std::vector<std::unique_ptr<float>> ConsumptionProfile;
std::vector<std::unique_ptr<float>> GenerationProfile;
std::vector<std::unique_ptr<float> > ConsumptionProfile;
std::vector<std::unique_ptr<float> > GenerationProfile;
std::string ConsumptionProfileName;
std::string GenerationProfileName;
short ConnectionPower;
@ -60,38 +66,59 @@ namespace Building
public:
std::string name() const;
void set_name(const std::string& name);
void set_name(const std::string &name);
float annual_consumption() const;
void set_annual_consumption(float annual_consumption);
float annual_generation() const;
void set_annual_generation(float annual_generation);
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();
void set_generation_profile(std::vector<std::unique_ptr<float>> generation_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();
void set_generation_profile(std::vector<std::unique_ptr<float> > generation_profile);
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;
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;
void set_connection_power(short connection_power);
short grid_power() const;
void set_grid_power(short grid_power);
};
class Base : public Model<Base>
{
class Base : public Model<Base> {
private:
std::unique_ptr<Cost> Cost;
std::unique_ptr<Simulation_Values> Values;
std::unique_ptr<Metadata> Metadata;
public:
std::unique_ptr<Building::Cost>& 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);
std::unique_ptr<Building::Metadata>& metadata();
std::unique_ptr<Building::Metadata> &metadata();
void set_metadata(std::unique_ptr<Building::Metadata> metadata);
};
}

35
src/model/Community.cpp
View File

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

19
src/model/Community.h
View File

@ -11,28 +11,27 @@
#include "Energy_Tariff.h"
class Community : public Model<Community>
{
class Community : public Model<Community> {
public:
std::string name() const;
void set_name(const std::string& name);
void set_name(const std::string &name);
std::vector<std::unique_ptr<Building::Base>>& buildings();
std::vector<std::unique_ptr<Building::Base> > &buildings();
void set_buildings(std::vector<std::unique_ptr<Building::Base>> buildings);
void set_buildings(std::vector<std::unique_ptr<Building::Base> > buildings);
Energy_Tariff energy_tariff() const;
void set_energy_tariff(const Energy_Tariff& energy_tariff);
void set_energy_tariff(const Energy_Tariff &energy_tariff);
static std::function<std::function<void(const std::function<void(Building::Base&)>&)>
(const std::function<void(Community&)>&)>
iterateBuildings(std::vector<std::unique_ptr<Community>>& Communities);
static std::function<std::function<void(const std::function<void(Building::Base &)> &)>
(const std::function<void(Community &)> &)>
iterateBuildings(std::vector<std::unique_ptr<Community> > &Communities);
private:
std::string Name;
std::vector<std::unique_ptr<Building::Base>> Buildings;
std::vector<std::unique_ptr<Building::Base> > Buildings;
Energy_Tariff energy_Tariff;
};

3
src/model/Energy_Tariff.h
View File

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

34
src/services/Surplus.cpp
View File

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

16
src/services/Surplus.h
View File

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

47
tests/model/Factory.h
View File

@ -9,33 +9,28 @@
#include "../../src/model/Community.h"
#include "../../src/model/Energy_Tariff.h"
namespace Building
{
namespace Building {
class Cost;
}
class Factory
{
class Factory {
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>();
cost->set_special_rate_consumption(0.15f);
cost->set_special_rate_generation(0.10f);
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 communityCoverage = std::vector<std::unique_ptr<float>>();
auto ownUsage = std::vector<std::unique_ptr<float>>();
auto neededCon = std::vector<std::unique_ptr<float>>();
auto neededGen = std::vector<std::unique_ptr<float>>();
auto communityCoverage = std::vector<std::unique_ptr<float> >();
auto ownUsage = std::vector<std::unique_ptr<float> >();
auto neededCon = 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
communityCoverage.push_back(std::make_unique<float>(i * 10.0f));
ownUsage.push_back(std::make_unique<float>(i * 5.0f));
@ -51,8 +46,7 @@ public:
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>();
metadata->set_name("Test Building");
metadata->set_annual_consumption(12000.0f);
@ -62,11 +56,10 @@ public:
metadata->set_connection_power(100);
metadata->set_grid_power(50);
auto consumptionProfile = std::vector<std::unique_ptr<float>>();
auto generationProfile = std::vector<std::unique_ptr<float>>();
auto consumptionProfile = 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
consumptionProfile.push_back(std::make_unique<float>(i * 100.0f));
generationProfile.push_back(std::make_unique<float>(i * 50.0f));
@ -78,8 +71,7 @@ public:
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>();
building->set_cost(create_test_cost());
@ -89,19 +81,16 @@ public:
return building;
}
Energy_Tariff static create_test_energy_tariff()
{
Energy_Tariff static create_test_energy_tariff() {
return {};
}
std::unique_ptr<Community> static create_test_community()
{
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 < 3; i++)
{
std::vector<std::unique_ptr<Building::Base> > buildings;
for (int i = 0; i < 3; i++) {
buildings.push_back(create_test_building());
}

5
tests/services/test_Surplus.cpp
View File

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