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

CG first Submission state

This commit is contained in:
iasonmanolas 2021-10-14 14:58:34 +03:00
parent f949c2d793
commit b58ae0e13b
3 changed files with 129 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main.cpp
View File

@ -53,6 +53,7 @@ int main(int argc, char *argv[]) {
input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100; input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
settings_optimization.normalizationStrategy settings_optimization.normalizationStrategy
= ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon; = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
settings_optimization.normalizationParameter = 0.0003; settings_optimization.normalizationParameter = 0.0003;
settings_optimization.solverAccuracy = 0.001; settings_optimization.solverAccuracy = 0.001;
settings_optimization.objectiveWeights.translational = std::atof(argv[4]); settings_optimization.objectiveWeights.translational = std::atof(argv[4]);
@ -117,6 +118,7 @@ int main(int argc, char *argv[]) {
if (optimizationResults.wasSuccessful) { if (optimizationResults.wasSuccessful) {
resultsOutputDir = convergedJobsDirPath.string(); resultsOutputDir = convergedJobsDirPath.string();
csvFile csv_results({}, false); csvFile csv_results({}, false);
// csvFile csv_results(std::filesystem::path(resultsOutputDir).append("optimizationDistances.csv"), false);
csv_results << "Name"; csv_results << "Name";
optimizationResults.writeHeaderTo(csv_results); optimizationResults.writeHeaderTo(csv_results);
settings_optimization.writeHeaderTo(csv_results); settings_optimization.writeHeaderTo(csv_results);
@ -131,10 +133,10 @@ int main(int argc, char *argv[]) {
optimizationResults.save(resultsOutputDir, true); optimizationResults.save(resultsOutputDir, true);
} }
//#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
// optimizationResults.saveMeshFiles(); // optimizationResults.saveMeshFiles();
// optimizationResults.draw(); optimizationResults.draw();
//#endif #endif
return 0; return 0;
} }

205
src/reducedmodeloptimizer.cpp
View File

@ -39,6 +39,7 @@ struct GlobalOptimizationVariables {
FullPatternVertexIndex interfaceViForComputingScenarioError; FullPatternVertexIndex interfaceViForComputingScenarioError;
double desiredMaxDisplacementValue; double desiredMaxDisplacementValue;
double desiredMaxRotationAngle; double desiredMaxRotationAngle;
std::string currentScenarioName;
} global; } global;
double ReducedModelOptimizer::computeDisplacementError( double ReducedModelOptimizer::computeDisplacementError(
@ -190,15 +191,17 @@ double ReducedModelOptimizer::objective(long n, const double *x) {
global.translationalDisplacementNormalizationValues[simulationScenarioIndex], global.translationalDisplacementNormalizationValues[simulationScenarioIndex],
global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]); global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]);
} }
//#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
// std::cout << "sim error:" << simulationScenarioError << std::endl; // std::cout << reducedJob->getLabel() << " sim error:" << simulationScenarioError
// global.reducedPatternSimulationJobs[simulationScenarioIndex]->pMesh->registerForDrawing( // << std::endl;
// ReducedModelOptimization::Colors::reducedInitial); // reducedJob->pMesh->registerForDrawing(Colors::reducedInitial);
// reducedModelResults.registerForDrawing( // reducedModelResults.registerForDrawing(Colors::reducedDeformed);
// ReducedModelOptimization::Colors::reducedDeformed); // global.fullPatternResults[simulationScenarioIndex].registerForDrawing(
// polyscope::show(); // Colors::fullDeformed);
// reducedModelResults.unregister(); // polyscope::show();
//#endif // reducedModelResults.unregister();
// global.fullPatternResults[simulationScenarioIndex].unregister();
#endif
// if (global.optimizationSettings.normalizationStrategy != // if (global.optimizationSettings.normalizationStrategy !=
// NormalizationStrategy::Epsilon && // NormalizationStrategy::Epsilon &&
// simulationScenarioError > 1) { // simulationScenarioError > 1) {
@ -214,20 +217,20 @@ double ReducedModelOptimizer::objective(long n, const double *x) {
// } // }
// } // }
//#ifdef POLYSCOPE_DEFINED // #ifdef POLYSCOPE_DEFINED
// ReducedModelOptimizer::visualizeResults( // ReducedModelOptimizer::visualizeResults(
// global.fullPatternSimulationJobs[simulationScenarioIndex], // global.fullPatternSimulationJobs[simulationScenarioIndex],
// global.reducedPatternSimulationJobs[simulationScenarioIndex], // global.reducedPatternSimulationJobs[simulationScenarioIndex],
// global.reducedToFullInterfaceViMap, false); // global.reducedToFullInterfaceViMap, false);
// ReducedModelOptimizer::visualizeResults( // ReducedModelOptimizer::visualizeResults(
// global.fullPatternSimulationJobs[simulationScenarioIndex], // global.fullPatternSimulationJobs[simulationScenarioIndex],
// std::make_shared<SimulationJob>( // std::make_shared<SimulationJob>(
// reducedPatternMaximumDisplacementSimulationJobs // reducedPatternMaximumDisplacementSimulationJobs
// [simulationScenarioIndex]), // [simulationScenarioIndex]),
// global.reducedToFullInterfaceViMap, true); // global.reducedToFullInterfaceViMap, true);
// polyscope::removeAllStructures(); // polyscope::removeAllStructures();
//#endif // POLYSCOPE_DEFINED // #endif // POLYSCOPE_DEFINED
totalError += simulationScenarioError; totalError += simulationScenarioError;
} }
} }
@ -272,14 +275,14 @@ void ReducedModelOptimizer::createSimulationMeshes(
pFullPatternSimulationMesh = std::make_shared<SimulationMesh>(fullModel); pFullPatternSimulationMesh = std::make_shared<SimulationMesh>(fullModel);
pFullPatternSimulationMesh->setBeamCrossSection( pFullPatternSimulationMesh->setBeamCrossSection(
CrossSectionType{0.002, 0.002}); CrossSectionType{0.002, 0.002});
pFullPatternSimulationMesh->setBeamMaterial(0.3, 1 * 1e9); pFullPatternSimulationMesh->setBeamMaterial(0.3, 2.3465 * 1e9);
// Reduced pattern // Reduced pattern
pReducedPatternSimulationMesh = pReducedPatternSimulationMesh =
std::make_shared<SimulationMesh>(reducedModel); std::make_shared<SimulationMesh>(reducedModel);
pReducedPatternSimulationMesh->setBeamCrossSection( pReducedPatternSimulationMesh->setBeamCrossSection(
CrossSectionType{0.002, 0.002}); CrossSectionType{0.002, 0.002});
pReducedPatternSimulationMesh->setBeamMaterial(0.3, 1 * 1e9); pReducedPatternSimulationMesh->setBeamMaterial(0.3, 2.3465 * 1e9);
} }
void ReducedModelOptimizer::createSimulationMeshes( void ReducedModelOptimizer::createSimulationMeshes(
@ -474,7 +477,7 @@ void ReducedModelOptimizer::initializePatterns(PatternGeometry &fullPattern,
computeMaps(copyFullPattern, copyReducedPattern); computeMaps(copyFullPattern, copyReducedPattern);
createSimulationMeshes(copyFullPattern, copyReducedPattern); createSimulationMeshes(copyFullPattern, copyReducedPattern);
initializeOptimizationParameters(m_pReducedPatternSimulationMesh,optimizationParameters); initializeOptimizationParameters(m_pFullPatternSimulationMesh, optimizationParameters);
} }
void updateMesh(long n, const double *x) { void updateMesh(long n, const double *x) {
@ -488,7 +491,7 @@ void updateMesh(long n, const double *x) {
const double beamHeight=beamWidth; const double beamHeight=beamWidth;
const double J=global.initialParameters(2) * x[2]; const double J=global.initialParameters(2) * x[2];
const double I2=global.initialParameters(3) * x[3]; const double I2 = global.initialParameters(3) * x[3];
const double I3=global.initialParameters(4) * x[4]; const double I3=global.initialParameters(4) * x[4];
for (EdgeIndex ei = 0; ei < pReducedPatternSimulationMesh->EN(); ei++) { for (EdgeIndex ei = 0; ei < pReducedPatternSimulationMesh->EN(); ei++) {
Element &e = pReducedPatternSimulationMesh->elements[ei]; Element &e = pReducedPatternSimulationMesh->elements[ei];
@ -594,29 +597,26 @@ void ReducedModelOptimizer::computeReducedModelSimulationJob(
// &reducedToFullInterfaceViMap) // &reducedToFullInterfaceViMap)
//{ //{
// DRMSimulationModel simulator; // DRMSimulationModel simulator;
// std::shared_ptr<SimulationMesh> pFullPatternSimulationMesh = // std::shared_ptr<SimulationMesh> pFullPatternSimulationMesh = fullPatternSimulationJobs[0]->pMesh;
// fullPatternSimulationJobs[0]->pMesh;
// pFullPatternSimulationMesh->registerForDrawing(); // pFullPatternSimulationMesh->registerForDrawing();
// pFullPatternSimulationMesh->save(pFullPatternSimulationMesh->getLabel() + "_undeformed.ply"); // pFullPatternSimulationMesh->save(pFullPatternSimulationMesh->getLabel() + "_undeformed.ply");
// reducedPatternSimulationJobs[0]->pMesh->save(reducedPatternSimulationJobs[0]->pMesh->getLabel() // reducedPatternSimulationJobs[0]->pMesh->save(reducedPatternSimulationJobs[0]->pMesh->getLabel()
// + "_undeformed.ply"); // + "_undeformed.ply");
// double totalError = 0; // double totalError = 0;
// for (const int simulationScenarioIndex : simulationScenarios) { // for (const int simulationScenarioIndex : simulationScenarios) {
// const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob = // const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
// fullPatternSimulationJobs[simulationScenarioIndex]; // = fullPatternSimulationJobs[simulationScenarioIndex];
// pFullPatternSimulationJob->registerForDrawing( // pFullPatternSimulationJob->registerForDrawing(pFullPatternSimulationMesh->getLabel());
// pFullPatternSimulationMesh->getLabel()); // SimulationResults fullModelResults = simulator.executeSimulation(pFullPatternSimulationJob);
// SimulationResults fullModelResults =
// simulator.executeSimulation(pFullPatternSimulationJob);
// fullModelResults.registerForDrawing(); // fullModelResults.registerForDrawing();
// // fullModelResults.saveDeformedModel(); // // fullModelResults.saveDeformedModel();
// const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob = // const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob
// reducedPatternSimulationJobs[simulationScenarioIndex]; // = reducedPatternSimulationJobs[simulationScenarioIndex];
// SimulationResults reducedModelResults = // SimulationResults reducedModelResults = simulator.executeSimulation(
// simulator.executeSimulation(pReducedPatternSimulationJob); // pReducedPatternSimulationJob);
// double normalizationFactor = 1; // double normalizationFactor = 1;
// if (global.optimizationSettings.normalizationStrategy != // if (global.optimizationSettings.normalizationStrategy
// ReducedModelOptimization::Settings::NormalizationStrategy::NonNormalized) { // != ReducedModelOptimization::Settings::NormalizationStrategy::NonNormalized) {
// normalizationFactor // normalizationFactor
// = global.translationalDisplacementNormalizationValues[simulationScenarioIndex]; // = global.translationalDisplacementNormalizationValues[simulationScenarioIndex];
// } // }
@ -627,8 +627,7 @@ void ReducedModelOptimizer::computeReducedModelSimulationJob(
// reducedToFullInterfaceViMap, // reducedToFullInterfaceViMap,
// normalizationFactor); // normalizationFactor);
// std::cout << "Error of simulation scenario " // std::cout << "Error of simulation scenario "
// <baseSimulationScenarioNames[simulationScenarioIndex] // < baseSimulationScenarioNames[simulationScenarioIndex] << " is " << error << std::endl;
// << " is " << error << std::endl;
// totalError += error; // totalError += error;
// reducedModelResults.registerForDrawing(); // reducedModelResults.registerForDrawing();
// // firstOptimizationRoundResults[simulationScenarioIndex].registerForDrawing(); // // firstOptimizationRoundResults[simulationScenarioIndex].registerForDrawing();
@ -1075,22 +1074,23 @@ double fullPatternMaxSimulationForceRotationalObjective(const double &forceMagni
DRMSimulationModel simulator; DRMSimulationModel simulator;
DRMSimulationModel::Settings settings; DRMSimulationModel::Settings settings;
settings.totalExternalForcesNormPercentageTermination = 1e-2; settings.totalExternalForcesNormPercentageTermination = 1e-2;
settings.totalTranslationalKineticEnergyThreshold = 1e-9; settings.totalTranslationalKineticEnergyThreshold = 1e-8;
settings.shouldUseTranslationalKineticEnergyThreshold = true; settings.viscousDampingFactor = 1e-2;
// settings.shouldDraw = true; settings.useKineticDamping = true;
// settings.useAverage = true; settings.shouldDraw = false;
settings.debugModeStep = 200;
// settings.isDebugMode = true; // settings.averageResidualForcesCriterionThreshold = 1e-5;
// settings.drawingStep = 500; settings.maxDRMIterations = 200000;
// settings.beVerbose = true;
// settings.debugModeStep = 200000;
// settings.shouldCreatePlots = true;
settings.maxDRMIterations = 100000;
SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job), SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job),
settings); settings);
const double &desiredRotationAngle = global.desiredMaxRotationAngle; const double &desiredRotationAngle = global.desiredMaxRotationAngle;
double error; double error;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
job.pMesh->setLabel("initial");
// job.pMesh->registerForDrawing();
// results.registerForDrawing();
// polyscope::show();
std::string saveJobToPath;
if (!results.converged) { if (!results.converged) {
// std::cout << "Force used:" << forceMagnitude << std::endl; // std::cout << "Force used:" << forceMagnitude << std::endl;
error = std::numeric_limits<double>::max(); error = std::numeric_limits<double>::max();
@ -1108,12 +1108,21 @@ double fullPatternMaxSimulationForceRotationalObjective(const double &forceMagni
// debugSimulationSettings.shouldUseTranslationalKineticEnergyThreshold = true; // debugSimulationSettings.shouldUseTranslationalKineticEnergyThreshold = true;
// auto debugResults = simulator.executeSimulation(std::make_shared<SimulationJob>(job), // auto debugResults = simulator.executeSimulation(std::make_shared<SimulationJob>(job),
// debugSimulationSettings); // debugSimulationSettings);
// std::terminate();
saveJobToPath = "../nonConvergingJobs";
} else { } else {
error = std::abs( error = std::abs(
results.rotationalDisplacementQuaternion[global.interfaceViForComputingScenarioError] results.rotationalDisplacementQuaternion[global.interfaceViForComputingScenarioError]
.angularDistance(Eigen::Quaterniond::Identity()) .angularDistance(Eigen::Quaterniond::Identity())
- desiredRotationAngle); - desiredRotationAngle);
saveJobToPath = "../convergingJobs";
} }
std::filesystem::path outputPath(std::filesystem::path(saveJobToPath)
.append(job.pMesh->getLabel())
.append("mag_" + global.currentScenarioName));
std::filesystem::create_directories(outputPath);
job.save(outputPath);
settings.save(outputPath);
std::cout << "Force:" << forceMagnitude << " Error is:" << vcg::math::ToDeg(error) << std::endl; std::cout << "Force:" << forceMagnitude << " Error is:" << vcg::math::ToDeg(error) << std::endl;
#endif #endif
@ -1133,23 +1142,32 @@ double fullPatternMaxSimulationForceTranslationalObjective(const double &forceMa
DRMSimulationModel::Settings settings; DRMSimulationModel::Settings settings;
// settings.totalResidualForcesNormThreshold = 1e-3; // settings.totalResidualForcesNormThreshold = 1e-3;
settings.totalExternalForcesNormPercentageTermination = 1e-2; settings.totalExternalForcesNormPercentageTermination = 1e-2;
settings.totalTranslationalKineticEnergyThreshold = 1e-9; settings.totalTranslationalKineticEnergyThreshold = 1e-8;
settings.shouldUseTranslationalKineticEnergyThreshold = true; settings.viscousDampingFactor = 5e-3;
// settings.useAverage = true; settings.useKineticDamping = true;
// settings.averageResidualForcesCriterionThreshold = 1e-5;
// settings.useAverage = true;
// settings.totalTranslationalKineticEnergyThreshold = 1e-10; // settings.totalTranslationalKineticEnergyThreshold = 1e-10;
// settings.shouldUseTranslationalKineticEnergyThreshold = true; // settings.shouldUseTranslationalKineticEnergyThreshold = true;
// settings.shouldDraw = true; // settings.shouldDraw = true;
// settings.isDebugMode = true; // settings.isDebugMode = true;
// settings.drawingStep = 200000; // settings.drawingStep = 200000;
// settings.beVerbose = true; // settings.beVerbose = true;
// settings.debugModeStep = 200000; // settings.debugModeStep = 200;
settings.maxDRMIterations = 100000; settings.maxDRMIterations = 200000;
SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job), SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job),
settings); settings);
const double &desiredDisplacementValue = global.desiredMaxDisplacementValue; const double &desiredDisplacementValue = global.desiredMaxDisplacementValue;
double error; double error;
if (!results.converged) { if (!results.converged) {
error = std::numeric_limits<double>::max(); error = std::numeric_limits<double>::max();
std::filesystem::path outputPath(std::filesystem::path("../nonConvergingJobs")
.append(job.pMesh->getLabel())
.append("mag_" + global.currentScenarioName));
std::filesystem::create_directories(outputPath);
job.save(outputPath);
settings.save(outputPath);
// std::terminate();
} else { } else {
error = std::abs( error = std::abs(
results.displacements[global.interfaceViForComputingScenarioError].getTranslation().norm() results.displacements[global.interfaceViForComputingScenarioError].getTranslation().norm()
@ -1180,6 +1198,7 @@ double ReducedModelOptimizer::computeFullPatternMaxSimulationForce(
objectiveFunction = &fullPatternMaxSimulationForceTranslationalObjective; objectiveFunction = &fullPatternMaxSimulationForceTranslationalObjective;
global.interfaceViForComputingScenarioError = global.fullPatternInterfaceViPairs[1].first; global.interfaceViForComputingScenarioError = global.fullPatternInterfaceViPairs[1].first;
global.desiredMaxDisplacementValue = 0.1 * baseTriangleHeight; global.desiredMaxDisplacementValue = 0.1 * baseTriangleHeight;
global.currentScenarioName = baseSimulationScenarioNames[scenario];
double forceMagnitudeEpsilon = 1e-4; double forceMagnitudeEpsilon = 1e-4;
switch (scenario) { switch (scenario) {
@ -1187,16 +1206,16 @@ double ReducedModelOptimizer::computeFullPatternMaxSimulationForce(
global.desiredMaxDisplacementValue = 0.03 * baseTriangleHeight; global.desiredMaxDisplacementValue = 0.03 * baseTriangleHeight;
break; break;
case Shear: case Shear:
global.desiredMaxDisplacementValue = 0.04 * baseTriangleHeight; global.desiredMaxDisplacementValue = 0.03 * baseTriangleHeight;
break; break;
case Bending: case Bending:
global.interfaceViForComputingScenarioError = global.fullPatternInterfaceViPairs[0].first;
break; break;
case Dome: case Dome:
global.desiredMaxRotationAngle = vcg::math::ToRad(35.0); global.desiredMaxRotationAngle = vcg::math::ToRad(25.0);
objectiveFunction = &fullPatternMaxSimulationForceRotationalObjective; objectiveFunction = &fullPatternMaxSimulationForceRotationalObjective;
forceMagnitudeEpsilon *= 1e-2; forceMagnitudeEpsilon *= 1e-2;
objectiveEpsilon = vcg::math::ToRad(3.0); objectiveEpsilon = vcg::math::ToRad(3.0);
forceMagnitude = 0.6;
break; break;
case Saddle: case Saddle:
global.interfaceViForComputingScenarioError = global.fullPatternInterfaceViPairs[0].first; global.interfaceViForComputingScenarioError = global.fullPatternInterfaceViPairs[0].first;
@ -1224,9 +1243,11 @@ double ReducedModelOptimizer::computeFullPatternMaxSimulationForce(
std::filesystem::path outputPath( std::filesystem::path outputPath(
std::filesystem::path("../nonConvergingJobs") std::filesystem::path("../nonConvergingJobs")
.append(m_pFullPatternSimulationMesh->getLabel()) .append(m_pFullPatternSimulationMesh->getLabel())
.append("mag_" + ReducedPatternOptimization::baseSimulationScenarioNames[scenario])); .append("magFinal_"
+ ReducedPatternOptimization::baseSimulationScenarioNames[scenario]));
std::filesystem::create_directories(outputPath); std::filesystem::create_directories(outputPath);
job.save(outputPath); job.save(outputPath);
std::terminate();
} }
#endif #endif
@ -1247,15 +1268,14 @@ std::vector<std::shared_ptr<SimulationJob>> ReducedModelOptimizer::createFullPat
scenarioMaxForceMagnitudePairs) { scenarioMaxForceMagnitudePairs) {
const BaseSimulationScenario scenario = scenarioMaxForceMagnitudePair.first; const BaseSimulationScenario scenario = scenarioMaxForceMagnitudePair.first;
const double maxForceMagnitude = scenarioMaxForceMagnitudePair.second; const double maxForceMagnitude = scenarioMaxForceMagnitudePair.second;
const double minForceMagnitude = scenarioIsSymmetrical[scenario] ? 0 : -maxForceMagnitude;
const int numberOfSimulationScenarios = simulationScenariosResolution[scenario]; const int numberOfSimulationScenarios = simulationScenariosResolution[scenario];
const int forceMagnitudeSamples = scenarioIsSymmetrical[scenario] const double minForceMagnitude = scenarioIsSymmetrical[scenario]
? numberOfSimulationScenarios - 1 ? maxForceMagnitude / numberOfSimulationScenarios
: numberOfSimulationScenarios; : -maxForceMagnitude;
const double forceMagnitudeStep = numberOfSimulationScenarios == 1 const double forceMagnitudeStep = numberOfSimulationScenarios == 1
? maxForceMagnitude ? maxForceMagnitude
: (maxForceMagnitude - minForceMagnitude) : (maxForceMagnitude - minForceMagnitude)
/ (forceMagnitudeSamples); / (numberOfSimulationScenarios);
const int baseSimulationScenarioIndexOffset const int baseSimulationScenarioIndexOffset
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.begin() + scenario, simulationScenariosResolution.begin() + scenario,
@ -1344,11 +1364,10 @@ void ReducedModelOptimizer::computeObjectiveValueNormalizationFactors() {
global.translationalDisplacementNormalizationValues[simulationScenarioIndex] global.translationalDisplacementNormalizationValues[simulationScenarioIndex]
= std::max(fullPatternTranslationalDisplacementNormSum[simulationScenarioIndex], = std::max(fullPatternTranslationalDisplacementNormSum[simulationScenarioIndex],
epsilon_translationalDisplacement); epsilon_translationalDisplacement);
// const double epsilon_rotationalDisplacement = vcg::math::ToRad(10.0); const double epsilon_rotationalDisplacement = vcg::math::ToRad(3.0);
global.rotationalDisplacementNormalizationValues[simulationScenarioIndex] global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]
= /*std::max(*/ fullPatternAngularDistance[simulationScenarioIndex] /*, = std::max(fullPatternAngularDistance[simulationScenarioIndex],
epsilon_rotationalDisplacement)*/ epsilon_rotationalDisplacement);
;
} else { } else {
global.translationalDisplacementNormalizationValues[simulationScenarioIndex] = 1; global.translationalDisplacementNormalizationValues[simulationScenarioIndex] = 1;
global.rotationalDisplacementNormalizationValues[simulationScenarioIndex] = 1; global.rotationalDisplacementNormalizationValues[simulationScenarioIndex] = 1;
@ -1396,9 +1415,12 @@ void ReducedModelOptimizer::optimize(
results.baseTriangle = global.baseTriangle; results.baseTriangle = global.baseTriangle;
DRMSimulationModel::Settings simulationSettings; DRMSimulationModel::Settings simulationSettings;
simulationSettings.maxDRMIterations = 100000; simulationSettings.maxDRMIterations = 200000;
simulationSettings.shouldUseTranslationalKineticEnergyThreshold = true;
simulationSettings.totalTranslationalKineticEnergyThreshold = 1e-8; simulationSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
simulationSettings.viscousDampingFactor = 5e-3;
simulationSettings.useKineticDamping = true;
// simulationSettings.averageResidualForcesCriterionThreshold = 1e-5;
// simulationSettings.viscousDampingFactor = 1e-3;
// simulationSettings.beVerbose = true; // simulationSettings.beVerbose = true;
// simulationSettings.shouldDraw = true; // simulationSettings.shouldDraw = true;
// simulationSettings.isDebugMode = true; // simulationSettings.isDebugMode = true;
@ -1410,30 +1432,44 @@ void ReducedModelOptimizer::optimize(
ReducedPatternOptimization::Colors::fullInitial); ReducedPatternOptimization::Colors::fullInitial);
} }
#endif #endif
// LinearSimulationModel linearSimulator; results.wasSuccessful = true;
for (int simulationScenarioIndex : global.simulationScenarioIndices) { for (int simulationScenarioIndex : global.simulationScenarioIndices) {
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
= global.fullPatternSimulationJobs[simulationScenarioIndex]; = global.fullPatternSimulationJobs[simulationScenarioIndex];
SimulationResults fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob, SimulationResults fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob,
simulationSettings); simulationSettings);
// if (!fullPatternResults.converged) {
// DRMSimulationModel::Settings simulationSettings_secondRound;
// simulationSettings_secondRound.viscousDampingFactor = 2e-3;
// simulationSettings_secondRound.useKineticDamping = true;
// simulationSettings.maxDRMIterations = 200000;
// fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob,
// simulationSettings_secondRound);
#ifdef POLYSCOPE_DEFINED
// std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel()
// << " used viscous damping." << std::endl;
#endif
if (!fullPatternResults.converged) { if (!fullPatternResults.converged) {
results.wasSuccessful = false; results.wasSuccessful = false;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel() std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel()
<< " did not converge." << std::endl; << " did not converge." << std::endl;
// DRMSimulationModel::Settings debugSimulationSettings; // DRMSimulationModel::Settings debugSimulationSettings;
// debugSimulationSettings.isDebugMode = true; // debugSimulationSettings.debugModeStep = 50;
// debugSimulationSettings.debugModeStep = 1000; // // // debugSimulationSettings.maxDRMIterations = 100000;
// // debugSimulationSettings.maxDRMIterations = 100000;
// debugSimulationSettings.shouldDraw = true; // debugSimulationSettings.shouldDraw = true;
// debugSimulationSettings.drawingStep = debugSimulationSettings.debugModeStep; // // debugSimulationSettings.drawingStep = debugSimulationSettings.debugModeStep;
// debugSimulationSettings.shouldCreatePlots = true; // debugSimulationSettings.shouldCreatePlots = true;
// // debugSimulationSettings.Dtini = 0.06; // // // debugSimulationSettings.Dtini = 0.06;
// debugSimulationSettings.beVerbose = true; // debugSimulationSettings.beVerbose = true;
// debugSimulationSettings.useAverage = true; // debugSimulationSettings.averageResidualForcesCriterionThreshold = 1e-5;
// // debugSimulationSettings.totalExternalForcesNormPercentageTermination = 1e-3; // debugSimulationSettings.maxDRMIterations = 100000;
// // debugSimulationSettings.shouldUseTranslationalKineticEnergyThreshold = true; // debugSimulationSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
// debugSimulationSettings.viscousDampingFactor = 1e-2;
// // // debugSimulationSettings.totalExternalForcesNormPercentageTermination = 1e-3;
// // // debugSimulationSettings.shouldUseTranslationalKineticEnergyThreshold = true;
// auto debugResults = simulator.executeSimulation(pFullPatternSimulationJob, // auto debugResults = simulator.executeSimulation(pFullPatternSimulationJob,
// debugSimulationSettings); // debugSimulationSettings);
// debugResults.setLabelPrefix("debugResults"); // debugResults.setLabelPrefix("debugResults");
@ -1446,16 +1482,17 @@ void ReducedModelOptimizer::optimize(
.append("final_" + pFullPatternSimulationJob->getLabel())); .append("final_" + pFullPatternSimulationJob->getLabel()));
std::filesystem::create_directories(outputPath); std::filesystem::create_directories(outputPath);
pFullPatternSimulationJob->save(outputPath); pFullPatternSimulationJob->save(outputPath);
simulationSettings.save(outputPath);
#endif #endif
std::terminate();
return; return;
// }
} }
results.wasSuccessful = true;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
if (drawFullPatternSimulationResults) { if (drawFullPatternSimulationResults) {
// SimulationResults fullPatternResults_linear = linearSimulator.executeSimulation( // SimulationResults fullPatternResults_linear = linearSimulator.executeSimulation(
// pFullPatternSimulationJob); // pFullPatternSimulationJob);
fullPatternResults.registerForDrawing(ReducedPatternOptimization::Colors::fullDeformed, fullPatternResults.registerForDrawing(ReducedPatternOptimization::Colors::fullDeformed,
true,
true); true);
// fullPatternResults_linear.labelPrefix += "_linear"; // fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed, // fullPatternResults_linear.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed,

3
src/reducedmodeloptimizer.hpp
View File

@ -38,7 +38,8 @@ class ReducedModelOptimizer
int fullPatternNumberOfEdges; int fullPatternNumberOfEdges;
public: public:
constexpr static std::array<int, 5> simulationScenariosResolution = {10, 10, 20, 20, 20}; constexpr static std::array<int, 5> simulationScenariosResolution = {11, 11, 20, 20, 20};
// constexpr static std::array<int, 5> simulationScenariosResolution = {3, 3, 3, 3, 3};
inline static int totalNumberOfSimulationScenarios inline static int totalNumberOfSimulationScenarios
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.end(), simulationScenariosResolution.end(),