manolas
/
ReducedModelOptimization
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Normalizing based on a globally defined epsilon(0.0003)

This commit is contained in:
Iason 2021-02-24 22:10:42 +02:00
parent 94eeb0a9df
commit 55731d3131
3 changed files with 82 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main.cpp
View File

@ -52,7 +52,7 @@ int main(int argc, char *argv[]) {
settings_optimization.numberOfFunctionCalls = settings_optimization.numberOfFunctionCalls =
input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100; input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
settings_optimization.shouldNormalizeObjectiveValue = true; settings_optimization.shouldNormalizeObjectiveValue = true;
settings_optimization.solutionAccuracy = 0.1; settings_optimization.solutionAccuracy = 0.01;
// Optimize pair // Optimize pair
const std::string pairName = const std::string pairName =

162
src/reducedmodeloptimizer.cpp
View File

@ -9,7 +9,7 @@
struct GlobalOptimizationVariables { struct GlobalOptimizationVariables {
std::vector<Eigen::MatrixX3d> g_optimalReducedModelDisplacements; std::vector<Eigen::MatrixX3d> g_optimalReducedModelDisplacements;
std::vector<std::vector<Vector6d>> fullPatternDisplacements; std::vector<std::vector<Vector6d>> fullPatternDisplacements;
std::vector<double> reducedPatternMaximumDisplacementNormSum; std::vector<double> fullPatternDisplacementNormSum;
std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs; std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs;
std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs; std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs;
std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
@ -47,13 +47,7 @@ double ReducedModelOptimizer::computeError(
computeRawError(reducedPatternDisplacements, fullPatternDisplacements, computeRawError(reducedPatternDisplacements, fullPatternDisplacements,
reducedToFullInterfaceViMap); reducedToFullInterfaceViMap);
if (global.optimizationSettings.shouldNormalizeObjectiveValue) { if (global.optimizationSettings.shouldNormalizeObjectiveValue) {
assert(rawError <= normalizationFactor); return rawError / std::max(normalizationFactor, 0.0003);
if (rawError > normalizationFactor) {
std::cout << "Normalized error is bigger than one." << std::endl;
}
return rawError /
normalizationFactor; // std::max(interfaceDisplacementsNormSum,
// 0.00003);
} }
return rawError; return rawError;
@ -199,36 +193,11 @@ double ReducedModelOptimizer::objective(long n, const double *x) {
std::cout << "Failed simulation" << std::endl; std::cout << "Failed simulation" << std::endl;
} }
} else { } else {
const double thisSimulationScenarioError = const double thisSimulationScenarioError = computeError(
computeError(reducedModelResults.displacements, reducedModelResults.displacements,
global.fullPatternDisplacements[simulationScenarioIndex], global.fullPatternDisplacements[simulationScenarioIndex],
global.reducedToFullInterfaceViMap, global.reducedToFullInterfaceViMap,
global.reducedPatternMaximumDisplacementNormSum global.fullPatternDisplacementNormSum[simulationScenarioIndex]);
[simulationScenarioIndex]);
if (thisSimulationScenarioError > 1) {
std::cout << "Simulation scenario "
<< simulationScenarioStrings[simulationScenarioIndex]
<< " results in an error bigger than one." << std::endl;
for (size_t parameterIndex = 0; parameterIndex < n; parameterIndex++) {
std::cout << "x[" + std::to_string(parameterIndex) + "]="
<< x[parameterIndex] << std::endl;
}
#ifdef POLYSCOPE_DEFINED
ReducedModelOptimizer::visualizeResults(
global.fullPatternSimulationJobs[simulationScenarioIndex],
global.reducedPatternSimulationJobs[simulationScenarioIndex],
global.reducedToFullInterfaceViMap, false);
ReducedModelOptimizer::visualizeResults(
global.fullPatternSimulationJobs[simulationScenarioIndex],
std::make_shared<SimulationJob>(
reducedPatternMaximumDisplacementSimulationJobs
[simulationScenarioIndex]),
global.reducedToFullInterfaceViMap, true);
polyscope::removeAllStructures();
#endif // POLYSCOPE_DEFINED
}
error += thisSimulationScenarioError; error += thisSimulationScenarioError;
} }
// std::ofstream out(filename, std::ios_base::app); // std::ofstream out(filename, std::ios_base::app);
@ -269,7 +238,7 @@ double ReducedModelOptimizer::objective(long n, const double *x) {
//} //}
// compute error and return it // compute error and return it
global.gObjectiveValueHistory.push_back(error); // global.gObjectiveValueHistory.push_back(error);
// auto xPlot = matplot::linspace(0, gObjectiveValueHistory.size(), // auto xPlot = matplot::linspace(0, gObjectiveValueHistory.size(),
// gObjectiveValueHistory.size()); // gObjectiveValueHistory.size());
// std::vector<double> colors(gObjectiveValueHistory.size(), 2); // std::vector<double> colors(gObjectiveValueHistory.size(), 2);
@ -577,7 +546,7 @@ void ReducedModelOptimizer::computeReducedModelSimulationJob(
} }
#if POLYSCOPE_DEFINED #if POLYSCOPE_DEFINED
void ReducedModelOptimizer::visualizeResults( void ReducedModelOptimizer::registerResultsForDrawing(
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob, const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob,
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob, const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob,
const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
@ -609,19 +578,6 @@ void ReducedModelOptimizer::visualizeResults(
global.reducedPatternMaximumDisplacementNormSum[simulationScenarioIndex]*/); global.reducedPatternMaximumDisplacementNormSum[simulationScenarioIndex]*/);
std::cout << "Error is " << error << std::endl; std::cout << "Error is " << error << std::endl;
reducedModelResults.registerForDrawing(); reducedModelResults.registerForDrawing();
if (draw) {
polyscope::show();
const std::string screenshotFilename =
"/home/iason/Coding/Projects/Approximating shapes with flat "
"patterns/RodModelOptimizationForPatterns/build/OptimizationResults/"
"Images/" +
pFullPatternSimulationMesh->getLabel() + "_" + "noScenarioName";
// simulationScenarioStrings[simulationScenarioIndex];
polyscope::screenshot(screenshotFilename, false);
fullModelResults.unregister();
reducedModelResults.unregister();
pFullPatternSimulationMesh->unregister();
}
} }
#endif // POLYSCOPE_DEFINED #endif // POLYSCOPE_DEFINED
@ -720,16 +676,37 @@ ReducedModelOptimizer::runOptimization(const Settings &settings) {
results.numberOfSimulationCrashes = global.numOfSimulationCrashes; results.numberOfSimulationCrashes = global.numOfSimulationCrashes;
results.x = global.minX; results.x = global.minX;
results.objectiveValue = global.minY; results.objectiveValue = global.minY;
if (settings.shouldNormalizeObjectiveValue) { // if (settings.shouldNormalizeObjectiveValue) {
global.optimizationSettings.shouldNormalizeObjectiveValue = false; // global.optimizationSettings.shouldNormalizeObjectiveValue = false;
if (global.optimizeInnerHexagonSize) { // if (global.optimizeInnerHexagonSize) {
results.objectiveValue = objective(4, results.x.data()); // results.objectiveValue = objective(4, results.x.data());
} else { // } else {
results.objectiveValue = // results.objectiveValue =
objective(results.x[0], results.x[1], results.x[2]); // objective(results.x[0], results.x[1], results.x[2]);
} // }
global.optimizationSettings.shouldNormalizeObjectiveValue = true; // global.optimizationSettings.shouldNormalizeObjectiveValue = true;
// }
// Compute obj value per simulation scenario
updateMesh(results.x.size(), results.x.data());
results.objectiveValuePerSimulationScenario.resize(
global.simulationScenarioIndices.size());
FormFinder::Settings simulationSettings;
FormFinder simulator;
for (int simulationScenarioIndex = 0;
simulationScenarioIndex <
SimulationScenario::NumberOfSimulationScenarios;
simulationScenarioIndex++) {
SimulationResults reducedModelResults = simulator.executeSimulation(
global.reducedPatternSimulationJobs[simulationScenarioIndex],
simulationSettings);
const double error = computeError(
reducedModelResults.displacements,
global.fullPatternDisplacements[simulationScenarioIndex],
global.reducedToFullInterfaceViMap,
global.fullPatternDisplacementNormSum[simulationScenarioIndex]);
results.objectiveValuePerSimulationScenario[simulationScenarioIndex] =
error;
} }
results.time = elapsed.count() / 1000.0; results.time = elapsed.count() / 1000.0;
const bool printDebugInfo = false; const bool printDebugInfo = false;
@ -1044,7 +1021,6 @@ ReducedModelOptimizer::Results ReducedModelOptimizer::optimize(
global.g_optimalReducedModelDisplacements.resize(6); global.g_optimalReducedModelDisplacements.resize(6);
global.reducedPatternSimulationJobs.resize(6); global.reducedPatternSimulationJobs.resize(6);
global.fullPatternDisplacements.resize(6); global.fullPatternDisplacements.resize(6);
global.reducedPatternMaximumDisplacementNormSum.resize(6);
global.g_firstRoundIterationIndex = 0; global.g_firstRoundIterationIndex = 0;
global.minY = std::numeric_limits<double>::max(); global.minY = std::numeric_limits<double>::max();
global.numOfSimulationCrashes = 0; global.numOfSimulationCrashes = 0;
@ -1052,7 +1028,7 @@ ReducedModelOptimizer::Results ReducedModelOptimizer::optimize(
global.optimizationSettings = optimizationSettings; global.optimizationSettings = optimizationSettings;
global.fullPatternSimulationJobs = global.fullPatternSimulationJobs =
createScenarios(m_pFullPatternSimulationMesh); createScenarios(m_pFullPatternSimulationMesh);
reducedPatternMaximumDisplacementSimulationJobs.resize(6); global.fullPatternDisplacementNormSum.resize(6);
// polyscope::removeAllStructures(); // polyscope::removeAllStructures();
FormFinder::Settings simulationSettings; FormFinder::Settings simulationSettings;
@ -1073,51 +1049,17 @@ ReducedModelOptimizer::Results ReducedModelOptimizer::optimize(
std::make_shared<SimulationJob>(reducedPatternSimulationJob); std::make_shared<SimulationJob>(reducedPatternSimulationJob);
if (optimizationSettings.shouldNormalizeObjectiveValue) { if (optimizationSettings.shouldNormalizeObjectiveValue) {
// Compute the quantities for normalizing the obj value double displacementNormSum = 0;
const double minB = optimizationSettings.xRanges[0].min; for (auto interfaceViPair : global.reducedToFullInterfaceViMap) {
const double maxRatio = optimizationSettings.xRanges[1].max; const int interfaceFullPatternVi = interfaceViPair.second;
const double minE = optimizationSettings.xRanges[2].min; const Eigen::Vector3d displacement(
const double minHS = 0.3; fullModelResults.displacements[interfaceFullPatternVi][0],
std::vector<double> mostFlexibleOptimizationParameters{minB, maxRatio, fullModelResults.displacements[interfaceFullPatternVi][1],
minE, minHS}; fullModelResults.displacements[interfaceFullPatternVi][2]);
if (global.optimizeInnerHexagonSize) { displacementNormSum += displacement.norm();
updateMesh(4, mostFlexibleOptimizationParameters.data());
} else {
updateMesh(3, mostFlexibleOptimizationParameters.data());
} }
reducedPatternMaximumDisplacementSimulationJobs[simulationScenarioIndex] = global.fullPatternDisplacementNormSum[simulationScenarioIndex] =
global.reducedPatternSimulationJobs[simulationScenarioIndex] displacementNormSum;
->getCopy();
reducedPatternMaximumDisplacementSimulationJobs[simulationScenarioIndex]
.pMesh->setLabel("reduced_maxDisplacement");
SimulationResults reducedModelResults = simulator.executeSimulation(
global.reducedPatternSimulationJobs[simulationScenarioIndex],
simulationSettings);
const double errorOfMaxDisplacedReduced = computeRawError(
reducedModelResults.displacements, fullModelResults.displacements,
global.reducedToFullInterfaceViMap);
const double errorOfNonDisplacedReduced = computeRawError(
std::vector<Vector6d>(reducedModelResults.displacements.size(),
Vector6d(0)),
fullModelResults.displacements, global.reducedToFullInterfaceViMap);
double displacementMultiplier = 2;
// if (global.optimizeInnerHexagonSize) {
// displacementMultiplier = 2;
// } else {
// displacementMultiplier = 2;
// }
global.reducedPatternMaximumDisplacementNormSum[simulationScenarioIndex] =
displacementMultiplier *
std::max(errorOfMaxDisplacedReduced, errorOfNonDisplacedReduced);
// if (errorOfMaxDisplacedReduced > errorOfNonDisplacedReduced) {
// std::cout << "Max disp results in a bigger error for scenario "
// << simulationScenarioStrings[simulationScenarioIndex]
// << std::endl;
// } else {
// std::cout << "Zero disp results in a bigger error for scenario "
// << simulationScenarioStrings[simulationScenarioIndex]
// << std::endl;
// }
} }
} }
Results optResults = runOptimization(optimizationSettings); Results optResults = runOptimization(optimizationSettings);
@ -1132,9 +1074,7 @@ ReducedModelOptimizer::Results ReducedModelOptimizer::optimize(
// visualizeResults(simulationJobs, global.simulationScenarioIndices); // visualizeResults(simulationJobs, global.simulationScenarioIndices);
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
// visualizeResults( optResults.draw();
// global.fullPatternSimulationJobs, global.reducedPatternSimulationJobs,
// global.simulationScenarioIndices, global.reducedToFullInterfaceViMap);
#endif // POLYSCOPE_DEFINED #endif // POLYSCOPE_DEFINED
return optResults; return optResults;
} }

49
src/reducedmodeloptimizer.hpp
View File

@ -95,6 +95,7 @@ public:
int numberOfSimulationCrashes{0}; int numberOfSimulationCrashes{0};
std::vector<double> x; std::vector<double> x;
double objectiveValue; double objectiveValue;
std::vector<double> objectiveValuePerSimulationScenario;
std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs; std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs;
std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs; std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs;
@ -189,21 +190,22 @@ public:
reducedModelResults.registerForDrawing(); reducedModelResults.registerForDrawing();
polyscope::show(); polyscope::show();
// Save a screensh // Save a screensh
// const std::string screenshotFilename = const std::string screenshotFilename =
// "/home/iason/Coding/Projects/Approximating shapes with flat " "/home/iason/Coding/Projects/Approximating shapes with flat "
// "patterns/RodModelOptimizationForPatterns/build/OptimizationResults/" "patterns/RodModelOptimizationForPatterns/Results/Images/" +
// + m_pFullPatternSimulationMesh->getLabel() + "_" + pFullPatternSimulationJob->pMesh->getLabel() + "_" +
// simulationScenarioStrings[simulationScenarioIndex]; simulationScenarioStrings[simulationJobIndex];
// polyscope::screenshot(screenshotFilename, false); polyscope::screenshot(screenshotFilename, false);
fullModelResults.unregister(); fullModelResults.unregister();
reducedModelResults.unregister(); reducedModelResults.unregister();
// double error = computeError( // double error = computeError(
// reducedModelResults, // reducedModelResults.displacements,fullModelResults.displacements,
// global.g_optimalReducedModelDisplacements[simulationScenarioIndex]); // );
// std::cout << "Error of simulation scenario " // std::cout << "Error of simulation scenario "
// << simulationScenarioStrings[simulationScenarioIndex] << // <<
// " is " // simulationScenarioStrings[simulationScenarioIndex]
// << error << std::endl; // << " is "
// << error << std::endl;
} }
} }
#endif // POLYSCOPE_DEFINED #endif // POLYSCOPE_DEFINED
@ -239,7 +241,13 @@ public:
void void
writeHeaderTo(const ReducedModelOptimizer::Settings &settings_optimization, writeHeaderTo(const ReducedModelOptimizer::Settings &settings_optimization,
csvFile &os) { csvFile &os) {
os << "Obj value"; os << "Total Obj value";
for (int simulationScenarioIndex = 0;
simulationScenarioIndex <
SimulationScenario::NumberOfSimulationScenarios;
simulationScenarioIndex++) {
os << "Obj value " + simulationScenarioStrings[simulationScenarioIndex];
}
for (const ReducedModelOptimizer::xRange &range : for (const ReducedModelOptimizer::xRange &range :
settings_optimization.xRanges) { settings_optimization.xRanges) {
os << range.label; os << range.label;
@ -252,6 +260,9 @@ public:
writeResultsTo(const ReducedModelOptimizer::Settings &settings_optimization, writeResultsTo(const ReducedModelOptimizer::Settings &settings_optimization,
csvFile &os) const { csvFile &os) const {
os << objectiveValue; os << objectiveValue;
for (double scenarioObjValue : objectiveValuePerSimulationScenario) {
os << scenarioObjValue;
}
for (const double &optimalX : x) { for (const double &optimalX : x) {
os << optimalX; os << optimalX;
} }
@ -319,7 +330,7 @@ public:
&fullToReducedInterfaceViMap, &fullToReducedInterfaceViMap,
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex> std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
&fullPatternOppositeInterfaceViMap); &fullPatternOppositeInterfaceViMap);
static void visualizeResults( static void registerResultsForDrawing(
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob, const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob,
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob, const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob,
const std::unordered_map<ReducedPatternVertexIndex, const std::unordered_map<ReducedPatternVertexIndex,
@ -343,10 +354,10 @@ public:
const double &normalizationFactor); const double &normalizationFactor);
private: private:
void void registerResultsForDrawing(
visualizeResults(const std::vector<std::shared_ptr<SimulationJob>> const std::vector<std::shared_ptr<SimulationJob>>
&fullPatternSimulationJobs, &fullPatternSimulationJobs,
const std::vector<SimulationScenario> &simulationScenarios); const std::vector<SimulationScenario> &simulationScenarios);
static void computeDesiredReducedModelDisplacements( static void computeDesiredReducedModelDisplacements(
const SimulationResults &fullModelResults, const SimulationResults &fullModelResults,
const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap, const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,