Skip to content

Commit 2f5a269

Browse files
AlfVIIAlfVII
committed
Fixed bug in temperature with only current, and clang-format applied
1 parent b5970a0 commit 2f5a269

38 files changed

+10555
-7576
lines changed

‎.clang-format

+12-1
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,18 @@ AlwaysBreakAfterReturnType: None
1818
AlwaysBreakTemplateDeclarations: MultiLine
1919
BinPackParameters: 'false'
2020
BreakBeforeBinaryOperators: None
21-
BreakBeforeBraces: Stroustrup
21+
BreakBeforeBraces: Custom
22+
BraceWrapping:
23+
AfterClass: false
24+
AfterControlStatement: false
25+
AfterEnum: false
26+
AfterFunction: false
27+
AfterNamespace: false
28+
AfterStruct: false
29+
AfterUnion: false
30+
BeforeCatch: true
31+
BeforeElse: true
32+
IndentBraces: false
2233
BreakBeforeTernaryOperators: 'false'
2334
BreakConstructorInitializers: AfterColon
2435
BreakInheritanceList: AfterColon

‎src/Constants.h

+17-17
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,27 @@
11
#if !defined(CONSTANTS_H)
2-
#define CONSTANTS_H 1
3-
#pragma once
2+
# define CONSTANTS_H 1
3+
# pragma once
44

5-
#include <numbers>
5+
# include <numbers>
66

77
namespace OpenMagnetics {
8-
struct Constants {
9-
Constants() {};
10-
const double residualGap = 5e-6;
11-
const double minimumNonResidualGap = 0.1e-3;
12-
const double vacuum_permeability = 1.25663706212e-6;
8+
struct Constants {
9+
Constants() {};
10+
const double residualGap = 5e-6;
11+
const double minimumNonResidualGap = 0.1e-3;
12+
const double vacuum_permeability = 1.25663706212e-6;
1313

14-
const double magnetic_flux_density_saturation = 0.352; // HARDCODED TODO: replace when materials are implemented
14+
const double magnetic_flux_density_saturation = 0.352; // HARDCODED TODO: replace when materials are implemented
1515

16-
const double spacer_protuding_percentage = 0.2;
16+
const double spacer_protuding_percentage = 0.2;
1717

18-
const double number_points_samples_waveforms = 128;
19-
const double minimum_distributed_fringing_factor = 1.05;
20-
const double maximum_distributed_fringing_factor = 1.3;
21-
const double initial_gap_length_for_searching = 0.001;
18+
const double number_points_samples_waveforms = 128;
19+
const double minimum_distributed_fringing_factor = 1.05;
20+
const double maximum_distributed_fringing_factor = 1.3;
21+
const double initial_gap_length_for_searching = 0.001;
2222

23-
const double roshen_magnetic_field_strength_step = 0.1;
24-
};
25-
}
23+
const double roshen_magnetic_field_strength_step = 0.1;
24+
};
25+
} // namespace OpenMagnetics
2626

2727
#endif

‎src/CoreLosses.cpp

+661-576
Large diffs are not rendered by default.

‎src/CoreLosses.h

+234-196
Large diffs are not rendered by default.

‎src/CoreTemperature.cpp

+100-92
Original file line numberDiff line numberDiff line change
@@ -1,117 +1,125 @@
1-
#include <fstream>
2-
#include <numbers>
3-
#include <iostream>
1+
#include "CoreTemperature.h"
2+
3+
#include "../tests/TestingUtils.h"
4+
#include "Constants.h"
5+
#include "InputsWrapper.h"
6+
47
#include <cmath>
58
#include <complex>
69
#include <cstdlib>
710
#include <ctime>
8-
#include <iomanip>
9-
#include <vector>
1011
#include <filesystem>
11-
#include <streambuf>
12+
#include <fstream>
13+
#include <iomanip>
14+
#include <iostream>
1215
#include <magic_enum.hpp>
13-
#include "InputsWrapper.h"
14-
#include "CoreTemperature.h"
15-
#include "Constants.h"
16-
#include "../tests/TestingUtils.h"
16+
#include <numbers>
17+
#include <streambuf>
18+
#include <vector>
1719

