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

Refactoring. Replaced PatternGeometry with ReducedModel everywhere

This commit is contained in:
iasonmanolas 2022-05-06 16:38:50 +03:00
parent 7f11ea8a47
commit 90dc2ac081
2 changed files with 298 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

467
reducedmodeloptimizer.cpp
View File

@ -4,14 +4,17 @@
#include "simulationhistoryplotter.hpp" #include "simulationhistoryplotter.hpp"
#include "trianglepatterngeometry.hpp" #include "trianglepatterngeometry.hpp"
#include "trianglepattterntopology.hpp" #include "trianglepattterntopology.hpp"
#include <armadillo> #ifdef USE_ENSMALLEN
#include "ensmallen.hpp"
#endif
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
#include <execution> #include <execution>
#include <experimental/numeric> #include <experimental/numeric>
#include <functional> #include <functional>
#include <parallel/parallel.h> //#include <parallel/parallel.h>
//#define USE_SCENARIO_WEIGHTS //#define USE_SCENARIO_WEIGHTS
#include <armadillo>
using namespace ReducedModelOptimization; using namespace ReducedModelOptimization;
@ -233,6 +236,7 @@ double ReducedModelOptimizer::objective(const std::vector<double> &x,
// for (const int simulationScenarioIndex : optimizationState.simulationScenarioIndices) { // for (const int simulationScenarioIndex : optimizationState.simulationScenarioIndices) {
const std::shared_ptr<SimulationJob> &reducedJob const std::shared_ptr<SimulationJob> &reducedJob
= optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex]; = optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex];
//#ifdef POLYSCOPE_DEFINED //#ifdef POLYSCOPE_DEFINED
// std::cout << reducedJob->getLabel() << ":" << std::endl; // std::cout << reducedJob->getLabel() << ":" << std::endl;
//#endif //#endif
@ -243,7 +247,19 @@ double ReducedModelOptimizer::objective(const std::vector<double> &x,
= std::numeric_limits<double>::max(); = std::numeric_limits<double>::max();
optimizationState.numOfSimulationCrashes++; optimizationState.numOfSimulationCrashes++;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << "Failed simulation" << std::endl; std::cout << "Failed simulation with x:" << std::endl;
std::cout.precision(17);
for (int i = 0; i < x.size(); i++) {
std::cout << x[i] << " ";
}
std::cout << std::endl;
// pReducedPatternSimulationMesh->registerForDrawing();
// polyscope::show();
// pReducedPatternSimulationMesh->unregister();
// std::filesystem::create_directories("failedJob");
// reducedJob->save("failedJob");
// Results debugRes;
#endif #endif
} else { } else {
// const double simulationScenarioError_PE = std::abs( // const double simulationScenarioError_PE = std::abs(
@ -380,7 +396,7 @@ void ReducedModelOptimizer::createSimulationMeshes(PatternGeometry &fullModel,
void ReducedModelOptimizer::computeMaps( void ReducedModelOptimizer::computeMaps(
const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode, const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode,
PatternGeometry &fullPattern, PatternGeometry &fullPattern,
PatternGeometry &reducedPattern, ReducedModel &reducedPattern,
std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
&reducedToFullInterfaceViMap, &reducedToFullInterfaceViMap,
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex> std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
@ -427,11 +443,11 @@ void ReducedModelOptimizer::computeMaps(
const size_t reducedModelBaseTriangleInterfaceVi = pu_reducedModel.remap[baseTriangleInterfaceVi]; const size_t reducedModelBaseTriangleInterfaceVi = pu_reducedModel.remap[baseTriangleInterfaceVi];
const size_t reducedModelInterfaceVertexOffset const size_t reducedModelInterfaceVertexOffset
= reducedPattern.VN() /*- 1*/ /*- reducedModelBaseTriangleInterfaceVi*/; = reducedPattern.VN() /*- 1*/ /*- reducedModelBaseTriangleInterfaceVi*/;
Results::applyOptimizationResults_innerHexagon(initialHexagonSize, Results::applyOptimizationResults_reducedModel_nonFanned(initialHexagonSize,
0, 0,
baseTriangle, baseTriangle,
reducedPattern); reducedPattern);
reducedPattern.createFan({0}); //TODO: should be an input parameter from main reducedPattern.createFan(); //TODO: should be an input parameter from main
for (size_t fanIndex = 0; fanIndex < fanSize; fanIndex++) { for (size_t fanIndex = 0; fanIndex < fanSize; fanIndex++) {
reducedToFullInterfaceViMap[reducedModelInterfaceVertexOffset * fanIndex reducedToFullInterfaceViMap[reducedModelInterfaceVertexOffset * fanIndex
+ reducedModelBaseTriangleInterfaceVi] + reducedModelBaseTriangleInterfaceVi]
@ -503,12 +519,11 @@ void ReducedModelOptimizer::computeMaps(
#endif #endif
} }
void ReducedModelOptimizer::computeMaps(PatternGeometry &fullPattern, void ReducedModelOptimizer::computeMaps(PatternGeometry &fullPattern, ReducedModel &reducedModel)
PatternGeometry &reducedPattern)
{ {
ReducedModelOptimizer::computeMaps(slotToNode, ReducedModelOptimizer::computeMaps(slotToNode,
fullPattern, fullPattern,
reducedPattern, reducedModel,
optimizationState.reducedToFullInterfaceViMap, optimizationState.reducedToFullInterfaceViMap,
m_fullToReducedInterfaceViMap, m_fullToReducedInterfaceViMap,
m_fullPatternOppositeInterfaceViPairs); m_fullPatternOppositeInterfaceViPairs);
@ -529,38 +544,42 @@ ReducedModelOptimizer::ReducedModelOptimizer()
scenarioIsSymmetrical[BaseSimulationScenario::Shear] = false; scenarioIsSymmetrical[BaseSimulationScenario::Shear] = false;
constructBaseScenarioFunctions[BaseSimulationScenario::Bending] constructBaseScenarioFunctions[BaseSimulationScenario::Bending]
= &constructBendingSimulationScenario; = &constructBendingSimulationScenario;
scenarioIsSymmetrical[BaseSimulationScenario::Bending] = false; scenarioIsSymmetrical[BaseSimulationScenario::Bending] = true;
constructBaseScenarioFunctions[BaseSimulationScenario::Dome] = &constructDomeSimulationScenario; constructBaseScenarioFunctions[BaseSimulationScenario::Dome] = &constructDomeSimulationScenario;
scenarioIsSymmetrical[BaseSimulationScenario::Dome] = false; scenarioIsSymmetrical[BaseSimulationScenario::Dome] = true;
constructBaseScenarioFunctions[BaseSimulationScenario::Saddle] constructBaseScenarioFunctions[BaseSimulationScenario::Saddle]
= &constructSaddleSimulationScenario; = &constructSaddleSimulationScenario;
scenarioIsSymmetrical[BaseSimulationScenario::Saddle] = false; scenarioIsSymmetrical[BaseSimulationScenario::Saddle] = true;
constructBaseScenarioFunctions[BaseSimulationScenario::S] = &constructSSimulationScenario; constructBaseScenarioFunctions[BaseSimulationScenario::S] = &constructSSimulationScenario;
scenarioIsSymmetrical[BaseSimulationScenario::S] = false; scenarioIsSymmetrical[BaseSimulationScenario::S] = true;
} }
void ReducedModelOptimizer::initializePatterns( void ReducedModelOptimizer::initializePatterns(
PatternGeometry &fullPattern, PatternGeometry &fullPattern,
PatternGeometry &reducedPattern, ReducedModel &reducedModel,
const std::array<xRange, NumberOfOptimizationVariables> &optimizationParameters) const std::array<xRange, NumberOfOptimizationVariables> &optimizationParameters)
{ {
assert(fullPattern.VN() == reducedPattern.VN() && fullPattern.EN() >= reducedPattern.EN()); assert(fullPattern.VN() == reducedModel.VN() && fullPattern.EN() >= reducedModel.EN());
#if POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
polyscope::removeAllStructures(); polyscope::removeAllStructures();
#endif #endif
// Create copies of the input models // Create copies of the input models
PatternGeometry copyFullPattern; PatternGeometry copyFullPattern;
PatternGeometry copyReducedPattern; ReducedModel copyReducedModel;
copyFullPattern.copy(fullPattern); copyFullPattern.copy(fullPattern);
copyReducedPattern.copy(reducedPattern); copyReducedModel.copy(reducedModel);
#ifdef POLYSCOPE_DEFINED
copyFullPattern.updateEigenEdgeAndVertices(); copyFullPattern.updateEigenEdgeAndVertices();
copyReducedPattern.updateEigenEdgeAndVertices(); #endif
baseTriangle = copyReducedPattern.getBaseTriangle(); copyReducedModel.updateEigenEdgeAndVertices();
baseTriangle = copyReducedModel.getBaseTriangle();
computeMaps(copyFullPattern, copyReducedPattern); computeMaps(copyFullPattern, copyReducedModel);
optimizationState.fullPatternOppositeInterfaceViPairs = m_fullPatternOppositeInterfaceViPairs; optimizationState.fullPatternOppositeInterfaceViPairs = m_fullPatternOppositeInterfaceViPairs;
createSimulationMeshes(copyFullPattern, copyReducedPattern); g_baseScenarioMaxDisplacementHelperData.fullPatternOppositeInterfaceViPairs
= m_fullPatternOppositeInterfaceViPairs;
createSimulationMeshes(copyFullPattern, copyReducedModel);
initializeUpdateReducedPatternFunctions(); initializeUpdateReducedPatternFunctions();
initializeOptimizationParameters(m_pFullPatternSimulationMesh, optimizationParameters); initializeOptimizationParameters(m_pFullPatternSimulationMesh, optimizationParameters);
} }
@ -570,9 +589,9 @@ void ReducedModelOptimizer::optimize(ConstPatternGeometry &fullPattern,
ReducedModelOptimization::Results &optimizationResults) ReducedModelOptimization::Results &optimizationResults)
{ {
//scale pattern and reduced model //scale pattern and reduced model
fullPattern.scale(optimizationSettings.targetBaseTriangleSize, interfaceNodeIndex); fullPattern.scale(optimizationSettings.targetBaseTriangleSize);
ReducedModel reducedModel; ReducedModel reducedModel;
reducedModel.scale(optimizationSettings.targetBaseTriangleSize, interfaceNodeIndex); reducedModel.scale(optimizationSettings.targetBaseTriangleSize);
auto start = std::chrono::system_clock::now(); auto start = std::chrono::system_clock::now();
optimizationResults.label = fullPattern.getLabel(); optimizationResults.label = fullPattern.getLabel();
optimizationResults.baseTriangleFullPattern.copy(fullPattern); optimizationResults.baseTriangleFullPattern.copy(fullPattern);
@ -589,18 +608,23 @@ void ReducedModelOptimizer::initializeUpdateReducedPatternFunctions()
{ {
const vcg::Triangle3<double> &baseTriangle = this->baseTriangle; const vcg::Triangle3<double> &baseTriangle = this->baseTriangle;
optimizationState.functions_updateReducedPatternParameter[R] = optimizationState.functions_updateReducedPatternParameter[R] =
[=](const double &newR, std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh) { [=](const double &newR, std::shared_ptr<SimulationMesh> &pReducedModelSimulationMesh) {
// std::shared_ptr<VCGEdgeMesh> pReducedModel_edgeMesh = std::dynamic_pointer_cast<VCGEdgeMesh>(
// pReducedModelSimulationMesh);
// ReducedModel::updateFannedGeometry_R(newR, pReducedModel_edgeMesh);
const CoordType barycentricCoordinates_hexagonBaseTriangleVertex(1 - newR, const CoordType barycentricCoordinates_hexagonBaseTriangleVertex(1 - newR,
newR / 2, newR / 2,
newR / 2); newR / 2);
// const vcg::Triangle3<double> &baseTriangle = getBaseTriangle();
const CoordType hexagonBaseTriangleVertexPosition const CoordType hexagonBaseTriangleVertexPosition
= baseTriangle.cP(0) * barycentricCoordinates_hexagonBaseTriangleVertex[0] = baseTriangle.cP(0) * barycentricCoordinates_hexagonBaseTriangleVertex[0]
+ baseTriangle.cP(1) * barycentricCoordinates_hexagonBaseTriangleVertex[1] + baseTriangle.cP(1) * barycentricCoordinates_hexagonBaseTriangleVertex[1]
+ baseTriangle.cP(2) * barycentricCoordinates_hexagonBaseTriangleVertex[2]; + baseTriangle.cP(2) * barycentricCoordinates_hexagonBaseTriangleVertex[2];
// constexpr int fanSize = 6;
for (int rotationCounter = 0; rotationCounter < ReducedModelOptimizer::fanSize; for (int rotationCounter = 0; rotationCounter < ReducedModelOptimizer::fanSize;
rotationCounter++) { rotationCounter++) {
pReducedPatternSimulationMesh->vert[2 * rotationCounter].P() pReducedModelSimulationMesh->vert[2 * rotationCounter].P()
= vcg::RotationMatrix(PatternGeometry::DefaultNormal, = vcg::RotationMatrix(PatternGeometry::DefaultNormal,
vcg::math::ToRad(60.0 * rotationCounter)) vcg::math::ToRad(60.0 * rotationCounter))
* hexagonBaseTriangleVertexPosition; * hexagonBaseTriangleVertexPosition;
@ -608,17 +632,21 @@ void ReducedModelOptimizer::initializeUpdateReducedPatternFunctions()
}; };
optimizationState.functions_updateReducedPatternParameter[Theta] = optimizationState.functions_updateReducedPatternParameter[Theta] =
[](const double &newTheta, std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh) { [](const double &newTheta_degrees,
const CoordType baseTriangleHexagonVertexPosition std::shared_ptr<SimulationMesh> &pReducedModelSimulationMesh) {
= pReducedPatternSimulationMesh->vert[0].cP(); // std::shared_ptr<VCGEdgeMesh> pReducedModel_edgeMesh
// = std::dynamic_pointer_cast<VCGEdgeMesh>(pReducedModelSimulationMesh);
// ReducedModel::updateFannedGeometry_theta(newTheta_degrees, pReducedModel_edgeMesh);
const CoordType baseTriangleHexagonVertexPosition = pReducedModelSimulationMesh->vert[0]
.cP();
const CoordType thetaRotatedHexagonBaseTriangleVertexPosition const CoordType thetaRotatedHexagonBaseTriangleVertexPosition
= vcg::RotationMatrix(PatternGeometry::DefaultNormal, vcg::math::ToRad(newTheta)) = vcg::RotationMatrix(PatternGeometry::DefaultNormal,
vcg::math::ToRad(newTheta_degrees))
* baseTriangleHexagonVertexPosition; * baseTriangleHexagonVertexPosition;
for (int rotationCounter = 0; rotationCounter < ReducedModelOptimizer::fanSize; for (int rotationCounter = 0; rotationCounter < ReducedModelOptimizer::fanSize;
rotationCounter++) { rotationCounter++) {
pReducedPatternSimulationMesh->vert[2 * rotationCounter].P() pReducedModelSimulationMesh->vert[2 * rotationCounter].P()
= vcg::RotationMatrix(PatternGeometry::DefaultNormal, = vcg::RotationMatrix(PatternGeometry::DefaultNormal,
vcg::math::ToRad(60.0 * rotationCounter)) vcg::math::ToRad(60.0 * rotationCounter))
* thetaRotatedHexagonBaseTriangleVertexPosition; * thetaRotatedHexagonBaseTriangleVertexPosition;
@ -814,9 +842,9 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
} }
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << std::endl; std::cout << std::endl;
m_pReducedPatternSimulationMesh->updateEigenEdgeAndVertices();
#endif #endif
m_pReducedPatternSimulationMesh->reset(); m_pReducedPatternSimulationMesh->reset();
results.fullPatternYoungsModulus = youngsModulus; results.fullPatternYoungsModulus = youngsModulus;
// Compute obj value per simulation scenario and the raw objective value // Compute obj value per simulation scenario and the raw objective value
// updateMeshFunction(optimalX); // updateMeshFunction(optimalX);
@ -844,8 +872,9 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
optimizationState.simulationScenarioIndices.size()); optimizationState.simulationScenarioIndices.size());
for (int i = 0; i < optimizationState.simulationScenarioIndices.size(); i++) { for (int i = 0; i < optimizationState.simulationScenarioIndices.size(); i++) {
const int simulationScenarioIndex = optimizationState.simulationScenarioIndices[i]; const int simulationScenarioIndex = optimizationState.simulationScenarioIndices[i];
SimulationResults reducedModelResults = simulator.executeSimulation( std::shared_ptr<SimulationJob> &pReducedJob
optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex]); = optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex];
SimulationResults reducedModelResults = simulator.executeSimulation(pReducedJob);
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
#ifdef USE_SCENARIO_WEIGHTS #ifdef USE_SCENARIO_WEIGHTS
@ -943,11 +972,12 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
<< std::endl; << std::endl;
std::cout << std::endl; std::cout << std::endl;
// reducedModelResults.registerForDrawing(Colors::reducedDeformed); reducedModelResults.registerForDrawing(Colors::reducedDeformed);
// optimizationState.fullPatternResults[simulationScenarioIndex].registerForDrawing(Colors::fullDeformed); optimizationState.fullPatternResults[simulationScenarioIndex].registerForDrawing(
// polyscope::show(); Colors::fullDeformed);
// reducedModelResults.unregister(); polyscope::show();
// optimizationState.fullPatternResults[simulationScenarioIndex].unregister(); reducedModelResults.unregister();
optimizationState.fullPatternResults[simulationScenarioIndex].unregister();
#endif #endif
} }
@ -968,6 +998,7 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
// results.draw(); // results.draw();
} }
#ifdef DLIB_DEFINED
std::array<double, NumberOfBaseSimulationScenarios> std::array<double, NumberOfBaseSimulationScenarios>
ReducedModelOptimizer::computeFullPatternMaxSimulationForces( ReducedModelOptimizer::computeFullPatternMaxSimulationForces(
const std::vector<BaseSimulationScenario> &desiredBaseSimulationScenario) const const std::vector<BaseSimulationScenario> &desiredBaseSimulationScenario) const
@ -1028,6 +1059,7 @@ ReducedModelOptimizer::getFullPatternMaxSimulationForces(
return fullPatternSimulationScenarioMaxMagnitudes; return fullPatternSimulationScenarioMaxMagnitudes;
} }
#endif
void ReducedModelOptimizer::runOptimization(const Settings &settings, void ReducedModelOptimizer::runOptimization(const Settings &settings,
ReducedModelOptimization::Results &results) ReducedModelOptimization::Results &results)
@ -1087,8 +1119,8 @@ void ReducedModelOptimizer::runOptimization(const Settings &settings,
= optimizationState.parametersInitialValue[parameterIndex]; = optimizationState.parametersInitialValue[parameterIndex];
return x[xIndex] * parameterInitialValue; return x[xIndex] * parameterInitialValue;
}(); }();
// std::cout << "Optimization parameter:" << parameterIndex << std::endl; // std::cout << "Optimization parameter:" << parameterIndex << std::endl;
// std::cout << "New value:" << parameterNewValue << std::endl; // std::cout << "New value:" << parameterNewValue << std::endl;
optimizationState optimizationState
.functions_updateReducedPatternParameter[parameterIndex](parameterNewValue, .functions_updateReducedPatternParameter[parameterIndex](parameterNewValue,
pMesh); pMesh);
@ -1141,7 +1173,7 @@ void ReducedModelOptimizer::runOptimization(const Settings &settings,
#else #else
ens::SA optimizer; ens::SA optimizer;
#endif #endif
// ens::LBestPSO optimizer; // ens::LBestPSO optimizer;
parameterGroup_optimalResult.y = optimizer.Optimize(optimizationFunction, x); parameterGroup_optimalResult.y = optimizer.Optimize(optimizationFunction, x);
// for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) { // for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
// if (x[xIndex] > optimizationState.xMax[xIndex]) { // if (x[xIndex] > optimizationState.xMax[xIndex]) {
@ -1155,7 +1187,6 @@ void ReducedModelOptimizer::runOptimization(const Settings &settings,
std::cout << "optimal x:" std::cout << "optimal x:"
<< "\n" << "\n"
<< x << std::endl; << x << std::endl;
std::cout << "Minima:" << minima << std::endl;
std::cout << "optimal objective:" << optimizationFunction.Evaluate(x) << std::endl; std::cout << "optimal objective:" << optimizationFunction.Evaluate(x) << std::endl;
#endif #endif
parameterGroup_optimalResult.x.clear(); parameterGroup_optimalResult.x.clear();
@ -1382,36 +1413,47 @@ void ReducedModelOptimizer::constructDomeSimulationScenario(
- job.pMesh->vert[viPair.second].cP()); - job.pMesh->vert[viPair.second].cP());
VectorType momentAxis = vcg::RotationMatrix(VectorType(0, 0, 1), vcg::math::ToRad(90.0)) VectorType momentAxis = vcg::RotationMatrix(VectorType(0, 0, 1), vcg::math::ToRad(90.0))
* interfaceVector.Normalize(); * interfaceVector.Normalize();
if (viPairIt == oppositeInterfaceViPairs.begin()) { // if (viPairIt == oppositeInterfaceViPairs.begin()) {
job.nodalForcedDisplacements[viPair.first] // // job.nodalForcedDisplacements[viPair.first] = Eigen::Vector3d(-interfaceVector[0],
= Eigen::Vector3d(-interfaceVector[0], // // -interfaceVector[1],
-interfaceVector[1], // // 0)
0) // // * 0.01
* 0.001 // /** std::abs(
* std::abs( // forceMagnitude)*/
forceMagnitude); //NOTE:Should the forced displacement change relatively to the magnitude? // // ; //NOTE:Should the forced displacement change relatively to the magnitude?
// * std::abs(forceMagnitude / maxForceMagnitude_dome); // // * std::abs(forceMagnitude / maxForceMagnitude_dome);
job.nodalForcedDisplacements[viPair.second] = Eigen::Vector3d(interfaceVector[0], // // job.nodalForcedDisplacements[viPair.second] = Eigen::Vector3d(interfaceVector[0],
interfaceVector[1], // // interfaceVector[1],
0) // // 0)
* 0.001 * std::abs(forceMagnitude); // // * 0.01 /** std::abs(forceMagnitude)*/;
// * std::abs(forceMagnitude / maxForceMagnitude_dome); // // * std::abs(forceMagnitude / maxForceMagnitude_dome);
// CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP()) // // CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP())
// ^ CoordType(0, 0, -1).Normalize(); // // ^ CoordType(0, 0, -1).Normalize();
// nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude // // nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude
// * 0.0001; // // * 0.0001;
// nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude // // nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude
// * 0.0001; // // * 0.0001;
} else { // job.constrainedVertices[viPair.first] = {0, 1, 2};
job.nodalExternalForces[viPair.first] // job.constrainedVertices[viPair.second] = {2};
= Vector6d({0, 0, 0, momentAxis[0], momentAxis[1], momentAxis[2]}) * forceMagnitude // job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{0, 1, 2};
/ 3; // job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{0, 2};
job.nodalExternalForces[viPair.second] // } else {
= Vector6d({0, 0, 0, -momentAxis[0], -momentAxis[1], -momentAxis[2]}) // job.nodalExternalForces[viPair.first]
* forceMagnitude / 3; // = Vector6d({0, 0, 0, momentAxis[0], momentAxis[1], momentAxis[2]}) * forceMagnitude
job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{2}; // / 3;
job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{2}; // job.nodalExternalForces[viPair.second]
} // = Vector6d({0, 0, 0, -momentAxis[0], -momentAxis[1], -momentAxis[2]})
// * forceMagnitude / 3;
// job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{2};
// job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{2};
// }
job.nodalExternalForces[viPair.first]
= Vector6d({0, 0, 0, momentAxis[0], momentAxis[1], momentAxis[2]}) * forceMagnitude / 3;
job.nodalExternalForces[viPair.second]
= Vector6d({0, 0, 0, -momentAxis[0], -momentAxis[1], -momentAxis[2]}) * forceMagnitude
/ 3;
job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{0, 1, 2};
job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{2};
} }
} }
@ -1564,7 +1606,7 @@ double fullPatternMaxSimulationForceTranslationalObjective(const double &forceMa
settings.totalExternalForcesNormPercentageTermination = 1e-2; settings.totalExternalForcesNormPercentageTermination = 1e-2;
settings.totalTranslationalKineticEnergyThreshold = 1e-8; settings.totalTranslationalKineticEnergyThreshold = 1e-8;
settings.viscousDampingFactor = 5e-3; settings.viscousDampingFactor = 5e-3;
settings.useKineticDamping = true; settings.useTranslationalKineticEnergyForKineticDamping = true;
// settings.averageResidualForcesCriterionThreshold = 1e-5; // settings.averageResidualForcesCriterionThreshold = 1e-5;
// settings.useAverage = true; // settings.useAverage = true;
// settings.totalTranslationalKineticEnergyThreshold = 1e-10; // settings.totalTranslationalKineticEnergyThreshold = 1e-10;
@ -1616,6 +1658,7 @@ struct ForceMagnitudeOptimization
}; };
#endif #endif
#ifdef DLIB_DEFINED
double ReducedModelOptimizer::computeFullPatternMaxSimulationForce( double ReducedModelOptimizer::computeFullPatternMaxSimulationForce(
const BaseSimulationScenario &scenario) const const BaseSimulationScenario &scenario) const
{ {
@ -1733,6 +1776,7 @@ double ReducedModelOptimizer::computeFullPatternMaxSimulationForce(
return forceMagnitude; return forceMagnitude;
} }
#endif
void ReducedModelOptimizer::computeScenarioWeights( void ReducedModelOptimizer::computeScenarioWeights(
const std::vector<BaseSimulationScenario> &baseSimulationScenarios, const std::vector<BaseSimulationScenario> &baseSimulationScenarios,
@ -1818,7 +1862,7 @@ std::vector<std::shared_ptr<SimulationJob>> ReducedModelOptimizer::createFullPat
const double forceMagnitudeStep = numberOfSimulationScenarios == 1 const double forceMagnitudeStep = numberOfSimulationScenarios == 1
? maxForceMagnitude ? maxForceMagnitude
: (maxForceMagnitude - minForceMagnitude) : (maxForceMagnitude - minForceMagnitude)
/ (numberOfSimulationScenarios); / (numberOfSimulationScenarios - 1);
const int baseSimulationScenarioIndexOffset const int baseSimulationScenarioIndexOffset
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.begin() + baseScenario, simulationScenariosResolution.begin() + baseScenario,
@ -1949,11 +1993,15 @@ void ReducedModelOptimizer::optimize(
continue; continue;
} }
} }
std::set<BaseSimulationScenario> set_desiredScenarios(desiredBaseSimulationScenarios.begin(),
desiredBaseSimulationScenarios.end());
std::set<BaseSimulationScenario> set_zeroScenarios(zeroMagnitudeScenarios.begin(),
zeroMagnitudeScenarios.end());
std::vector<BaseSimulationScenario> usedBaseSimulationScenarios; std::vector<BaseSimulationScenario> usedBaseSimulationScenarios;
std::set_difference(desiredBaseSimulationScenarios.begin(), std::set_difference(set_desiredScenarios.begin(),
desiredBaseSimulationScenarios.end(), set_desiredScenarios.end(),
zeroMagnitudeScenarios.begin(), set_zeroScenarios.begin(),
zeroMagnitudeScenarios.end(), set_zeroScenarios.end(),
std::back_inserter(usedBaseSimulationScenarios)); std::back_inserter(usedBaseSimulationScenarios));
assert(!optimizationSettings.optimizationStrategy.empty()); assert(!optimizationSettings.optimizationStrategy.empty());
@ -1979,11 +2027,16 @@ void ReducedModelOptimizer::optimize(
0)); 0));
} }
// constexpr bool recomputeForceMagnitudes = true; // constexpr bool recomputeForceMagnitudes = false;
// std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes // std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes
// = getFullPatternMaxSimulationForces(usedBaseSimulationScenarios, // = getFullPatternMaxSimulationForces(usedBaseSimulationScenarios,
// optimizationSettings.intermediateResultsDirectoryPath, // optimizationSettings.intermediateResultsDirectoryPath,
// recomputeForceMagnitudes); // recomputeForceMagnitudes);
// for (int baseScenario = Axial; baseScenario != NumberOfBaseSimulationScenarios; baseScenario++) {
// fullPatternSimulationScenarioMaxMagnitudes[baseScenario]
// = std::min(fullPatternSimulationScenarioMaxMagnitudes[baseScenario],
// optimizationSettings.baseScenarioMaxMagnitudes[baseScenario]);
// }
// optimizationSettings.baseScenarioMaxMagnitudes = fullPatternSimulationScenarioMaxMagnitudes; // optimizationSettings.baseScenarioMaxMagnitudes = fullPatternSimulationScenarioMaxMagnitudes;
std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes
= optimizationSettings.baseScenarioMaxMagnitudes; = optimizationSettings.baseScenarioMaxMagnitudes;
@ -1997,47 +2050,60 @@ void ReducedModelOptimizer::optimize(
results.baseTriangle = baseTriangle; results.baseTriangle = baseTriangle;
DRMSimulationModel::Settings simulationSettings; DRMSimulationModel::Settings drmSettings;
simulationSettings.totalExternalForcesNormPercentageTermination = 1e-5; drmSettings.totalExternalForcesNormPercentageTermination = 1e-5;
simulationSettings.maxDRMIterations = 200000; drmSettings.maxDRMIterations = 200000;
simulationSettings.totalTranslationalKineticEnergyThreshold = 1e-15; // drmSettings.totalTranslationalKineticEnergyThreshold = 1e-10;
// simulationSettings.viscousDampingFactor = 5e-3; drmSettings.totalTranslationalKineticEnergyThreshold = 1e-9;
// simulationSettings.debugModeStep = 100000; // drmSettings.gradualForcedDisplacementSteps = 20;
// simulationSettings.shouldDraw = true; // drmSettings.linearGuessForceScaleFactor = 1;
// simulationSettings.beVerbose = true; // drmSettings.viscousDampingFactor = 5e-3;
// simulationSettings.useKineticDamping = true; // drmSettings.useTotalRotationalKineticEnergyForKineticDamping = true;
// simulationSettings.save(std::filesystem::path(std::string(__FILE__)) // drmSettings.shouldDraw = true;
// .parent_path()
// .parent_path()
// .append("DefaultSettings")
// .append("DRMSettings")
// .append("defaultDRMSimulationSettings.json"));
// simulationSettings.averageResidualForcesCriterionThreshold = 1e-5; // drmSettings.totalExternalForcesNormPercentageTermination = 1e-2;
// simulationSettings.viscousDampingFactor = 1e-3; drmSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
// simulationSettings.beVerbose = true; // drmSettings.viscousDampingFactor = 5e-3;
// simulationSettings.shouldDraw = true; // simulationSettings.viscousDampingFactor = 5e-3;
// simulationSettings.isDebugMode = true; // simulationSettings.linearGuessForceScaleFactor = 1;
// simulationSettings.debugModeStep = 100000; // simulationSettings.gamma = 0.3;
#ifdef POLYSCOPE_DEFINED // simulationSettings.xi = 0.9999;
// drmSettings.debugModeStep = 100;
// drmSettings.shouldDraw = true;
// drmSettings.shouldCreatePlots = true;
// drmSettings.beVerbose = true;
// simulationSettings.useKineticDamping = true;
// simulationSettings.save(std::filesystem::path(std::string(__FILE__))
// .parent_path()
// .parent_path()
// .append("DefaultSettings")
// .append("DRMSettings")
// .append("defaultDRMSimulationSettings.json"));
// simulationSettings.averageResidualForcesCriterionThreshold = 1e-5;
// simulationSettings.viscousDampingFactor = 1e-3;
// simulationSettings.beVerbose = true;
// simulationSettings.shouldDraw = true;
// simulationSettings.isDebugMode = true;
// simulationSettings.debugModeStep = 100000;
//#ifdef POLYSCOPE_DEFINED
constexpr bool drawFullPatternSimulationResults = false; constexpr bool drawFullPatternSimulationResults = false;
if (drawFullPatternSimulationResults) { auto t1 = std::chrono::high_resolution_clock::now();
optimizationState.fullPatternSimulationJobs[0]->pMesh->registerForDrawing( //#endif
ReducedModelOptimization::Colors::fullInitial);
}
#endif
results.wasSuccessful = true; results.wasSuccessful = true;
optimizationState.fullPatternResults.resize(totalNumberOfSimulationScenarios); optimizationState.fullPatternResults.resize(totalNumberOfSimulationScenarios);
optimizationState.reducedPatternSimulationJobs.resize(totalNumberOfSimulationScenarios); optimizationState.reducedPatternSimulationJobs.resize(totalNumberOfSimulationScenarios);
std::for_each( std::for_each(
//#ifndef POLYSCOPE_DEFINED
std::execution::par_unseq, std::execution::par_unseq,
//#endif
optimizationState.simulationScenarioIndices.begin(), optimizationState.simulationScenarioIndices.begin(),
optimizationState.simulationScenarioIndices.end(), optimizationState.simulationScenarioIndices.end(),
[&](const int &simulationScenarioIndex) { [&](const int &simulationScenarioIndex) {
// for (int simulationScenarioIndex : optimizationState.simulationScenarioIndices) {
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
= optimizationState.fullPatternSimulationJobs[simulationScenarioIndex]; = optimizationState.fullPatternSimulationJobs[simulationScenarioIndex];
// std::cout << "Executing " << pFullPatternSimulationJob->getLabel() << std::endl;
std::filesystem::path jobResultsDirectoryPath( std::filesystem::path jobResultsDirectoryPath(
std::filesystem::path(optimizationSettings.intermediateResultsDirectoryPath) std::filesystem::path(optimizationSettings.intermediateResultsDirectoryPath)
@ -2050,7 +2116,7 @@ void ReducedModelOptimizer::optimize(
//#else //#else
// constexpr bool recomputeFullPatternResults = true; // constexpr bool recomputeFullPatternResults = true;
//#endif //#endif
SimulationResults fullPatternResults; SimulationResults patternDrmResults;
// if (!recomputeFullPatternResults && std::filesystem::exists(jobResultsDirectoryPath)) { // if (!recomputeFullPatternResults && std::filesystem::exists(jobResultsDirectoryPath)) {
// fullPatternResults // fullPatternResults
// .load(std::filesystem::path(jobResultsDirectoryPath).append("Results"), // .load(std::filesystem::path(jobResultsDirectoryPath).append("Results"),
@ -2078,76 +2144,101 @@ void ReducedModelOptimizer::optimize(
//#else //#else
DRMSimulationModel simulator; DRMSimulationModel simulator;
fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob, patternDrmResults = simulator.executeSimulation(pFullPatternSimulationJob, drmSettings);
simulationSettings); // fullPatternResults.save(jobResultsDirectoryPath);
// fullPatternResults.save(jobResultsDirectoryPath); // }
// } //#endif
//#endif // if (!fullPatternResults.converged) {
// if (!fullPatternResults.converged) { // DRMSimulationModel::Settings simulationSettings_secondRound;
// DRMSimulationModel::Settings simulationSettings_secondRound; // simulationSettings_secondRound.viscousDampingFactor = 2e-3;
// simulationSettings_secondRound.viscousDampingFactor = 2e-3; // simulationSettings_secondRound.useKineticDamping = true;
// simulationSettings_secondRound.useKineticDamping = true; // simulationSettings.maxDRMIterations = 200000;
// simulationSettings.maxDRMIterations = 200000; // fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob,
// fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob, // simulationSettings_secondRound);
// simulationSettings_secondRound);
#ifdef POLYSCOPE_DEFINED
// std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel()
// << " used viscous damping." << std::endl;
#endif
if (!fullPatternResults.converged) { if (!patternDrmResults.converged) {
results.wasSuccessful = false;
std::cerr << "Simulation job " << pFullPatternSimulationJob->getLabel()
<< " did not converge." << std::endl;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
// DRMSimulationModel::Settings debugSimulationSettings;
// debugSimulationSettings.debugModeStep = 50;
// // // debugSimulationSettings.maxDRMIterations = 100000;
// debugSimulationSettings.shouldDraw = true;
// // debugSimulationSettings.drawingStep = debugSimulationSettings.debugModeStep;
// debugSimulationSettings.shouldCreatePlots = true;
// // // debugSimulationSettings.Dtini = 0.06;
// debugSimulationSettings.beVerbose = true;
// debugSimulationSettings.averageResidualForcesCriterionThreshold = 1e-5;
// debugSimulationSettings.maxDRMIterations = 100000;
// debugSimulationSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
// debugSimulationSettings.viscousDampingFactor = 1e-2;
// // // debugSimulationSettings.totalExternalForcesNormPercentageTermination = 1e-3;
// // // debugSimulationSettings.shouldUseTranslationalKineticEnergyThreshold = true;
// auto debugResults = simulator.executeSimulation(pFullPatternSimulationJob,
// debugSimulationSettings);
// debugResults.setLabelPrefix("debugResults");
// debugResults.registerForDrawing();
// polyscope::show();
// debugResults.unregister();
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("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); // drmSettings_secondTry.save(outputPath);
std::terminate();
return;
#endif #endif
// } //#ifdef POLYSCOPE_DEFINED
} // SimulationResults fullPatternResults_linear;
// if (drawFullPatternSimulationResults) {
// LinearSimulationModel linearSimulator;
// fullPatternResults_linear = linearSimulator.executeSimulation(
// pFullPatternSimulationJob);
// fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear.registerForDrawing(std::array<double, 3>{0, 0, 255},
// true);
// std::cout << pFullPatternSimulationJob->getLabel()
// << " did not converge on the first try. Trying again.." << std::endl;
// }
//#endif
DRMSimulationModel::Settings drmSettings_secondTry = drmSettings;
// drmSettings_secondTry.shouldDraw = true;
// drmSettings_secondTry.debugModeStep = 20000;
// drmSettings_secondTry.shouldCreatePlots = true;
// drmSettings_secondTry.beVerbose = true;
drmSettings_secondTry.linearGuessForceScaleFactor = 1;
drmSettings_secondTry.viscousDampingFactor = 4e-8;
*drmSettings_secondTry.maxDRMIterations *= 5;
drmSettings_secondTry.useTotalRotationalKineticEnergyForKineticDamping = true;
// drmSettings.totalTranslationalKineticEnergyThreshold = std::nullopt;
// drmSettings.totalExternalForcesNormPercentageTermination = 1e-3;
drmSettings.totalTranslationalKineticEnergyThreshold = 1e-10;
// drmSettings_secondTry.gamma = 2;
// drmSettings_secondTry.xi = 0.98;
SimulationResults drmResults_secondTry
= simulator.executeSimulation(pFullPatternSimulationJob, drmSettings_secondTry);
if (drmResults_secondTry.converged) {
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
if (drawFullPatternSimulationResults) { std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel()
// SimulationResults fullPatternResults_linear = linearSimulator.executeSimulation( << " converged after a second try." << std::endl;
// pFullPatternSimulationJob);
fullPatternResults.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed,
true);
// fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed,
// true,
// true);
polyscope::show();
fullPatternResults.unregister();
// fullPatternResults_linear.unregister();
}
#endif #endif
optimizationState.fullPatternResults[simulationScenarioIndex] = fullPatternResults; patternDrmResults = drmResults_secondTry;
} else {
results.wasSuccessful = false;
std::cerr << "Simulation job " << pFullPatternSimulationJob->getLabel()
<< " of pattern " << pFullPatternSimulationJob->pMesh->getLabel()
<< " did not converge." << std::endl;
#ifdef POLYSCOPE_DEFINED
std::filesystem::path outputPath(
std::filesystem::path("../nonConvergingJobs")
.append(m_pFullPatternSimulationMesh->getLabel())
.append("final_" + pFullPatternSimulationJob->getLabel()));
std::filesystem::create_directories(outputPath);
pFullPatternSimulationJob->save(outputPath);
drmSettings_secondTry.save(outputPath);
if (drawFullPatternSimulationResults) {
optimizationState.fullPatternSimulationJobs[0]->pMesh->registerForDrawing(
ReducedModelOptimization::Colors::fullInitial);
pFullPatternSimulationJob->registerForDrawing(
optimizationState.fullPatternSimulationJobs[0]->pMesh->getLabel(), true);
patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
// SimulationResults fullPatternResults_linear
// = linearSimulator.executeSimulation(pFullPatternSimulationJob);
// patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
// fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear
// .registerForDrawing(std::array<double, 3>{0, 0, 255}, true);
polyscope::show();
patternDrmResults.unregister();
// fullPatternResults_linear.unregister();
optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister();
}
#endif
return;
}
}
optimizationState.fullPatternResults[simulationScenarioIndex] = patternDrmResults;
SimulationJob reducedPatternSimulationJob; SimulationJob reducedPatternSimulationJob;
reducedPatternSimulationJob.pMesh = m_pReducedPatternSimulationMesh; reducedPatternSimulationJob.pMesh = m_pReducedPatternSimulationMesh;
computeReducedModelSimulationJob(*pFullPatternSimulationJob, computeReducedModelSimulationJob(*pFullPatternSimulationJob,
@ -2155,13 +2246,42 @@ void ReducedModelOptimizer::optimize(
reducedPatternSimulationJob); reducedPatternSimulationJob);
optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex] optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex]
= std::make_shared<SimulationJob>(reducedPatternSimulationJob); = std::make_shared<SimulationJob>(reducedPatternSimulationJob);
// std::cout << "Ran sim scenario:" << simulationScenarioIndex << std::endl; // std::cout << "Ran sim scenario:" << simulationScenarioIndex << std::endl;
#ifdef POLYSCOPE_DEFINED
if (drawFullPatternSimulationResults) {
optimizationState.fullPatternSimulationJobs[0]->pMesh->registerForDrawing(
ReducedModelOptimization::Colors::fullInitial);
pFullPatternSimulationJob->registerForDrawing(optimizationState
.fullPatternSimulationJobs[0]
->pMesh->getLabel(),
true);
patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
// SimulationResults fullPatternResults_linear
// = linearSimulator.executeSimulation(pFullPatternSimulationJob);
// patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
// fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear
// .registerForDrawing(std::array<double, 3>{0, 0, 255}, true);
polyscope::show();
patternDrmResults.unregister();
// fullPatternResults_linear.unregister();
optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister();
}
#endif
}); });
auto t2 = std::chrono::high_resolution_clock::now();
auto s_int = std::chrono::duration_cast<std::chrono::seconds>(t2 - t1);
std::cout << s_int.count() << std::endl;
results.wasSuccessful = false;
return;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << "Computed ground of truth pattern results in:" << s_int.count() << " seconds."
<< std::endl;
if (drawFullPatternSimulationResults) { if (drawFullPatternSimulationResults) {
optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister(); optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister();
} }
optimizationState.reducedPatternSimulationJobs[0]->pMesh->updateEigenEdgeAndVertices();
#endif #endif
// if (optimizationState.optimizationSettings.normalizationStrategy // if (optimizationState.optimizationSettings.normalizationStrategy
// == Settings::NormalizationStrategy::Epsilon) { // == Settings::NormalizationStrategy::Epsilon) {
@ -2171,5 +2291,4 @@ void ReducedModelOptimizer::optimize(
std::cout << "Running reduced model optimization" << std::endl; std::cout << "Running reduced model optimization" << std::endl;
#endif #endif
runOptimization(optimizationSettings, results); runOptimization(optimizationSettings, results);
results.notes = optimizationNotes;
} }

10
reducedmodeloptimizer.hpp
View File

@ -117,7 +117,7 @@ public:
inline static std::array<std::string, ReducedModelOptimization::NumberOfOptimizationVariables> inline static std::array<std::string, ReducedModelOptimization::NumberOfOptimizationVariables>
parameterLabels = {"E", "A", "I2", "I3", "J", "Theta", "R"}; parameterLabels = {"E", "A", "I2", "I3", "J", "Theta", "R"};
constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios> constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
simulationScenariosResolution = {11, 11, 21, 21, 21, 21}; simulationScenariosResolution = {12, 12, 22, 22, 22, 22};
constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios> constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
baseScenarioWeights = {1, 1, 2, 3, 2}; baseScenarioWeights = {1, 1, 2, 3, 2};
inline static int totalNumberOfSimulationScenarios inline static int totalNumberOfSimulationScenarios
@ -150,7 +150,7 @@ public:
std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh); std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh);
void computeMaps(const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode, void computeMaps(const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode,
PatternGeometry &fullPattern, PatternGeometry &fullPattern,
PatternGeometry &reducedPattern, ReducedModel &reducedPattern,
std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
&reducedToFullInterfaceViMap, &reducedToFullInterfaceViMap,
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex> std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
@ -263,7 +263,7 @@ public:
ReducedModelOptimization::Results optimize( ReducedModelOptimization::Results optimize(
ConstPatternGeometry &fullPattern, ConstPatternGeometry &fullPattern,
const ReducedModelOptimization::Settings &optimizatifullyonSettings); const ReducedModelOptimization::Settings &optimizationSettings);
void optimize(ConstPatternGeometry &fullPattern, void optimize(ConstPatternGeometry &fullPattern,
ReducedModelOptimization::Settings &optimizationSettings, ReducedModelOptimization::Settings &optimizationSettings,
@ -285,7 +285,7 @@ private:
ReducedModelOptimization::S})); ReducedModelOptimization::S}));
void initializePatterns(PatternGeometry &fullPattern, void initializePatterns(PatternGeometry &fullPattern,
PatternGeometry &reducedPattern, ReducedModel &reducedPattern,
const std::array<ReducedModelOptimization::xRange, const std::array<ReducedModelOptimization::xRange,
ReducedModelOptimization::NumberOfOptimizationVariables> ReducedModelOptimization::NumberOfOptimizationVariables>
&optimizationParameters); &optimizationParameters);
@ -295,7 +295,7 @@ private:
Eigen::MatrixX3d &optimalDisplacementsOfReducedModel); Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
void runOptimization(const ReducedModelOptimization::Settings &settings, void runOptimization(const ReducedModelOptimization::Settings &settings,
ReducedModelOptimization::Results &results); ReducedModelOptimization::Results &results);
void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern); void computeMaps(PatternGeometry &fullModel, ReducedModel &reducedModel);
void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel); void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
void initializeOptimizationParameters( void initializeOptimizationParameters(
const std::shared_ptr<SimulationMesh> &mesh, const std::shared_ptr<SimulationMesh> &mesh,