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);
} }

95
src/model/Building.h
View File

@ -11,48 +11,54 @@
#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;
std::vector<std::unique_ptr<float>> Needed_con; std::vector<std::unique_ptr<float> > Needed_con;
std::vector<std::unique_ptr<float>> NeededGen; std::vector<std::unique_ptr<float> > NeededGen;
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);
std::vector<std::unique_ptr<float>>& own_usage(); void set_community_coverage(std::vector<std::unique_ptr<float> > community_coverage);
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> > &own_usage();
void set_needed_con(std::vector<std::unique_ptr<float>> needed_con);
std::vector<std::unique_ptr<float>>& needed_gen(); void set_own_usage(std::vector<std::unique_ptr<float> > own_usage);
void set_needed_gen(std::vector<std::unique_ptr<float>> needed_gen);
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: private:
std::string Name; std::string Name;
float AnnualConsumption; float AnnualConsumption;
float AnnualGeneration; float AnnualGeneration;
std::vector<std::unique_ptr<float>> ConsumptionProfile; std::vector<std::unique_ptr<float> > ConsumptionProfile;
std::vector<std::unique_ptr<float>> GenerationProfile; std::vector<std::unique_ptr<float> > GenerationProfile;
std::string ConsumptionProfileName; std::string ConsumptionProfileName;
std::string GenerationProfileName; std::string GenerationProfileName;
short ConnectionPower; short ConnectionPower;
@ -60,38 +66,59 @@ 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();
void set_consumption_profile(std::vector<std::unique_ptr<float>> 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); 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; 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;
std::unique_ptr<Metadata> Metadata; std::unique_ptr<Metadata> Metadata;
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);
}; };
} }

35
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);
} }
}); });

19
src/model/Community.h
View File

@ -11,28 +11,27 @@
#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;
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; 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&)>&)> static std::function<std::function<void(const std::function<void(Building::Base &)> &)>
(const std::function<void(Community&)>&)> (const std::function<void(Community &)> &)>
iterateBuildings(std::vector<std::unique_ptr<Community>>& Communities); iterateBuildings(std::vector<std::unique_ptr<Community> > &Communities);
private: private:
std::string Name; std::string Name;
std::vector<std::unique_ptr<Building::Base>> Buildings; std::vector<std::unique_ptr<Building::Base> > Buildings;
Energy_Tariff energy_Tariff; Energy_Tariff energy_Tariff;
}; };

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 {
{
}; };

34
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,15 +23,14 @@ 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; std::vector<std::unique_ptr<float> > ownUsage;
std::vector<std::unique_ptr<float>> ownUsage;
const auto& consumption = building.metadata()->consumption_profile(); const auto &consumption = building.metadata()->consumption_profile();
const auto& generation = building.metadata()->generation_profile(); const auto &generation = building.metadata()->generation_profile();
ownCoverage.reserve(consumption.size()); ownCoverage.reserve(consumption.size());
neededConsumption.reserve(consumption.size()); neededConsumption.reserve(consumption.size());
@ -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));

16
src/services/Surplus.h
View File

@ -12,25 +12,23 @@
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;
std::vector<float> generationAvailable; std::vector<float> generationAvailable;
std::vector<bool> isGenBigger; std::vector<bool> isGenBigger;
public: 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();
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/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> >();
auto ownUsage = std::vector<std::unique_ptr<float>>(); auto ownUsage = std::vector<std::unique_ptr<float> >();
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);
@ -62,11 +56,10 @@ public:
metadata->set_connection_power(100); metadata->set_connection_power(100);
metadata->set_grid_power(50); metadata->set_grid_power(50);
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());
} }

5
tests/services/test_Surplus.cpp
View File

@ -6,9 +6,8 @@
#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);
surplus.CalculateSurplus(); surplus.CalculateSurplus();