1820
namespace OpenMagnetics {
19-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel::factory(CoreTemperatureModels modelName)
20-
{
21-
if (modelName == CoreTemperatureModels::KAZIMIERCZUK) {
22-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureKazimierczukModel);
23-
return CoreTemperatureModel;
24-
}
25-
else if (modelName == CoreTemperatureModels::MANIKTALA) {
26-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureManiktalaModel);
27-
return CoreTemperatureModel;
28-
}
29-
else if (modelName == CoreTemperatureModels::TDK) {
30-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureTdkModel);
31-
return CoreTemperatureModel;
32-
}
33-
else if (modelName == CoreTemperatureModels::DIXON) {
34-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureDixonModel);
35-
return CoreTemperatureModel;
36-
}
37-
else if (modelName == CoreTemperatureModels::AMIDON) {
38-
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureAmidonModel);
39-
return CoreTemperatureModel;
40-
}
41-
42-
else throw std::runtime_error("Unknown Core losses mode, available options are: {KAZIMIERCZUK, MANIKTALA, TDK, DIXON, AMIDON}");
21+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel::factory(CoreTemperatureModels modelName) {
22+
if (modelName == CoreTemperatureModels::KAZIMIERCZUK) {
23+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureKazimierczukModel);
24+
return CoreTemperatureModel;
4325
}
44-
45-
std::map<std::string, double> CoreTemperatureManiktalaModel::get_core_temperature(CoreWrapper core, double coreLosses, double ambientTemperature) {
46-
47-
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
48-
double thermalResistance = 53 * pow(effectiveVolume * 1000000, -0.54);
49-
double temperatureRise = coreLosses * thermalResistance;
50-
double maximumTemperature = ambientTemperature + temperatureRise;
51-
52-
std::map<std::string, double> result;
53-
result["maximumTemperature"] = maximumTemperature;
54-
55-
return result;
26+
else if (modelName == CoreTemperatureModels::MANIKTALA) {
27+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureManiktalaModel);
28+
return CoreTemperatureModel;
5629
}
57-
58-
std::map<std::string, double> CoreTemperatureKazimierczukModel::get_core_temperature(CoreWrapper core, double coreLosses, double ambientTemperature) {
59-
60-
double width = core.get_processed_description().value().get_width();
61-
double height = core.get_processed_description().value().get_height();
62-
double depth = core.get_processed_description().value().get_depth();
63-
double coreSurface = 2 * depth * height + 2 * height * width + 2 * width * depth;
64-
double temperatureRise = pow(0.1 * coreLosses / coreSurface, 0.826);
65-
double maximumTemperature = ambientTemperature + temperatureRise;
66-
67-
std::map<std::string, double> result;
68-
result["maximumTemperature"] = maximumTemperature;
69-
70-
return result;
30+
else if (modelName == CoreTemperatureModels::TDK) {
31+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureTdkModel);
32+
return CoreTemperatureModel;
33+
}
34+
else if (modelName == CoreTemperatureModels::DIXON) {
35+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureDixonModel);
36+
return CoreTemperatureModel;
37+
}
38+
else if (modelName == CoreTemperatureModels::AMIDON) {
39+
std::shared_ptr<CoreTemperatureModel> CoreTemperatureModel(new CoreTemperatureAmidonModel);
40+
return CoreTemperatureModel;
7141
}
7242

73-
std::map<std::string, double> CoreTemperatureTdkModel::get_core_temperature(CoreWrapper core, double coreLosses, double ambientTemperature) {
43+
else
44+
throw std::runtime_error(
45+
"Unknown Core losses mode, available options are: {KAZIMIERCZUK, MANIKTALA, TDK, DIXON, AMIDON}");
46+
}
7447

75-
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
76-
double thermalResistance = 1 / sqrt(effectiveVolume * 1000000);
77-
double temperatureRise = coreLosses * thermalResistance;
78-
double maximumTemperature = ambientTemperature + temperatureRise;
48+
std::map<std::string, double> CoreTemperatureManiktalaModel::get_core_temperature(CoreWrapper core,
49+
double coreLosses,
50+
double ambientTemperature) {
51+
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
52+
double thermalResistance = 53 * pow(effectiveVolume * 1000000, -0.54);
53+
double temperatureRise = coreLosses * thermalResistance;
54+
double maximumTemperature = ambientTemperature + temperatureRise;
7955

80-
std::map<std::string, double> result;
81-
result["maximumTemperature"] = maximumTemperature;
56+
std::map<std::string, double> result;
57+
result["maximumTemperature"] = maximumTemperature;
8258

83-
return result;
84-
}
59+
return result;
60+
}
8561

