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

Chronos is being used for computing the ground truth of the pattern during the reduced model optimization

This commit is contained in:
iasonmanolas 2022-07-08 15:53:17 +03:00
parent 8a335411d9
commit 9d9f7dbacf
7 changed files with 252 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
chronoseulersimulationmodel.cpp
View File

@ -1,11 +1,17 @@
#include "chronoseulersimulationmodel.hpp" #include "chronoseulersimulationmodel.hpp"
#include "chrono/physics/ChLoadContainer.h"
#include <chrono/fea/ChBeamSectionEuler.h> #include <chrono/fea/ChBeamSectionEuler.h>
#include <chrono/fea/ChBuilderBeam.h> #include <chrono/fea/ChBuilderBeam.h>
#include <chrono/fea/ChLoadsBeam.h>
#include <chrono/fea/ChMesh.h> #include <chrono/fea/ChMesh.h>
#include <chrono/fea/ChNodeFEAxyzrot.h> #include <chrono/fea/ChNodeFEAxyzrot.h>
#include <chrono/physics/ChSystemSMC.h> #include <chrono/physics/ChSystemSMC.h>
#include <chrono/solver/ChIterativeSolverLS.h> #include <chrono/solver/ChIterativeSolverLS.h>
#include <chrono/assets/ChVisualization.h>
#include <chrono/fea/ChElementBeamEuler.h>
#include <chrono/fea/ChVisualizationFEAmesh.h>
using namespace chrono; using namespace chrono;
using namespace chrono::fea; using namespace chrono::fea;
std::shared_ptr<ChMesh> ChronosEulerSimulationModel::convertToChronosMesh_Euler( std::shared_ptr<ChMesh> ChronosEulerSimulationModel::convertToChronosMesh_Euler(
@ -19,9 +25,9 @@ std::shared_ptr<ChMesh> ChronosEulerSimulationModel::convertToChronosMesh_Euler(
//add nodes //add nodes
for (int vi = 0; vi < pMesh->VN(); vi++) { for (int vi = 0; vi < pMesh->VN(); vi++) {
const auto &vertex = pMesh->vert[vi]; const auto &vertex = pMesh->vert[vi];
edgeMeshVertsToChronosNodes[vi] = std::make_shared<ChNodeFEAxyzrot>( ChVector<> vertexPos(vertex.cP()[0], vertex.cP()[1], vertex.cP()[2]);
ChFrame<>(ChVector<>(vertex.cP()[0], vertex.cP()[1], vertex.cP()[2]), edgeMeshVertsToChronosNodes[vi] = chrono_types::make_shared<ChNodeFEAxyzrot>(
ChVector<>(0, 1, 0))); ChFrame<>(vertexPos));
mesh_chronos->AddNode(edgeMeshVertsToChronosNodes[vi]); mesh_chronos->AddNode(edgeMeshVertsToChronosNodes[vi]);
} }
//add elements //add elements
@ -36,19 +42,21 @@ std::shared_ptr<ChMesh> ChronosEulerSimulationModel::convertToChronosMesh_Euler(
const double beam_wz = element.dimensions.b; const double beam_wz = element.dimensions.b;
const double beam_wy = element.dimensions.h; const double beam_wy = element.dimensions.h;
const double E = element.material.youngsModulus; const double E = element.material.youngsModulus;
const double poisson = element.material.poissonsRatio; // const double poisson = element.material.poissonsRatio;
const double density = 1e4; const double density = 1e0;
auto msection = chrono_types::make_shared<ChBeamSectionEulerAdvanced>(); // auto msection = chrono_types::make_shared<ChBeamSectionEulerAdvanced>();
msection->SetDensity(density); auto msection = chrono_types::make_shared<ChBeamSectionEulerEasyRectangular>(
msection->SetYoungModulus(E); beam_wy, beam_wz, E, element.material.G, density);
msection->SetGwithPoissonRatio(poisson); // msection->SetDensity(density);
msection->SetBeamRaleyghDamping(0.0); // msection->SetYoungModulus(E);
msection->SetAsRectangularSection(beam_wy, beam_wz); // msection->SetGwithPoissonRatio(poisson);
// // msection->SetBeamRaleyghDamping(0.0);
// msection->SetAsRectangularSection(beam_wy, beam_wz);
builder builder
.BuildBeam(mesh_chronos, // the mesh where to put the created nodes and elements .BuildBeam(mesh_chronos, // the mesh where to put the created nodes and elements
msection, // the ChBeamSectionEuler to use for the ChElementBeamEuler elements msection, // the ChBeamSectionEuler to use for the ChElementBeamEuler elements
5, // the number of ChElementBeamEuler to create 1, // the number of ChElementBeamEuler to create
edgeMeshVertsToChronosNodes[vi0], // the 'A' point in space (beginning of beam) edgeMeshVertsToChronosNodes[vi0], // the 'A' point in space (beginning of beam)
edgeMeshVertsToChronosNodes[vi1], // the 'B' point in space (end of beam) edgeMeshVertsToChronosNodes[vi1], // the 'B' point in space (end of beam)
ChVector<>(0, 0, 1) ChVector<>(0, 0, 1)
@ -61,88 +69,153 @@ std::shared_ptr<ChMesh> ChronosEulerSimulationModel::convertToChronosMesh_Euler(
ChronosEulerSimulationModel::ChronosEulerSimulationModel() {} ChronosEulerSimulationModel::ChronosEulerSimulationModel() {}
SimulationResults ChronosEulerSimulationModel::executeSimulation( //SimulationResults ChronosEulerSimulationModel::executeSimulation(
const std::shared_ptr<SimulationJob> &pJob) // const std::shared_ptr<SimulationJob> &pJob)
//{}
//chrono::ChSystemSMC convertToChronosSystem(const std::shared_ptr<SimulationJob> &pJob)
//{
// chrono::ChSystemSMC my_system;
//}
void ChronosEulerSimulationModel::parseForces(
const std::shared_ptr<chrono::fea::ChMesh> &mesh_chronos,
const std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronoNodes,
const std::unordered_map<VertexIndex, Vector6d> &nodalExternalForces)
{ {
chrono::ChSystemSMC my_system; mesh_chronos->SetAutomaticGravity(false);
my_system.SetTimestepperType(chrono::ChTimestepper::Type::EULER_IMPLICIT_LINEARIZED); for (const std::pair<VertexIndex, Vector6d> &externalForce : nodalExternalForces) {
std::vector<std::shared_ptr<ChNodeFEAxyzrot>> edgeMeshVertsToChronosNodes; const int &forceVi = externalForce.first;
auto mesh_chronos = convertToChronosMesh_Euler(pJob->pMesh, edgeMeshVertsToChronosNodes); const Vector6d &force = externalForce.second;
// mesh_chronos->SetAutomaticGravity(false); edgeMeshVertsToChronoNodes[forceVi]->SetForce(ChVector<>(force[0], force[1], force[2]));
//parse constrained vertices edgeMeshVertsToChronoNodes[forceVi]->SetTorque(ChVector<>(force[3], force[4], force[5]));
}
}
void ChronosEulerSimulationModel::parseConstrainedVertices(
const std::shared_ptr<SimulationJob> &pJob,
const std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronoNodes,
chrono::ChSystemSMC &my_system)
{
assert(!edgeMeshVertsToChronoNodes.empty());
for (const std::pair<VertexIndex, std::unordered_set<int>> &constrainedVertex : for (const std::pair<VertexIndex, std::unordered_set<int>> &constrainedVertex :
pJob->constrainedVertices) { pJob->constrainedVertices) {
const int &constrainedVi = constrainedVertex.first; const int &constrainedVi = constrainedVertex.first;
const std::unordered_set<int> &constrainedDoF = constrainedVertex.second; const std::unordered_set<int> &constrainedDoF = constrainedVertex.second;
const bool vertexIsFullyConstrained = constrainedDoF.size() == 6 // Create a truss
&& constrainedDoF.contains(0) auto truss = chrono_types::make_shared<ChBody>();
&& constrainedDoF.contains(1) truss->SetBodyFixed(true);
&& constrainedDoF.contains(2) my_system.Add(truss);
&& constrainedDoF.contains(3) const auto &constrainedChronoNode = edgeMeshVertsToChronoNodes[constrainedVi];
&& constrainedDoF.contains(4) // Create a constraint at the end of the beam
&& constrainedDoF.contains(5); auto constr_a = chrono_types::make_shared<ChLinkMateGeneric>();
if (vertexIsFullyConstrained) { constr_a->SetConstrainedCoords(constrainedDoF.contains(0),
edgeMeshVertsToChronosNodes[constrainedVi]->SetFixed(true); constrainedDoF.contains(1),
} else { constrainedDoF.contains(2),
std::cerr << "Currently only rigid vertices are handled." << std::endl; constrainedDoF.contains(3),
SimulationResults simulationResults; constrainedDoF.contains(4),
simulationResults.converged = false; constrainedDoF.contains(5));
assert(false); constr_a->Initialize(constrainedChronoNode,
return simulationResults; truss,
} false,
constrainedChronoNode->Frame(),
constrainedChronoNode->Frame());
// const auto frameNode = constrainedChronoNode->Frame();
my_system.Add(constr_a);
// edgeMeshVertsToChronoNodes[constrainedVi]->SetFixed(true);
// if (vertexIsFullyConstrained) {
// } else {
// std::cerr << "Currently only rigid vertices are handled." << std::endl;
// // SimulationResults simulationResults;
// // simulationResults.converged = false;
// // assert(false);
// // return simulationResults;
// }
} }
}
SimulationResults ChronosEulerSimulationModel::executeSimulation(
const std::shared_ptr<SimulationJob> &pJob)
{
assert(pJob->pMesh->VN() != 0);
const bool structureInitialized = mesh_chronos != nullptr;
const bool wasInitializedWithDifferentStructure = structureInitialized
&& (pJob->pMesh->EN()
!= mesh_chronos->GetNelements()
|| pJob->pMesh->VN()
!= mesh_chronos->GetNnodes());
if (!structureInitialized || wasInitializedWithDifferentStructure) {
setStructure(pJob->pMesh);
}
chrono::ChSystemSMC my_system;
// chrono::irrlicht::ChIrrApp application(&my_system,
// L"Irrlicht FEM visualization",
// irr::core::dimension2d<irr::u32>(800, 600),
// chrono::irrlicht::VerticalDir::Z,
// false,
// true);
// const std::string chronoDataFolderPath = "/home/iason/Coding/build/external "
// "dependencies/CHRONO-src/data/";
// application.AddTypicalLogo(chronoDataFolderPath + "logo_chronoengine_alpha.png");
// application.AddTypicalSky(chronoDataFolderPath + "skybox/");
// application.AddTypicalLights();
// application.AddTypicalCamera(irr::core::vector3df(0, (irr::f32) 0.6, -1));
// my_system.SetTimestepperType(chrono::ChTimestepper::Type::EULER_IMPLICIT_LINEARIZED);
//parse forces
parseForces(mesh_chronos, edgeMeshVertsToChronoNodes, pJob->nodalExternalForces);
//parse constrained vertices
parseConstrainedVertices(pJob, edgeMeshVertsToChronoNodes, my_system);
// std::dynamic_pointer_cast<std::shared_ptr<ChNodeFEAxyzrot>>(mesh_chronos->GetNode(1)) // std::dynamic_pointer_cast<std::shared_ptr<ChNodeFEAxyzrot>>(mesh_chronos->GetNode(1))
// ->SetFixed(true); // ->SetFixed(true);
//parse external forces // and load containers must be added to your system
for (const std::pair<VertexIndex, Vector6d> &externalForce : pJob->nodalExternalForces) { // auto mvisualizemesh = chrono_types::make_shared<ChVisualizationFEAmesh>(*(mesh_chronos.get()));
const int &forceVi = externalForce.first; // mvisualizemesh->SetFEMdataType(ChVisualizationFEAmesh::E_PLOT_NODE_DISP_NORM);
const Vector6d &force = externalForce.second; // mvisualizemesh->SetColorscaleMinMax(0.0, 5.50);
if (Eigen::Vector3d(force[3], force[4], force[5]).norm() > 1e-10) { // mvisualizemesh->SetShrinkElements(false, 0.85);
std::cerr << "Moments are currently not supported." << std::endl; // mvisualizemesh->SetSmoothFaces(false);
SimulationResults simulationResults; // mesh_chronos->AddAsset(mvisualizemesh);
simulationResults.converged = false;
assert(false);
return simulationResults;
} else {
edgeMeshVertsToChronosNodes[forceVi]->SetForce(ChVector<>(force[0], force[1], force[2]));
}
}
// edgeMeshVertsToChronosNodes[0]->SetFixed(true);
// edgeMeshVertsToChronosNodes[1]->SetForce(ChVector<>(1e-10, 0, 0));
// edgeMeshVertsToChronosNodes[0]->SetFixed(true);
// builder.GetLastBeamNodes().front()->SetFixed(true);
// builder.GetLastBeamNodes().back()->SetForce(ChVector<>(0, 0, 1e1));
// edgeMeshVertsToChronosNodes[3]->SetFixed(true);
// edgeMeshVertsToChronosNodes[7]->SetFixed(true);
// edgeMeshVertsToChronosNodes[11]->SetFixed(true);
// edgeMeshVertsToChronosNodes[15]->SetForce(ChVector<>(0.0, 0, 1e-1));
// edgeMeshVertsToChronosNodes[19]->SetForce(ChVector<>(0.0, 0, 1e-1));
// edgeMeshVertsToChronosNodes[23]->SetForce(ChVector<>(0.0, 0, 1e-1));
// builder.GetLastBeamNodes().back()->SetForce(ChVector<>(0.0, 1e2, 0.0));
// application.AssetBindAll();
// application.AssetUpdateAll();
my_system.Add(mesh_chronos); my_system.Add(mesh_chronos);
auto solver = chrono_types::make_shared<ChSolverMINRES>(); auto solver = chrono_types::make_shared<ChSolverMINRES>();
solver->SetMaxIterations(5000);
solver->SetTolerance(1e-10);
solver->EnableDiagonalPreconditioner(true);
solver->SetVerbose(true);
my_system.SetSolver(solver); my_system.SetSolver(solver);
// solver->SetMaxIterations(100);
// solver->SetTolerance(1e-8);
solver->EnableWarmStart(true); // IMPORTANT for convergence when using EULER_IMPLICIT_LINEARIZED
solver->EnableDiagonalPreconditioner(true);
my_system.SetSolverForceTolerance(1e-6);
solver->SetVerbose(false);
SimulationResults simulationResults; SimulationResults simulationResults;
simulationResults.converged = my_system.DoStaticNonlinear(); simulationResults.converged = my_system.DoStaticNonlinear();
// simulationResults.converged = my_system.DoStaticLinear();
if (!simulationResults.converged) { if (!simulationResults.converged) {
std::cerr << "Simulation failed" << std::endl; std::cerr << "Simulation failed" << std::endl;
assert(false); assert(false);
return simulationResults; return simulationResults;
} }
// my_system.DoStaticLinear();
// my_system.SetTimestepperType(ChTimestepper::Type::EULER_IMPLICIT_LINEARIZED);
// application.SetTimestep(0.001);
// while (application.GetDevice()->run()) {
// application.BeginScene();
// application.DrawAll();
// application.EndScene();
// }
simulationResults.pJob = pJob; simulationResults.pJob = pJob;
simulationResults.displacements.resize(pJob->pMesh->VN()); simulationResults.displacements.resize(pJob->pMesh->VN());
simulationResults.rotationalDisplacementQuaternion.resize(pJob->pMesh->VN()); simulationResults.rotationalDisplacementQuaternion.resize(pJob->pMesh->VN());
for (size_t vi = 0; vi < pJob->pMesh->VN(); vi++) { for (size_t vi = 0; vi < pJob->pMesh->VN(); vi++) {
std::shared_ptr<ChNodeFEAxyzrot> node_chronos = edgeMeshVertsToChronosNodes[vi]; const auto node_chronos = edgeMeshVertsToChronoNodes[vi];
const auto posDisplacement = node_chronos->GetPos() - node_chronos->GetX0().GetPos(); const auto posDisplacement = node_chronos->Frame().GetPos()
- node_chronos->GetX0().GetPos();
// std::cout << "Node " << vi << " coordinate x= " << node_chronos->Frame().GetPos().x()
// << " y=" << node_chronos->Frame().GetPos().y()
// << " z=" << node_chronos->Frame().GetPos().z() << "\n";
//Translations //Translations
simulationResults.displacements[vi][0] = posDisplacement[0]; simulationResults.displacements[vi][0] = posDisplacement[0];
simulationResults.displacements[vi][1] = posDisplacement[1]; simulationResults.displacements[vi][1] = posDisplacement[1];
@ -152,10 +225,13 @@ SimulationResults ChronosEulerSimulationModel::executeSimulation(
simulationResults.rotationalDisplacementQuaternion[vi] simulationResults.rotationalDisplacementQuaternion[vi]
= Eigen::Quaternion<double>(rotQuat.e0(), rotQuat.e1(), rotQuat.e2(), rotQuat.e3()); = Eigen::Quaternion<double>(rotQuat.e0(), rotQuat.e1(), rotQuat.e2(), rotQuat.e3());
const ChVector<double> eulerAngles = rotQuat.Q_to_Euler123(); const ChVector<double> eulerAngles = rotQuat.Q_to_Euler123();
// std::cout << "Euler angles:" << eulerAngles << std::endl;
simulationResults.displacements[vi][3] = eulerAngles[0]; simulationResults.displacements[vi][3] = eulerAngles[0];
simulationResults.displacements[vi][4] = eulerAngles[1]; simulationResults.displacements[vi][4] = eulerAngles[1];
simulationResults.displacements[vi][5] = eulerAngles[2]; simulationResults.displacements[vi][5] = eulerAngles[2];
} }
simulationResults.setLabelPrefix("chronos");
return simulationResults; return simulationResults;
// VCGEdgeMesh deformedMesh; // VCGEdgeMesh deformedMesh;
@ -173,3 +249,8 @@ SimulationResults ChronosEulerSimulationModel::executeSimulation(
// polyscope::show(); // polyscope::show();
// return simulationResults; // return simulationResults;
} }
void ChronosEulerSimulationModel::setStructure(const std::shared_ptr<SimulationMesh> &pMesh)
{
mesh_chronos = convertToChronosMesh_Euler(pMesh, edgeMeshVertsToChronoNodes);
}

15
chronoseulersimulationmodel.hpp
View File

@ -4,6 +4,7 @@
#include "simulationmodel.hpp" #include "simulationmodel.hpp"
namespace chrono { namespace chrono {
class ChSystemSMC;
namespace fea { namespace fea {
class ChMesh; class ChMesh;
class ChNodeFEAxyzrot; class ChNodeFEAxyzrot;
@ -12,12 +13,26 @@ class ChNodeFEAxyzrot;
class ChronosEulerSimulationModel : public SimulationModel class ChronosEulerSimulationModel : public SimulationModel
{ {
std::shared_ptr<chrono::fea::ChMesh> mesh_chronos;
std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> edgeMeshVertsToChronoNodes;
public: public:
ChronosEulerSimulationModel(); ChronosEulerSimulationModel();
SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &pJob) override; SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &pJob) override;
void setStructure(const std::shared_ptr<SimulationMesh> &pMesh) override;
static std::shared_ptr<chrono::fea::ChMesh> convertToChronosMesh_Euler( static std::shared_ptr<chrono::fea::ChMesh> convertToChronosMesh_Euler(
const std::shared_ptr<SimulationMesh> &pMesh, const std::shared_ptr<SimulationMesh> &pMesh,
std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronosNodes); std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronosNodes);
private:
static void parseConstrainedVertices(
const std::shared_ptr<SimulationJob> &pJob,
const std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronoNodes,
chrono::ChSystemSMC &my_system);
static void parseForces(
const std::shared_ptr<chrono::fea::ChMesh> &mesh_chronos,
const std::vector<std::shared_ptr<chrono::fea::ChNodeFEAxyzrot>> &edgeMeshVertsToChronoNodes,
const std::unordered_map<VertexIndex, Vector6d> &nodalExternalForces);
}; };
#endif // CHRONOSEULERSIMULATIONMODEL_HPP #endif // CHRONOSEULERSIMULATIONMODEL_HPP

8
drmsimulationmodel.cpp
View File

@ -3006,6 +3006,14 @@ currentSimulationStep > maxDRMIterations*/
#endif #endif
return results; return results;
} }
void DRMSimulationModel::setStructure(const std::shared_ptr<SimulationMesh> &pMesh)
{
std::cout << "This function is currently not implemented" << std::endl;
assert(false);
std::terminate();
}
SimulationResults DRMSimulationModel::executeSimulation(const std::shared_ptr<SimulationJob> &pJob, SimulationResults DRMSimulationModel::executeSimulation(const std::shared_ptr<SimulationJob> &pJob,
const Settings &settings, const Settings &settings,
const SimulationResults &solutionGuess) const SimulationResults &solutionGuess)

3
drmsimulationmodel.hpp
View File

@ -251,7 +251,8 @@ private:
void applyKineticDamping(const std::shared_ptr<SimulationJob> &pJob); void applyKineticDamping(const std::shared_ptr<SimulationJob> &pJob);
virtual SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &pJob); virtual SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &pJob) override;
void setStructure(const std::shared_ptr<SimulationMesh> &pMesh) override;
void reset(const std::shared_ptr<SimulationJob> &pJob); void reset(const std::shared_ptr<SimulationJob> &pJob);

240
reducedmodeloptimizer.cpp
View File

@ -222,6 +222,7 @@ double ReducedModelOptimizer::objective(const std::vector<double> &x,
// run simulations // run simulations
std::vector<double> simulationErrorsPerScenario(totalNumberOfSimulationScenarios, 0); std::vector<double> simulationErrorsPerScenario(totalNumberOfSimulationScenarios, 0);
// ChronosEulerSimulationModel simulator;
LinearSimulationModel simulator; LinearSimulationModel simulator;
simulator.setStructure(pReducedPatternSimulationMesh); simulator.setStructure(pReducedPatternSimulationMesh);
// simulator.initialize(); // simulator.initialize();
@ -389,7 +390,7 @@ void ReducedModelOptimizer::createSimulationMeshes(PatternGeometry &fullModel,
ReducedModelOptimizer::createSimulationMeshes(fullModel, ReducedModelOptimizer::createSimulationMeshes(fullModel,
reducedModel, reducedModel,
m_pFullPatternSimulationMesh, m_pFullPatternSimulationMesh,
m_pReducedPatternSimulationMesh); m_pReducedModelSimulationMesh);
} }
void ReducedModelOptimizer::computeMaps( void ReducedModelOptimizer::computeMaps(
@ -833,7 +834,7 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
optimizationState.functions_updateReducedPatternParameter[optimizationParameterIndex]( optimizationState.functions_updateReducedPatternParameter[optimizationParameterIndex](
results.optimalXNameValuePairs[optimizationParameterIndex].second, results.optimalXNameValuePairs[optimizationParameterIndex].second,
m_pReducedPatternSimulationMesh); //NOTE:due to this call this function is not const m_pReducedModelSimulationMesh); //NOTE:due to this call this function is not const
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << results.optimalXNameValuePairs[optimizationParameterIndex].first << ":" std::cout << results.optimalXNameValuePairs[optimizationParameterIndex].first << ":"
<< results.optimalXNameValuePairs[optimizationParameterIndex].second << " "; << results.optimalXNameValuePairs[optimizationParameterIndex].second << " ";
@ -841,15 +842,14 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
} }
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
std::cout << std::endl; std::cout << std::endl;
m_pReducedPatternSimulationMesh->updateEigenEdgeAndVertices(); m_pReducedModelSimulationMesh->updateEigenEdgeAndVertices();
#endif #endif
m_pReducedPatternSimulationMesh->reset(); m_pReducedModelSimulationMesh->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);
// results.objectiveValue.totalPerSimulationScenario.resize(totalNumberOfSimulationScenarios); // results.objectiveValue.totalPerSimulationScenario.resize(totalNumberOfSimulationScenarios);
//TODO:use push_back it will make the code more readable //TODO:use push_back it will make the code more readable
LinearSimulationModel simulator;
results.objectiveValue.totalRaw = 0; results.objectiveValue.totalRaw = 0;
results.objectiveValue.perSimulationScenario_translational.resize( results.objectiveValue.perSimulationScenario_translational.resize(
optimizationState.simulationScenarioIndices.size()); optimizationState.simulationScenarioIndices.size());
@ -869,11 +869,12 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
results.perScenario_fullPatternPotentialEnergy.resize( results.perScenario_fullPatternPotentialEnergy.resize(
optimizationState.simulationScenarioIndices.size()); optimizationState.simulationScenarioIndices.size());
reducedModelSimulator.setStructure(m_pReducedModelSimulationMesh);
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];
std::shared_ptr<SimulationJob> &pReducedJob std::shared_ptr<SimulationJob> &pReducedJob
= optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex]; = optimizationState.reducedPatternSimulationJobs[simulationScenarioIndex];
SimulationResults reducedModelResults = simulator.executeSimulation(pReducedJob); SimulationResults reducedModelResults = reducedModelSimulator.executeSimulation(pReducedJob);
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
#ifdef USE_SCENARIO_WEIGHTS #ifdef USE_SCENARIO_WEIGHTS
@ -973,7 +974,7 @@ void ReducedModelOptimizer::getResults(const FunctionEvaluation &optimalObjectiv
reducedModelResults.registerForDrawing(Colors::reducedDeformed); reducedModelResults.registerForDrawing(Colors::reducedDeformed);
optimizationState.fullPatternResults[simulationScenarioIndex].registerForDrawing( optimizationState.fullPatternResults[simulationScenarioIndex].registerForDrawing(
Colors::fullDeformed); Colors::patternDeformed);
polyscope::show(); polyscope::show();
reducedModelResults.unregister(); reducedModelResults.unregister();
optimizationState.fullPatternResults[simulationScenarioIndex].unregister(); optimizationState.fullPatternResults[simulationScenarioIndex].unregister();
@ -1362,6 +1363,7 @@ void ReducedModelOptimizer::constructSSimulationScenario(
* forceMagnitude; * forceMagnitude;
} }
} }
job.label = "Axial";
} }
void ReducedModelOptimizer::constructShearSimulationScenario( void ReducedModelOptimizer::constructShearSimulationScenario(
@ -1382,6 +1384,7 @@ void ReducedModelOptimizer::constructShearSimulationScenario(
job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5}; job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5};
} }
} }
job.label = "Shear";
} }
void ReducedModelOptimizer::constructBendingSimulationScenario( void ReducedModelOptimizer::constructBendingSimulationScenario(
@ -1394,6 +1397,7 @@ void ReducedModelOptimizer::constructBendingSimulationScenario(
job.nodalExternalForces[viPair.first] = Vector6d({0, 0, 1, 0, 0, 0}) * forceMagnitude; job.nodalExternalForces[viPair.first] = Vector6d({0, 0, 1, 0, 0, 0}) * forceMagnitude;
job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5}; job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5};
} }
job.label = "Bending";
} }
/*NOTE: From the results it seems as if the forced displacements are different in the linear and in the drm /*NOTE: From the results it seems as if the forced displacements are different in the linear and in the drm
@ -1454,6 +1458,7 @@ void ReducedModelOptimizer::constructDomeSimulationScenario(
job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{0, 1, 2}; job.constrainedVertices[viPair.first] = std::unordered_set<DoFType>{0, 1, 2};
job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{2}; job.constrainedVertices[viPair.second] = std::unordered_set<DoFType>{2};
} }
job.label = "Dome";
} }
void ReducedModelOptimizer::constructSaddleSimulationScenario( void ReducedModelOptimizer::constructSaddleSimulationScenario(
@ -1483,6 +1488,7 @@ void ReducedModelOptimizer::constructSaddleSimulationScenario(
* forceMagnitude / 2; * forceMagnitude / 2;
} }
} }
job.label = "Saddle";
} }
double fullPatternMaxSimulationForceRotationalObjective(const double &forceMagnitude) double fullPatternMaxSimulationForceRotationalObjective(const double &forceMagnitude)
@ -1497,18 +1503,20 @@ double fullPatternMaxSimulationForceRotationalObjective(const double &forceMagni
// optimizationState.fullPatternInterfaceViPairs, // optimizationState.fullPatternInterfaceViPairs,
// job); // job);
DRMSimulationModel simulator; ChronosEulerSimulationModel simulator;
DRMSimulationModel::Settings settings; SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job));
// settings.totalExternalForcesNormPercentageTermination = 1e-2; // DRMSimulationModel simulator;
settings.totalTranslationalKineticEnergyThreshold = 1e-10; // DRMSimulationModel::Settings settings;
// settings.viscousDampingFactor = 1e-2; // // settings.totalExternalForcesNormPercentageTermination = 1e-2;
// settings.useKineticDamping = true; // settings.totalTranslationalKineticEnergyThreshold = 1e-10;
settings.shouldDraw = false; // // settings.viscousDampingFactor = 1e-2;
settings.debugModeStep = 200; // // settings.useKineticDamping = true;
// settings.averageResidualForcesCriterionThreshold = 1e-5; // settings.shouldDraw = false;
settings.maxDRMIterations = 200000; // settings.debugModeStep = 200;
SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job), // // settings.averageResidualForcesCriterionThreshold = 1e-5;
settings); // settings.maxDRMIterations = 200000;
// SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job),
// settings);
const double &desiredRotationAngle const double &desiredRotationAngle
= g_baseScenarioMaxDisplacementHelperData = g_baseScenarioMaxDisplacementHelperData
.desiredMaxRotationAngle; //TODO: move from OptimizationState to a new struct .desiredMaxRotationAngle; //TODO: move from OptimizationState to a new struct
@ -1599,25 +1607,28 @@ double fullPatternMaxSimulationForceTranslationalObjective(const double &forceMa
// optimizationState.fullPatternInterfaceViPairs, // optimizationState.fullPatternInterfaceViPairs,
// job); // job);
DRMSimulationModel simulator; ChronosEulerSimulationModel simulator;
DRMSimulationModel::Settings settings; SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job));
// settings.totalResidualForcesNormThreshold = 1e-3;
settings.totalExternalForcesNormPercentageTermination = 1e-2; // DRMSimulationModel simulator;
settings.totalTranslationalKineticEnergyThreshold = 1e-8; // DRMSimulationModel::Settings settings;
settings.viscousDampingFactor = 5e-3; // // settings.totalResidualForcesNormThreshold = 1e-3;
settings.useTranslationalKineticEnergyForKineticDamping = true; // settings.totalExternalForcesNormPercentageTermination = 1e-2;
// settings.averageResidualForcesCriterionThreshold = 1e-5; // settings.totalTranslationalKineticEnergyThreshold = 1e-8;
// settings.useAverage = true; // settings.viscousDampingFactor = 5e-3;
// settings.totalTranslationalKineticEnergyThreshold = 1e-10; // settings.useTranslationalKineticEnergyForKineticDamping = true;
// settings.shouldUseTranslationalKineticEnergyThreshold = true; // // settings.averageResidualForcesCriterionThreshold = 1e-5;
// settings.shouldDraw = true; // // settings.useAverage = true;
// settings.isDebugMode = true; // // settings.totalTranslationalKineticEnergyThreshold = 1e-10;
// settings.drawingStep = 200000; // // settings.shouldUseTranslationalKineticEnergyThreshold = true;
// settings.beVerbose = true; // // settings.shouldDraw = true;
// settings.debugModeStep = 200; // // settings.isDebugMode = true;
settings.maxDRMIterations = 200000; // // settings.drawingStep = 200000;
SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job), // // settings.beVerbose = true;
settings); // // settings.debugModeStep = 200;
// settings.maxDRMIterations = 200000;
// SimulationResults results = simulator.executeSimulation(std::make_shared<SimulationJob>(job),
// settings);
const double &desiredDisplacementValue const double &desiredDisplacementValue
= g_baseScenarioMaxDisplacementHelperData = g_baseScenarioMaxDisplacementHelperData
.desiredMaxDisplacementValue; //TODO: move from OptimizationState to a new struct .desiredMaxDisplacementValue; //TODO: move from OptimizationState to a new struct
@ -1630,7 +1641,6 @@ double fullPatternMaxSimulationForceTranslationalObjective(const double &forceMa
.append("mag_" + g_baseScenarioMaxDisplacementHelperData.currentScenarioName)); .append("mag_" + g_baseScenarioMaxDisplacementHelperData.currentScenarioName));
std::filesystem::create_directories(outputPath); std::filesystem::create_directories(outputPath);
job.save(outputPath); job.save(outputPath);
settings.save(outputPath);
// std::terminate(); // std::terminate();
} else { } else {
error = std::abs(results error = std::abs(results
@ -2049,11 +2059,13 @@ void ReducedModelOptimizer::optimize(
results.baseTriangle = baseTriangle; results.baseTriangle = baseTriangle;
DRMSimulationModel::Settings drmSettings; // DRMSimulationModel::Settings drmSettings;
drmSettings.totalExternalForcesNormPercentageTermination = 1e-5; // drmSettings.totalExternalForcesNormPercentageTermination = 1e-5;
drmSettings.maxDRMIterations = 200000; // drmSettings.maxDRMIterations = 200000;
// drmSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
// drmSettings.totalTranslationalKineticEnergyThreshold = 1e-9;
// drmSettings.totalTranslationalKineticEnergyThreshold = 1e-10; // drmSettings.totalTranslationalKineticEnergyThreshold = 1e-10;
drmSettings.totalTranslationalKineticEnergyThreshold = 1e-9;
// drmSettings.gradualForcedDisplacementSteps = 20; // drmSettings.gradualForcedDisplacementSteps = 20;
// drmSettings.linearGuessForceScaleFactor = 1; // drmSettings.linearGuessForceScaleFactor = 1;
// drmSettings.viscousDampingFactor = 5e-3; // drmSettings.viscousDampingFactor = 5e-3;
@ -2061,7 +2073,6 @@ void ReducedModelOptimizer::optimize(
// drmSettings.shouldDraw = true; // drmSettings.shouldDraw = true;
// drmSettings.totalExternalForcesNormPercentageTermination = 1e-2; // drmSettings.totalExternalForcesNormPercentageTermination = 1e-2;
drmSettings.totalTranslationalKineticEnergyThreshold = 1e-8;
// drmSettings.viscousDampingFactor = 5e-3; // drmSettings.viscousDampingFactor = 5e-3;
// simulationSettings.viscousDampingFactor = 5e-3; // simulationSettings.viscousDampingFactor = 5e-3;
// simulationSettings.linearGuessForceScaleFactor = 1; // simulationSettings.linearGuessForceScaleFactor = 1;
@ -2109,152 +2120,44 @@ void ReducedModelOptimizer::optimize(
.append("FullPatternResults") .append("FullPatternResults")
.append(m_pFullPatternSimulationMesh->getLabel()) .append(m_pFullPatternSimulationMesh->getLabel())
.append(pFullPatternSimulationJob->getLabel())); .append(pFullPatternSimulationJob->getLabel()));
// .append(pFullPatternSimulationJob->getLabel() + ".json")
//#ifdef POLYSCOPE_DEFINED
// constexpr bool recomputeFullPatternResults = true;
//#else
// constexpr bool recomputeFullPatternResults = true;
//#endif
SimulationResults patternDrmResults;
// if (!recomputeFullPatternResults && std::filesystem::exists(jobResultsDirectoryPath)) {
// fullPatternResults
// .load(std::filesystem::path(jobResultsDirectoryPath).append("Results"),
// pFullPatternSimulationJob);
// } else {
// const bool fullPatternScenarioMagnitudesExist = std::filesystem::exists(
// patternMaxForceMagnitudesFilePath);
// if (fullPatternScenarioMagnitudesExist) {
// nlohmann::json json;
// std::ifstream ifs(patternMaxForceMagnitudesFilePath.string());
// ifs >> json;
// fullPatternSimulationScenarioMaxMagnitudes
// = static_cast<std::vector<std::pair<BaseSimulationScenario, double>>>(
// json.at("maxMagn"));
// const bool shouldRecompute = fullPatternSimulationScenarioMaxMagnitudes.size()
// != desiredBaseSimulationScenarioIndices.size();
// if (!shouldRecompute) {
// return fullPatternSimulationScenarioMaxMagnitudes;
// }
// }
//#ifdef POLYSCOPE_DEFINED
// LinearSimulationModel linearSimulator;
// SimulationResults fullPatternResults = linearSimulator.executeSimulation(
// pFullPatternSimulationJob);
//#else ChronosEulerSimulationModel patternSimulator;
DRMSimulationModel simulator; patternSimulator.setStructure(m_pFullPatternSimulationMesh);
patternDrmResults = simulator.executeSimulation(pFullPatternSimulationJob, drmSettings); SimulationResults results = patternSimulator.executeSimulation(
// fullPatternResults.save(jobResultsDirectoryPath); pFullPatternSimulationJob);
// }
//#endif
// 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);
if (!patternDrmResults.converged) { if (!results.converged) {
#ifdef POLYSCOPE_DEFINED //#ifdef POLYSCOPE_DEFINED
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);
// drmSettings_secondTry.save(outputPath); std::cerr << m_pFullPatternSimulationMesh->getLabel() << " did not converge."
#endif << std::endl;
//#ifdef POLYSCOPE_DEFINED assert(false);
// 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 //#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
std::cout << "Simulation job " << pFullPatternSimulationJob->getLabel()
<< " converged after a second try." << std::endl;
#endif
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; optimizationState.fullPatternResults[simulationScenarioIndex] = results;
SimulationJob reducedPatternSimulationJob; SimulationJob reducedPatternSimulationJob;
reducedPatternSimulationJob.pMesh = m_pReducedPatternSimulationMesh; reducedPatternSimulationJob.pMesh = m_pReducedModelSimulationMesh;
computeReducedModelSimulationJob(*pFullPatternSimulationJob, computeReducedModelSimulationJob(*pFullPatternSimulationJob,
m_fullToReducedInterfaceViMap, m_fullToReducedInterfaceViMap,
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 #ifdef POLYSCOPE_DEFINED
if (drawFullPatternSimulationResults) { if (drawFullPatternSimulationResults) {
optimizationState.fullPatternSimulationJobs[0]->pMesh->registerForDrawing( optimizationState.fullPatternSimulationJobs[0]->pMesh->registerForDrawing(
ReducedModelOptimization::Colors::fullInitial); ReducedModelOptimization::Colors::patternInitial);
pFullPatternSimulationJob->registerForDrawing(optimizationState pFullPatternSimulationJob->registerForDrawing(optimizationState
.fullPatternSimulationJobs[0] .fullPatternSimulationJobs[0]
->pMesh->getLabel(), ->pMesh->getLabel(),
true); true);
patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true); results.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
// SimulationResults fullPatternResults_linear // SimulationResults fullPatternResults_linear
// = linearSimulator.executeSimulation(pFullPatternSimulationJob); // = linearSimulator.executeSimulation(pFullPatternSimulationJob);
// patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true); // patternDrmResults.registerForDrawing(std::array<double, 3>{0, 255, 0}, true);
@ -2262,7 +2165,7 @@ void ReducedModelOptimizer::optimize(
// fullPatternResults_linear // fullPatternResults_linear
// .registerForDrawing(std::array<double, 3>{0, 0, 255}, true); // .registerForDrawing(std::array<double, 3>{0, 0, 255}, true);
polyscope::show(); polyscope::show();
patternDrmResults.unregister(); results.unregister();
// fullPatternResults_linear.unregister(); // fullPatternResults_linear.unregister();
optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister(); optimizationState.fullPatternSimulationJobs[0]->pMesh->unregister();
} }
@ -2271,9 +2174,6 @@ void ReducedModelOptimizer::optimize(
auto t2 = std::chrono::high_resolution_clock::now(); auto t2 = std::chrono::high_resolution_clock::now();
auto s_int = std::chrono::duration_cast<std::chrono::seconds>(t2 - t1); 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::cout << "Computed ground of truth pattern results in:" << s_int.count() << " seconds."
<< std::endl; << std::endl;

8
reducedmodeloptimizer.hpp
View File

@ -1,6 +1,7 @@
#ifndef REDUCEDMODELOPTIMIZER_HPP #ifndef REDUCEDMODELOPTIMIZER_HPP
#define REDUCEDMODELOPTIMIZER_HPP #define REDUCEDMODELOPTIMIZER_HPP
#include "chronoseulersimulationmodel.hpp"
#include "csvfile.hpp" #include "csvfile.hpp"
#include "drmsimulationmodel.hpp" #include "drmsimulationmodel.hpp"
#include "edgemesh.hpp" #include "edgemesh.hpp"
@ -71,7 +72,7 @@ private:
const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>> &, const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>> &,
SimulationJob &)> SimulationJob &)>
constructScenarioFunction; constructScenarioFunction;
std::shared_ptr<SimulationMesh> m_pReducedPatternSimulationMesh; std::shared_ptr<SimulationMesh> m_pReducedModelSimulationMesh;
std::shared_ptr<SimulationMesh> m_pFullPatternSimulationMesh; std::shared_ptr<SimulationMesh> m_pFullPatternSimulationMesh;
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex> std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
m_fullToReducedInterfaceViMap; m_fullToReducedInterfaceViMap;
@ -119,7 +120,7 @@ public:
constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios> constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
simulationScenariosResolution = {12, 12, 22, 22, 22, 22}; 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, 2, 2};
inline static int totalNumberOfSimulationScenarios inline static int totalNumberOfSimulationScenarios
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.end(), simulationScenariosResolution.end(),
@ -303,7 +304,8 @@ private:
ReducedModelOptimization::NumberOfOptimizationVariables> ReducedModelOptimization::NumberOfOptimizationVariables>
&optimizationParamters); &optimizationParamters);
DRMSimulationModel simulator; ChronosEulerSimulationModel patternSimulator;
LinearSimulationModel reducedModelSimulator;
void computeObjectiveValueNormalizationFactors( void computeObjectiveValueNormalizationFactors(
const ReducedModelOptimization::Settings &optimizationSettings); const ReducedModelOptimization::Settings &optimizationSettings);

1
simulationmodel.hpp
View File

@ -8,6 +8,7 @@ class SimulationModel
public: public:
virtual SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &simulationJob) virtual SimulationResults executeSimulation(const std::shared_ptr<SimulationJob> &simulationJob)
= 0; = 0;
virtual void setStructure(const std::shared_ptr<SimulationMesh> &pMesh) = 0;
}; };
#endif // SIMULATIONMODEL_HPP #endif // SIMULATIONMODEL_HPP