86-
std::map<std::string, double> CoreTemperatureDixonModel::get_core_temperature(CoreWrapper core, double coreLosses, double ambientTemperature) {
62+
std::map<std::string, double> CoreTemperatureKazimierczukModel::get_core_temperature(CoreWrapper core,
63+
double coreLosses,
64+
double ambientTemperature) {
65+
double width = core.get_processed_description().value().get_width();
66+
double height = core.get_processed_description().value().get_height();
67+
double depth = core.get_processed_description().value().get_depth();
68+
double coreSurface = 2 * depth * height + 2 * height * width + 2 * width * depth;
69+
double temperatureRise = pow(0.1 * coreLosses / coreSurface, 0.826);
70+
double maximumTemperature = ambientTemperature + temperatureRise;
8771

88-
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
89-
double centralColumnArea = core.get_processed_description().value().get_columns()[0].get_area();
90-
double windingWindowArea = core.get_processed_description().value().get_winding_windows()[0].get_area().value();
91-
double areaProduct = centralColumnArea * windingWindowArea * 100000000;
92-
double thermalResistance = 23 * pow(areaProduct, -0.37);
93-
double temperatureRise = coreLosses * thermalResistance;
94-
double maximumTemperature = ambientTemperature + temperatureRise;
72+
std::map<std::string, double> result;
73+
result["maximumTemperature"] = maximumTemperature;
9574

96-
std::map<std::string, double> result;
97-
result["maximumTemperature"] = maximumTemperature;
75+
return result;
76+
}
9877

99-
return result;
100-
}
78+
std::map<std::string, double> CoreTemperatureTdkModel::get_core_temperature(CoreWrapper core,
79+
double coreLosses,
80+
double ambientTemperature) {
81+
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
82+
double thermalResistance = 1 / sqrt(effectiveVolume * 1000000);
83+
double temperatureRise = coreLosses * thermalResistance;
84+
double maximumTemperature = ambientTemperature + temperatureRise;
10185

102-
std::map<std::string, double> CoreTemperatureAmidonModel::get_core_temperature(CoreWrapper core, double coreLosses, double ambientTemperature) {
86+
std::map<std::string, double> result;
87+
result["maximumTemperature"] = maximumTemperature;
10388

104-
double width = core.get_processed_description().value().get_width();
105-
double height = core.get_processed_description().value().get_height();
106-
double depth = core.get_processed_description().value().get_depth();
107-
double coreSurface = 2 * depth * height + 2 * height * width + 2 * width * depth;
108-
double temperatureRise = pow(coreLosses * 1000 / (coreSurface * 10000), 0.833);
109-
double maximumTemperature = ambientTemperature + temperatureRise;
89+
return result;
90+
}
11091

111-
std::map<std::string, double> result;
112-
result["maximumTemperature"] = maximumTemperature;
92+
std::map<std::string, double> CoreTemperatureDixonModel::get_core_temperature(CoreWrapper core,
93+
double coreLosses,
94+
double ambientTemperature) {
95+
double effectiveVolume = core.get_processed_description().value().get_effective_parameters().get_effective_volume();
96+
double centralColumnArea = core.get_processed_description().value().get_columns()[0].get_area();
97+
double windingWindowArea = core.get_processed_description().value().get_winding_windows()[0].get_area().value();
98+
double areaProduct = centralColumnArea * windingWindowArea * 100000000;
99+
double thermalResistance = 23 * pow(areaProduct, -0.37);
100+
double temperatureRise = coreLosses * thermalResistance;
101+
double maximumTemperature = ambientTemperature + temperatureRise;
102+
103+
std::map<std::string, double> result;
104+
result["maximumTemperature"] = maximumTemperature;
105+
106+
return result;
107+
}
113108

114-
return result;
115-
}
109+
std::map<std::string, double> CoreTemperatureAmidonModel::get_core_temperature(CoreWrapper core,
110+
double coreLosses,
111+
double ambientTemperature) {
112+
double width = core.get_processed_description().value().get_width();
113+
double height = core.get_processed_description().value().get_height();
114+
double depth = core.get_processed_description().value().get_depth();
115+
double coreSurface = 2 * depth * height + 2 * height * width + 2 * width * depth;
116+
double temperatureRise = pow(coreLosses * 1000 / (coreSurface * 10000), 0.833);
117+
double maximumTemperature = ambientTemperature + temperatureRise;
116118

119+
std::map<std::string, double> result;
120+
result["maximumTemperature"] = maximumTemperature;
121+
122+
return result;
117123
}
124+
125+
} // namespace OpenMagnetics

0 commit comments

Comments
 (0)