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

Refactoring.Addded multiple simulation scenarios

This commit is contained in:
iasonmanolas 2021-04-08 20:55:56 +03:00
parent 49494ccef8
commit b54662be9e
3 changed files with 387 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/main.cpp
View File

@ -40,21 +40,21 @@ int main(int argc, char *argv[]) {
reducedPattern.scale(0.03, interfaceNodeIndex); reducedPattern.scale(0.03, interfaceNodeIndex);
// Set the optization settings // Set the optization settings
ReducedModelOptimization::xRange beamE{"E", 0.001, 1000}; ReducedPatternOptimization::xRange beamE{"E", 0.001, 1000};
ReducedModelOptimization::xRange beamA{"A", 0.001, 1000}; ReducedPatternOptimization::xRange beamA{"A", 0.001, 1000};
ReducedModelOptimization::xRange beamI2{"I2", 0.001, 1000}; ReducedPatternOptimization::xRange beamI2{"I2", 0.001, 1000};
ReducedModelOptimization::xRange beamI3{"I3", 0.001, 1000}; ReducedPatternOptimization::xRange beamI3{"I3", 0.001, 1000};
ReducedModelOptimization::xRange beamJ{"J", 0.001, 1000}; ReducedPatternOptimization::xRange beamJ{"J", 0.001, 1000};
ReducedModelOptimization::xRange innerHexagonSize{"HexSize", 0.05, 0.95}; ReducedPatternOptimization::xRange innerHexagonSize{"HexSize", 0.05, 0.95};
ReducedModelOptimization::xRange innerHexagonAngle{"HexAngle", -30.0, 30.0}; ReducedPatternOptimization::xRange innerHexagonAngle{"HexAngle", -30.0, 30.0};
ReducedModelOptimization::Settings settings_optimization; ReducedPatternOptimization::Settings settings_optimization;
settings_optimization.xRanges = {beamE,beamA,beamJ,beamI2,beamI3, settings_optimization.xRanges = {beamE,beamA,beamJ,beamI2,beamI3,
innerHexagonSize, innerHexagonAngle}; innerHexagonSize, innerHexagonAngle};
const bool input_numberOfFunctionCallsDefined = argc >= 4; const bool input_numberOfFunctionCallsDefined = argc >= 4;
settings_optimization.numberOfFunctionCalls = settings_optimization.numberOfFunctionCalls =
input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100; input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
settings_optimization.normalizationStrategy settings_optimization.normalizationStrategy
= ReducedModelOptimization::Settings::NormalizationStrategy::Epsilon; = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
settings_optimization.normalizationParameter = 0.0003; settings_optimization.normalizationParameter = 0.0003;
settings_optimization.solutionAccuracy = 0.001; settings_optimization.solutionAccuracy = 0.001;
@ -66,7 +66,8 @@ int main(int argc, char *argv[]) {
assert(interfaceNodeIndex==numberOfNodesPerSlot[0]+numberOfNodesPerSlot[3]); assert(interfaceNodeIndex==numberOfNodesPerSlot[0]+numberOfNodesPerSlot[3]);
ReducedModelOptimizer optimizer(numberOfNodesPerSlot); ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
optimizer.initializePatterns(fullPattern, reducedPattern, settings_optimization.xRanges.size()); optimizer.initializePatterns(fullPattern, reducedPattern, settings_optimization.xRanges.size());
ReducedModelOptimization::Results optimizationResults = optimizer.optimize(settings_optimization); ReducedPatternOptimization::Results optimizationResults = optimizer.optimize(
settings_optimization);
// Export results // Export results
const bool input_resultDirectoryDefined = argc >= 5; const bool input_resultDirectoryDefined = argc >= 5;
@ -105,7 +106,9 @@ int main(int argc, char *argv[]) {
csv_results << endrow; csv_results << endrow;
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
optimizationResults.saveMeshFiles();
optimizationResults.draw(); optimizationResults.draw();
#endif #endif
return 0; return 0;
} }

589
src/reducedmodeloptimizer.cpp
View File

@ -4,10 +4,8 @@
#include "trianglepatterngeometry.hpp" #include "trianglepatterngeometry.hpp"
#include "trianglepattterntopology.hpp" #include "trianglepattterntopology.hpp"
#include <chrono> #include <chrono>
#include <dlib/global_optimization.h>
#include <dlib/optimization.h>
using namespace ReducedModelOptimization; using namespace ReducedPatternOptimization;
struct GlobalOptimizationVariables { struct GlobalOptimizationVariables {
// std::vector<std::vector<Vector6d>> fullPatternDisplacements; // std::vector<std::vector<Vector6d>> fullPatternDisplacements;
@ -22,15 +20,12 @@ struct GlobalOptimizationVariables {
std::vector<double> objectiveValueHistory; std::vector<double> objectiveValueHistory;
Eigen::VectorXd initialParameters; Eigen::VectorXd initialParameters;
std::vector<int> simulationScenarioIndices; std::vector<int> simulationScenarioIndices;
std::vector<VectorType> g_innerHexagonVectors{6, VectorType(0, 0, 0)};
double innerHexagonInitialRotationAngle{30};
double innerHexagonInitialPos{0};
double minY{DBL_MAX}; double minY{DBL_MAX};
std::vector<double> minX; std::vector<double> minX;
int numOfSimulationCrashes{false}; int numOfSimulationCrashes{false};
int numberOfFunctionCalls{0}; int numberOfFunctionCalls{0};
int numberOfOptimizationParameters{5}; int numberOfOptimizationParameters{5};
ReducedModelOptimization::Settings optimizationSettings; ReducedPatternOptimization::Settings optimizationSettings;
vcg::Triangle3<double> baseTriangle; vcg::Triangle3<double> baseTriangle;
} global; } global;
@ -41,13 +36,13 @@ double ReducedModelOptimizer::computeDisplacementError(
&reducedToFullInterfaceViMap, &reducedToFullInterfaceViMap,
const double &normalizationFactor) const double &normalizationFactor)
{ {
const double rawError = computeRawDisplacementError(fullPatternDisplacements, const double rawError = computeRawTranslationalError(fullPatternDisplacements,
reducedPatternDisplacements, reducedPatternDisplacements,
reducedToFullInterfaceViMap); reducedToFullInterfaceViMap);
return rawError / normalizationFactor; return rawError / normalizationFactor;
} }
double ReducedModelOptimizer::computeRawDisplacementError( double ReducedModelOptimizer::computeRawTranslationalError(
const std::vector<Vector6d> &fullPatternDisplacements, const std::vector<Vector6d> &fullPatternDisplacements,
const std::vector<Vector6d> &reducedPatternDisplacements, const std::vector<Vector6d> &reducedPatternDisplacements,
const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
@ -56,18 +51,14 @@ double ReducedModelOptimizer::computeRawDisplacementError(
double error = 0; double error = 0;
for (const auto reducedFullViPair : reducedToFullInterfaceViMap) { for (const auto reducedFullViPair : reducedToFullInterfaceViMap) {
const VertexIndex reducedModelVi = reducedFullViPair.first; const VertexIndex reducedModelVi = reducedFullViPair.first;
Eigen::Vector3d reducedVertexDisplacement(
reducedPatternDisplacements[reducedModelVi][0],
reducedPatternDisplacements[reducedModelVi][1],
reducedPatternDisplacements[reducedModelVi][2]);
const VertexIndex fullModelVi = reducedFullViPair.second; const VertexIndex fullModelVi = reducedFullViPair.second;
Eigen::Vector3d fullVertexDisplacement( const Eigen::Vector3d fullPatternVertexDiplacement = fullPatternDisplacements[fullModelVi]
fullPatternDisplacements[fullModelVi][0], .getTranslation();
fullPatternDisplacements[fullModelVi][1], const Eigen::Vector3d reducedPatternVertexDiplacement
fullPatternDisplacements[fullModelVi][2]); = reducedPatternDisplacements[reducedModelVi].getTranslation();
Eigen::Vector3d errorVector = const double vertexError = (fullPatternVertexDiplacement - reducedPatternVertexDiplacement)
fullVertexDisplacement - reducedVertexDisplacement; .norm();
error += errorVector.norm(); error += vertexError;
} }
return error; return error;
@ -121,7 +112,7 @@ double ReducedModelOptimizer::computeError(
simulationResults_reducedPattern.rotationalDisplacementQuaternion, simulationResults_reducedPattern.rotationalDisplacementQuaternion,
reducedToFullInterfaceViMap, reducedToFullInterfaceViMap,
normalizationFactor_rotationalDisplacement); normalizationFactor_rotationalDisplacement);
return translationalError + rotationalError; return 1.5 * translationalError + 0.5 * rotationalError;
} }
double ReducedModelOptimizer::objective(double E,double A,double J,double I2,double I3, double ReducedModelOptimizer::objective(double E,double A,double J,double I2,double I3,
@ -226,10 +217,10 @@ double ReducedModelOptimizer::objective(long n, const double *x) {
global.minX.assign(x, x + n); global.minX.assign(x, x + n);
} }
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
// if (++global.numberOfFunctionCalls % 100 == 0) { ++global.numberOfFunctionCalls;
// std::cout << "Number of function calls:" << global.numberOfFunctionCalls if (global.numberOfFunctionCalls % 100 == 0) {
// << std::endl; std::cout << "Number of function calls:" << global.numberOfFunctionCalls << std::endl;
// } }
#endif #endif
// compute error and return it // compute error and return it
// global.objectiveValueHistory.push_back(totalError); // global.objectiveValueHistory.push_back(totalError);
@ -517,9 +508,6 @@ void ReducedModelOptimizer::initializeOptimizationParameters(
global.initialParameters(2) = mesh->elements[0].J; global.initialParameters(2) = mesh->elements[0].J;
global.initialParameters(3) = mesh->elements[0].I2; global.initialParameters(3) = mesh->elements[0].I2;
global.initialParameters(4) = mesh->elements[0].I3; global.initialParameters(4) = mesh->elements[0].I3;
global.initialParameters(optimizationParamters-2) = global.innerHexagonInitialPos;
global.innerHexagonInitialRotationAngle = 30;
global.initialParameters(optimizationParamters-1) = global.innerHexagonInitialRotationAngle;
} }
void ReducedModelOptimizer::computeReducedModelSimulationJob( void ReducedModelOptimizer::computeReducedModelSimulationJob(
@ -674,89 +662,105 @@ void ReducedModelOptimizer::computeDesiredReducedModelDisplacements(
} }
} }
ReducedModelOptimization::Results ReducedPatternOptimization::Results ReducedModelOptimizer::getResults(
ReducedModelOptimizer::runOptimization(const Settings &settings) { const dlib::function_evaluation &optimizationResult_dlib, const Settings &settings)
{
ReducedPatternOptimization::Results results;
global.objectiveValueHistory.clear(); results.baseTriangle = global.baseTriangle;
dlib::matrix<double, 0, 1> xMin(global.numberOfOptimizationParameters); //Number of crashes
dlib::matrix<double, 0, 1> xMax(global.numberOfOptimizationParameters);
for (int i = 0; i < global.numberOfOptimizationParameters; i++) {
xMin(i) = settings.xRanges[i].min;
xMax(i) = settings.xRanges[i].max;
}
auto start = std::chrono::system_clock::now();
dlib::function_evaluation result;
double (*objF)(double, double, double, double, double,double,double) = &objective;
result = dlib::find_min_global(
objF, xMin, xMax,
dlib::max_function_calls(settings.numberOfFunctionCalls),
std::chrono::hours(24 * 365 * 290), settings.solutionAccuracy);
auto end = std::chrono::system_clock::now();
auto elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
ReducedModelOptimization::Results results;
results.numberOfSimulationCrashes = global.numOfSimulationCrashes; results.numberOfSimulationCrashes = global.numOfSimulationCrashes;
//Value of optimal objective Y
results.objectiveValue.total = optimizationResult_dlib.y;
//Optimal X values
results.optimalXNameValuePairs.resize(settings.xRanges.size()); results.optimalXNameValuePairs.resize(settings.xRanges.size());
for(int xVariableIndex=0;xVariableIndex<settings.xRanges.size();xVariableIndex++){ std::vector<double> optimalX(settings.xRanges.size());
results.optimalXNameValuePairs[xVariableIndex] for (int xVariableIndex = 0; xVariableIndex < settings.xRanges.size(); xVariableIndex++) {
= std::make_pair(settings.xRanges[xVariableIndex].label, global.minX[xVariableIndex]); if (xVariableIndex < 5) {
results.optimalXNameValuePairs[xVariableIndex]
= std::make_pair(settings.xRanges[xVariableIndex].label,
global.minX[xVariableIndex]
* global.initialParameters(xVariableIndex));
} else {
//Hex size and angle are pure values (not multipliers of the initial values)
results.optimalXNameValuePairs[xVariableIndex]
= std::make_pair(settings.xRanges[xVariableIndex].label,
global.minX[xVariableIndex]);
}
assert(global.minX[xVariableIndex] == optimizationResult_dlib.x(xVariableIndex));
optimalX[xVariableIndex] = optimizationResult_dlib.x(xVariableIndex);
} }
// Compute obj value per simulation scenario and the raw objective value // Compute obj value per simulation scenario and the raw objective value
results.rawObjectiveValue=0;
std::vector<double> optimalX(results.optimalXNameValuePairs.size());
for (int xVariableIndex = 0; xVariableIndex < global.numberOfOptimizationParameters;
xVariableIndex++) {
optimalX[xVariableIndex] = global.minX[xVariableIndex];
assert(global.minX[xVariableIndex] == result.x(xVariableIndex));
}
updateMesh(optimalX.size(), optimalX.data()); updateMesh(optimalX.size(), optimalX.data());
results.objectiveValuePerSimulationScenario.resize(totalNumberOfSimulationScenarios); // results.objectiveValue.totalPerSimulationScenario.resize(totalNumberOfSimulationScenarios);
LinearSimulationModel simulator; LinearSimulationModel simulator;
double totalObjectiveValue = 0; results.objectiveValue.totalRaw = 0;
double totalRawObjectiveValue = 0; results.objectiveValue.perSimulationScenario_translational.resize(
totalNumberOfSimulationScenarios);
results.objectiveValue.perSimulationScenario_rawTranslational.resize(
totalNumberOfSimulationScenarios);
results.objectiveValue.perSimulationScenario_rotational.resize(totalNumberOfSimulationScenarios);
results.objectiveValue.perSimulationScenario_rawRotational.resize(
totalNumberOfSimulationScenarios);
results.objectiveValue.perSimulationScenario_total.resize(totalNumberOfSimulationScenarios);
for (int simulationScenarioIndex : global.simulationScenarioIndices) { for (int simulationScenarioIndex : global.simulationScenarioIndices) {
SimulationResults reducedModelResults = simulator.executeSimulation( SimulationResults reducedModelResults = simulator.executeSimulation(
global.reducedPatternSimulationJobs[simulationScenarioIndex]); global.reducedPatternSimulationJobs[simulationScenarioIndex]);
totalObjectiveValue += computeError( results.objectiveValue.perSimulationScenario_total[simulationScenarioIndex] = computeError(
global.fullPatternResults[simulationScenarioIndex], global.fullPatternResults[simulationScenarioIndex],
reducedModelResults, reducedModelResults,
global.reducedToFullInterfaceViMap, global.reducedToFullInterfaceViMap,
global.translationalDisplacementNormalizationValues[simulationScenarioIndex], global.translationalDisplacementNormalizationValues[simulationScenarioIndex],
global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]); global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]);
const double rawTranslationalError = computeRawDisplacementError( //Raw translational
const double rawTranslationalError = computeRawTranslationalError(
global.fullPatternResults[simulationScenarioIndex].displacements, global.fullPatternResults[simulationScenarioIndex].displacements,
reducedModelResults.displacements, reducedModelResults.displacements,
global.reducedToFullInterfaceViMap); global.reducedToFullInterfaceViMap);
results.objectiveValue.perSimulationScenario_rawTranslational[simulationScenarioIndex]
= rawTranslationalError;
//Raw rotational
const double rawRotationalError = computeRawRotationalError( const double rawRotationalError = computeRawRotationalError(
global.fullPatternResults[simulationScenarioIndex].rotationalDisplacementQuaternion, global.fullPatternResults[simulationScenarioIndex].rotationalDisplacementQuaternion,
reducedModelResults.rotationalDisplacementQuaternion, reducedModelResults.rotationalDisplacementQuaternion,
global.reducedToFullInterfaceViMap); global.reducedToFullInterfaceViMap);
results.objectiveValue.perSimulationScenario_rawRotational[simulationScenarioIndex]
= rawRotationalError;
results.rawObjectiveValue += rawTranslationalError + rawRotationalError; //Normalized translational
const double normalizedTranslationalError = computeDisplacementError(
const double normalizedTranslationalError
= rawTranslationalError
/ global.translationalDisplacementNormalizationValues[simulationScenarioIndex];
const double test_normalizedTranslationError = computeDisplacementError(
global.fullPatternResults[simulationScenarioIndex].displacements, global.fullPatternResults[simulationScenarioIndex].displacements,
reducedModelResults.displacements, reducedModelResults.displacements,
global.reducedToFullInterfaceViMap, global.reducedToFullInterfaceViMap,
global.translationalDisplacementNormalizationValues[simulationScenarioIndex]); global.translationalDisplacementNormalizationValues[simulationScenarioIndex]);
const double normalizedRotationalError results.objectiveValue.perSimulationScenario_translational[simulationScenarioIndex]
= rawRotationalError = normalizedTranslationalError;
/ global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]; // const double test_normalizedTranslationError = computeDisplacementError(
const double test_normalizedRotationalError = computeRotationalError( // global.fullPatternResults[simulationScenarioIndex].displacements,
// reducedModelResults.displacements,
// global.reducedToFullInterfaceViMap,
// global.translationalDisplacementNormalizationValues[simulationScenarioIndex]);
//Normalized rotational
const double normalizedRotationalError = computeRotationalError(
global.fullPatternResults[simulationScenarioIndex].rotationalDisplacementQuaternion, global.fullPatternResults[simulationScenarioIndex].rotationalDisplacementQuaternion,
reducedModelResults.rotationalDisplacementQuaternion, reducedModelResults.rotationalDisplacementQuaternion,
global.reducedToFullInterfaceViMap, global.reducedToFullInterfaceViMap,
global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]); global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]);
assert(test_normalizedTranslationError == normalizedTranslationalError); results.objectiveValue.perSimulationScenario_rotational[simulationScenarioIndex]
assert(test_normalizedRotationalError == normalizedRotationalError); = normalizedRotationalError;
std::cout << "Simulation scenario:" << baseSimulationScenarioNames[simulationScenarioIndex] // const double test_normalizedRotationalError = computeRotationalError(
// global.fullPatternResults[simulationScenarioIndex].rotationalDisplacementQuaternion,
// reducedModelResults.rotationalDisplacementQuaternion,
// global.reducedToFullInterfaceViMap,
// global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]);
// assert(test_normalizedTranslationError == normalizedTranslationalError);
// assert(test_normalizedRotationalError == normalizedRotationalError);
std::cout << "Simulation scenario:"
<< global.reducedPatternSimulationJobs[simulationScenarioIndex]->getLabel()
<< std::endl; << std::endl;
std::cout << "raw translational error:" << rawTranslationalError << std::endl; std::cout << "raw translational error:" << rawTranslationalError << std::endl;
std::cout << "translation normalization value:" std::cout << "translation normalization value:"
@ -768,180 +772,307 @@ ReducedModelOptimizer::runOptimization(const Settings &settings) {
<< global.rotationalDisplacementNormalizationValues[simulationScenarioIndex] << global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]
<< std::endl; << std::endl;
std::cout << "Rotational error:" << normalizedRotationalError << std::endl; std::cout << "Rotational error:" << normalizedRotationalError << std::endl;
results.objectiveValuePerSimulationScenario[simulationScenarioIndex] // results.objectiveValuePerSimulationScenario[simulationScenarioIndex]
= normalizedTranslationalError + normalizedRotationalError; // = normalizedTranslationalError + normalizedRotationalError;
std::cout << "Objective value:" std::cout << "Objective value:"
<< results.objectiveValuePerSimulationScenario[simulationScenarioIndex] << results.objectiveValue.perSimulationScenario_total[simulationScenarioIndex]
<< std::endl; << std::endl;
// totalObjectiveValue += results.objectiveValuePerSimulationScenario[simulationScenarioIndex]; results.objectiveValue.totalRaw += rawTranslationalError + rawRotationalError;
totalRawObjectiveValue += rawTranslationalError + rawRotationalError;
std::cout << std::endl; std::cout << std::endl;
} }
assert(result.y == global.minY);
results.objectiveValue = result.y;
auto functionReturnValue = objective(optimalX.size(), optimalX.data());
std::cout << "Total (functionReturn)" << functionReturnValue << std::endl;
std::cout << "Total:" << totalObjectiveValue << std::endl;
#ifdef POLYSCOPE_DEFINED
std::cout << "Total optimal objective value:" << results.objectiveValue << std::endl;
// std::cout << "Total raw objective value:" << global.minY << std::endl;
if (global.minY != result.y) {
std::cerr << "Global min objective is not equal to result objective" << std::endl;
}
#endif
results.time = elapsed.count() / 1000.0;
const bool printDebugInfo = false; const bool printDebugInfo = false;
if (printDebugInfo) { if (printDebugInfo) {
std::cout << "Finished optimizing." << endl; std::cout << "Finished optimizing." << endl;
// std::cout << "Solution x:" << endl; std::cout << "Total optimal objective value:" << results.objectiveValue.total << std::endl;
// std::cout << result.x << endl; assert(global.minY == optimizationResult_dlib.y);
std::cout << "Objective value:" << global.minY << endl; }
for (int simulationScenarioIndex : global.simulationScenarioIndices) {
results.fullPatternSimulationJobs.push_back(
global.fullPatternSimulationJobs[simulationScenarioIndex]);
results.reducedPatternSimulationJobs.push_back(
global.reducedPatternSimulationJobs[simulationScenarioIndex]);
// const std::string temp = global.reducedPatternSimulationJobs[simulationScenarioIndex]
// ->pMesh->getLabel();
// global.reducedPatternSimulationJobs[simulationScenarioIndex]->pMesh->setLabel("temp");
// global.reducedPatternSimulationJobs[simulationScenarioIndex]->pMesh->registerForDrawing();
// global.reducedPatternSimulationJobs[simulationScenarioIndex]->pMesh->setLabel(temp);
} }
return results; return results;
} }
ReducedPatternOptimization::Results ReducedModelOptimizer::runOptimization(const Settings &settings)
{
global.objectiveValueHistory.clear();
dlib::matrix<double, 0, 1> xMin(global.numberOfOptimizationParameters);
dlib::matrix<double, 0, 1> xMax(global.numberOfOptimizationParameters);
for (int i = 0; i < global.numberOfOptimizationParameters; i++) {
xMin(i) = settings.xRanges[i].min;
xMax(i) = settings.xRanges[i].max;
}
auto start = std::chrono::system_clock::now();
dlib::function_evaluation result_dlib;
double (*objF)(double, double, double, double, double,double,double) = &objective;
result_dlib = dlib::find_min_global(objF,
xMin,
xMax,
dlib::max_function_calls(settings.numberOfFunctionCalls),
std::chrono::hours(24 * 365 * 290),
settings.solutionAccuracy);
auto end = std::chrono::system_clock::now();
auto elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
ReducedPatternOptimization::Results results = getResults(result_dlib, settings);
results.time = elapsed.count() / 1000.0;
return results;
}
//TODO: create a function that takes as arguments the magnitude range, a lambda that generates the simulation job and the base sim scenario index
std::vector<std::shared_ptr<SimulationJob>> std::vector<std::shared_ptr<SimulationJob>>
ReducedModelOptimizer::createScenarios( ReducedModelOptimizer::createFullPatternSimulationScenarios(
const std::shared_ptr<SimulationMesh> &pMesh) { const std::shared_ptr<SimulationMesh> &pMesh)
{
std::vector<std::shared_ptr<SimulationJob>> scenarios; std::vector<std::shared_ptr<SimulationJob>> scenarios;
scenarios.resize(totalNumberOfSimulationScenarios); scenarios.resize(totalNumberOfSimulationScenarios);
std::unordered_map<VertexIndex, std::unordered_set<DoFType>> fixedVertices; std::unordered_map<VertexIndex, std::unordered_set<DoFType>> fixedVertices;
std::unordered_map<VertexIndex, Vector6d> nodalForces; std::unordered_map<VertexIndex, Vector6d> nodalForces;
//// Axial //// Axial
int simulationScenarioIndex = BaseSimulationScenario::Axial; const double maxForceMagnitude_axial = 500;
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin(); const double minForceMagnitude_axial = -500;
viPairIt != m_fullPatternOppositeInterfaceViPairs.end(); const int numberOfSimulationScenarios_axial
viPairIt++) { = simulationScenariosResolution[BaseSimulationScenario::Axial];
if (viPairIt != m_fullPatternOppositeInterfaceViPairs.begin()) { const double forceMagnitudeStep_axial = numberOfSimulationScenarios_axial == 1
CoordType forceDirection(1, 0, 0); ? maxForceMagnitude_axial
const auto viPair = *viPairIt; : (maxForceMagnitude_axial - minForceMagnitude_axial)
nodalForces[viPair.first] / (numberOfSimulationScenarios_axial - 1);
= Vector6d({forceDirection[0], forceDirection[1], forceDirection[2], 0, 0, 0}) const int baseSimulationScenarioIndexOffset_axial
* 500; = std::accumulate(simulationScenariosResolution.begin(),
fixedVertices[viPair.second] = simulationScenariosResolution.begin() + BaseSimulationScenario::Axial,
std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5}; 0);
for (int axialSimulationScenarioIndex = 0;
axialSimulationScenarioIndex < numberOfSimulationScenarios_axial;
axialSimulationScenarioIndex++) {
const double forceMagnitude = (forceMagnitudeStep_axial * axialSimulationScenarioIndex
+ minForceMagnitude_axial);
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin();
viPairIt != m_fullPatternOppositeInterfaceViPairs.end();
viPairIt++) {
if (viPairIt != m_fullPatternOppositeInterfaceViPairs.begin()) {
CoordType forceDirection(1, 0, 0);
const auto viPair = *viPairIt;
nodalForces[viPair.first]
= Vector6d({forceDirection[0], forceDirection[1], forceDirection[2], 0, 0, 0})
* forceMagnitude;
fixedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5};
}
} }
scenarios[baseSimulationScenarioIndexOffset_axial + axialSimulationScenarioIndex]
= std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[BaseSimulationScenario::Axial] + "_"
+ std::to_string(axialSimulationScenarioIndex),
fixedVertices,
nodalForces,
{}));
} }
scenarios[simulationScenarioIndex] = std::make_shared<SimulationJob>(
SimulationJob(pMesh,
"Axial_" + std::to_string(simulationScenarioIndex),
fixedVertices,
nodalForces,
{}));
//// Shear //// Shear
simulationScenarioIndex = BaseSimulationScenario::Shear; const double maxForceMagnitude_shear = 50;
fixedVertices.clear(); const double minForceMagnitude_shear = -50;
nodalForces.clear(); const int numberOfSimulationScenarios_shear
// NewMethod = simulationScenariosResolution[BaseSimulationScenario::Shear];
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin(); const double forceMagnitudeStep_shear = numberOfSimulationScenarios_shear == 1
viPairIt != m_fullPatternOppositeInterfaceViPairs.end(); ? maxForceMagnitude_shear
viPairIt++) { : (maxForceMagnitude_shear - minForceMagnitude_shear)
if (viPairIt != m_fullPatternOppositeInterfaceViPairs.begin()) { / (numberOfSimulationScenarios_shear - 1);
CoordType forceDirection(0, 1, 0); const int baseSimulationScenarioIndexOffset_shear
const auto viPair = *viPairIt; = std::accumulate(simulationScenariosResolution.begin(),
nodalForces[viPair.first] simulationScenariosResolution.begin() + BaseSimulationScenario::Shear,
= Vector6d({forceDirection[0], forceDirection[1], forceDirection[2], 0, 0, 0}) * 40; 0);
fixedVertices[viPair.second] = for (int shearSimulationScenarioIndex = 0;
std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5}; shearSimulationScenarioIndex < numberOfSimulationScenarios_shear;
shearSimulationScenarioIndex++) {
fixedVertices.clear();
nodalForces.clear();
const double forceMagnitude = (forceMagnitudeStep_shear * shearSimulationScenarioIndex
+ minForceMagnitude_shear);
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin();
viPairIt != m_fullPatternOppositeInterfaceViPairs.end();
viPairIt++) {
if (viPairIt != m_fullPatternOppositeInterfaceViPairs.begin()) {
CoordType forceDirection(0, 1, 0);
const auto viPair = *viPairIt;
nodalForces[viPair.first]
= Vector6d({forceDirection[0], forceDirection[1], forceDirection[2], 0, 0, 0})
* forceMagnitude;
fixedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5};
}
} }
scenarios[baseSimulationScenarioIndexOffset_shear + shearSimulationScenarioIndex]
= std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[BaseSimulationScenario::Shear] + "_"
+ std::to_string(shearSimulationScenarioIndex),
fixedVertices,
nodalForces,
{}));
} }
scenarios[simulationScenarioIndex] = std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[simulationScenarioIndex],
fixedVertices,
nodalForces,
{}));
//// Bending //// Bending
simulationScenarioIndex = BaseSimulationScenario::Bending; const double maxForceMagnitude_bending = 0.005;
fixedVertices.clear(); const double minForceMagnitude_bending = -0.005;
nodalForces.clear(); const int numberOfSimulationScenarios_bending
for (const auto &viPair : m_fullPatternOppositeInterfaceViPairs) { = simulationScenariosResolution[BaseSimulationScenario::Bending];
nodalForces[viPair.first] = Vector6d({0, 0, 1, 0, 0, 0}) * 0.005; const double forceMagnitudeStep_bending = numberOfSimulationScenarios_bending == 1
fixedVertices[viPair.second] = ? maxForceMagnitude_bending
std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5}; : (maxForceMagnitude_bending
- minForceMagnitude_bending)
/ (numberOfSimulationScenarios_bending - 1);
const int baseSimulationScenarioIndexOffset_bending
= std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.begin() + BaseSimulationScenario::Bending,
0);
for (int bendingSimulationScenarioIndex = 0;
bendingSimulationScenarioIndex < numberOfSimulationScenarios_bending;
bendingSimulationScenarioIndex++) {
fixedVertices.clear();
nodalForces.clear();
const double forceMagnitude = (forceMagnitudeStep_bending * bendingSimulationScenarioIndex
+ minForceMagnitude_bending);
for (const auto &viPair : m_fullPatternOppositeInterfaceViPairs) {
nodalForces[viPair.first] = Vector6d({0, 0, 1, 0, 0, 0}) * forceMagnitude;
fixedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2, 3, 4, 5};
}
scenarios[baseSimulationScenarioIndexOffset_bending + bendingSimulationScenarioIndex]
= std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[BaseSimulationScenario::Bending] + "_"
+ std::to_string(bendingSimulationScenarioIndex),
fixedVertices,
nodalForces,
{}));
} }
scenarios[simulationScenarioIndex] = std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[simulationScenarioIndex],
fixedVertices,
nodalForces,
{}));
//// Dome //// Dome
simulationScenarioIndex = BaseSimulationScenario::Dome; const double maxForceMagnitude_dome = 0.025;
fixedVertices.clear(); const double minForceMagnitude_dome = -0.025;
nodalForces.clear(); const int numberOfSimulationScenarios_dome
std::unordered_map<VertexIndex, Eigen::Vector3d> nodalForcedDisplacements; = simulationScenariosResolution[BaseSimulationScenario::Dome];
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin(); const double forceMagnitudeStep_dome = numberOfSimulationScenarios_dome == 1
viPairIt != m_fullPatternOppositeInterfaceViPairs.end(); ? maxForceMagnitude_dome
viPairIt++) { : (maxForceMagnitude_dome - minForceMagnitude_dome)
const auto viPair = *viPairIt; / (numberOfSimulationScenarios_dome - 1);
if (viPairIt == m_fullPatternOppositeInterfaceViPairs.begin()) { const int baseSimulationScenarioIndexOffset_dome
CoordType interfaceV = (pMesh->vert[viPair.first].cP() = std::accumulate(simulationScenariosResolution.begin(),
- pMesh->vert[viPair.second].cP()); simulationScenariosResolution.begin() + BaseSimulationScenario::Dome,
nodalForcedDisplacements[viPair.first] = Eigen::Vector3d(-interfaceV[0], 0);
-interfaceV[1], for (int domeSimulationScenarioIndex = 0;
0) domeSimulationScenarioIndex < numberOfSimulationScenarios_dome;
* 0.025; domeSimulationScenarioIndex++) {
nodalForcedDisplacements[viPair.second] = Eigen::Vector3d(interfaceV[0], fixedVertices.clear();
interfaceV[1], nodalForces.clear();
0) std::unordered_map<VertexIndex, Eigen::Vector3d> nodalForcedDisplacements;
* 0.025; const double forceMagnitude = (forceMagnitudeStep_dome * domeSimulationScenarioIndex
// CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP()) + minForceMagnitude_dome);
// ^ CoordType(0, 0, -1).Normalize(); for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin();
// nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude viPairIt != m_fullPatternOppositeInterfaceViPairs.end();
// * 0.0001; viPairIt++) {
// nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude const auto viPair = *viPairIt;
// * 0.0001; CoordType interfaceVector = (pMesh->vert[viPair.first].cP()
} else { - pMesh->vert[viPair.second].cP());
fixedVertices[viPair.first] = std::unordered_set<DoFType>{2}; VectorType momentAxis = vcg::RotationMatrix(VectorType(0, 0, 1), vcg::math::ToRad(90.0))
fixedVertices[viPair.second] = std::unordered_set<DoFType>{2}; * interfaceVector.Normalize();
CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP()) if (viPairIt == m_fullPatternOppositeInterfaceViPairs.begin()) {
^ CoordType(0, 0, -1).Normalize(); nodalForcedDisplacements[viPair.first] = Eigen::Vector3d(-interfaceVector[0],
nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * 0.005; -interfaceVector[1],
nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * 0.005; 0)
* std::abs(forceMagnitude);
nodalForcedDisplacements[viPair.second] = Eigen::Vector3d(interfaceVector[0],
interfaceVector[1],
0)
* std::abs(forceMagnitude);
// CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP())
// ^ CoordType(0, 0, -1).Normalize();
// nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude
// * 0.0001;
// nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude
// * 0.0001;
} else {
nodalForces[viPair.first]
= Vector6d({0, 0, 0, momentAxis[0], momentAxis[1], momentAxis[2]})
* forceMagnitude / 5;
nodalForces[viPair.second]
= Vector6d({0, 0, 0, -momentAxis[0], -momentAxis[1], -momentAxis[2]})
* forceMagnitude / 5;
fixedVertices[viPair.first] = std::unordered_set<DoFType>{2};
fixedVertices[viPair.second] = std::unordered_set<DoFType>{2};
}
} }
scenarios[baseSimulationScenarioIndexOffset_dome + domeSimulationScenarioIndex]
= std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[BaseSimulationScenario::Dome] + "_"
+ std::to_string(domeSimulationScenarioIndex),
fixedVertices,
nodalForces,
nodalForcedDisplacements));
} }
scenarios[simulationScenarioIndex] = std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[simulationScenarioIndex],
fixedVertices,
nodalForces,
nodalForcedDisplacements));
//// Saddle //// Saddle
simulationScenarioIndex = BaseSimulationScenario::Saddle; const double maxForceMagnitude_saddle = 0.005;
fixedVertices.clear(); const double minForceMagnitude_saddle = -0.005;
nodalForces.clear(); const int numberOfSimulationScenarios_saddle
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin(); = simulationScenariosResolution[BaseSimulationScenario::Saddle];
viPairIt != m_fullPatternOppositeInterfaceViPairs.end(); const double forceMagnitudeStep_saddle = numberOfSimulationScenarios_saddle == 1
viPairIt++) { ? maxForceMagnitude_saddle
const auto &viPair = *viPairIt; : (maxForceMagnitude_saddle
CoordType v = - minForceMagnitude_saddle)
(pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP()) ^ / (numberOfSimulationScenarios_saddle - 1);
CoordType(0, 0, -1).Normalize(); const int baseSimulationScenarioIndexOffset_saddle
if (viPairIt == m_fullPatternOppositeInterfaceViPairs.begin()) { = std::accumulate(simulationScenariosResolution.begin(),
nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * 0.002; simulationScenariosResolution.begin() + BaseSimulationScenario::Saddle,
nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * 0.002; 0);
} else { for (int saddleSimulationScenarioIndex = 0;
fixedVertices[viPair.first] = std::unordered_set<DoFType>{2}; saddleSimulationScenarioIndex < numberOfSimulationScenarios_saddle;
fixedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2}; saddleSimulationScenarioIndex++) {
fixedVertices.clear();
nodalForces.clear();
const double forceMagnitude = (forceMagnitudeStep_saddle * saddleSimulationScenarioIndex
+ minForceMagnitude_saddle);
for (auto viPairIt = m_fullPatternOppositeInterfaceViPairs.begin();
viPairIt != m_fullPatternOppositeInterfaceViPairs.end();
viPairIt++) {
const auto &viPair = *viPairIt;
CoordType v = (pMesh->vert[viPair.first].cP() - pMesh->vert[viPair.second].cP())
^ CoordType(0, 0, -1).Normalize();
if (viPairIt == m_fullPatternOppositeInterfaceViPairs.begin()) {
nodalForces[viPair.first] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude;
nodalForces[viPair.second] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude;
} else {
fixedVertices[viPair.first] = std::unordered_set<DoFType>{2};
fixedVertices[viPair.second] = std::unordered_set<DoFType>{0, 1, 2};
nodalForces[viPair.first] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * 0.001; nodalForces[viPair.first] = Vector6d({0, 0, 0, -v[0], -v[1], 0}) * forceMagnitude
nodalForces[viPair.second] = Vector6d({0, 0, 0, v[0], v[1], 0}) * 0.001; / 2;
nodalForces[viPair.second] = Vector6d({0, 0, 0, v[0], v[1], 0}) * forceMagnitude
/ 2;
}
} }
scenarios[baseSimulationScenarioIndexOffset_saddle + saddleSimulationScenarioIndex]
= std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[BaseSimulationScenario::Saddle] + "_"
+ std::to_string(saddleSimulationScenarioIndex),
fixedVertices,
nodalForces,
{}));
} }
scenarios[simulationScenarioIndex] = std::make_shared<SimulationJob>(
SimulationJob(pMesh,
baseSimulationScenarioNames[simulationScenarioIndex],
fixedVertices,
nodalForces,
{}));
return scenarios; return scenarios;
} }
@ -1050,31 +1181,32 @@ Results ReducedModelOptimizer::optimize(
global.numOfSimulationCrashes = 0; global.numOfSimulationCrashes = 0;
global.numberOfFunctionCalls = 0; global.numberOfFunctionCalls = 0;
global.optimizationSettings = optimizationSettings; global.optimizationSettings = optimizationSettings;
global.fullPatternSimulationJobs = createScenarios(m_pFullPatternSimulationMesh); global.fullPatternSimulationJobs = createFullPatternSimulationScenarios(
m_pFullPatternSimulationMesh);
// polyscope::removeAllStructures(); // polyscope::removeAllStructures();
DRMSimulationModel::Settings simulationSettings; DRMSimulationModel::Settings simulationSettings;
simulationSettings.shouldDraw = false; simulationSettings.shouldDraw = false;
// global.fullPatternSimulationJobs[0]->pMesh->registerForDrawing( // global.fullPatternSimulationJobs[0]->pMesh->registerForDrawing(
// ReducedModelOptimization::Colors::fullInitial); // ReducedPatternOptimization::Colors::fullInitial);
// LinearSimulationModel linearSimulator; // LinearSimulationModel linearSimulator;
for (int simulationScenarioIndex : global.simulationScenarioIndices) { for (int simulationScenarioIndex : global.simulationScenarioIndices) {
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
= global.fullPatternSimulationJobs[simulationScenarioIndex]; = global.fullPatternSimulationJobs[simulationScenarioIndex];
SimulationResults fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob, SimulationResults fullPatternResults = simulator.executeSimulation(pFullPatternSimulationJob,
simulationSettings); simulationSettings);
// SimulationResults fullPatternResults_linear = linearSimulator.executeSimulation( // SimulationResults fullPatternResults_linear = linearSimulator.executeSimulation(
// pFullPatternSimulationJob); // pFullPatternSimulationJob);
// fullPatternResults.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed, // fullPatternResults.registerForDrawing(ReducedPatternOptimization::Colors::fullDeformed,
// true, // true,
// true); // true);
// fullPatternResults_linear.labelPrefix += "_linear"; // fullPatternResults_linear.labelPrefix += "_linear";
// fullPatternResults_linear.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed, // fullPatternResults_linear.registerForDrawing(ReducedModelOptimization::Colors::fullDeformed,
// true, // true,
// true); // true);
// polyscope::show(); // polyscope::show();
// fullPatternResults.unregister(); // fullPatternResults.unregister();
// fullPatternResults_linear.unregister(); // fullPatternResults_linear.unregister();
global.fullPatternResults[simulationScenarioIndex] = fullPatternResults; global.fullPatternResults[simulationScenarioIndex] = fullPatternResults;
SimulationJob reducedPatternSimulationJob; SimulationJob reducedPatternSimulationJob;
reducedPatternSimulationJob.pMesh = m_pReducedPatternSimulationMesh; reducedPatternSimulationJob.pMesh = m_pReducedPatternSimulationMesh;
@ -1083,6 +1215,7 @@ Results ReducedModelOptimizer::optimize(
reducedPatternSimulationJob); reducedPatternSimulationJob);
global.reducedPatternSimulationJobs[simulationScenarioIndex] global.reducedPatternSimulationJobs[simulationScenarioIndex]
= std::make_shared<SimulationJob>(reducedPatternSimulationJob); = std::make_shared<SimulationJob>(reducedPatternSimulationJob);
// std::cout << "Ran sim scenario:" << simulationScenarioIndex << std::endl;
} }
// global.fullPatternSimulationJobs[0]->pMesh->unregister(); // global.fullPatternSimulationJobs[0]->pMesh->unregister();
@ -1091,12 +1224,6 @@ Results ReducedModelOptimizer::optimize(
computeObjectiveValueNormalizationFactors(); computeObjectiveValueNormalizationFactors();
// } // }
Results optResults = runOptimization(optimizationSettings); Results optResults = runOptimization(optimizationSettings);
for (int simulationScenarioIndex : global.simulationScenarioIndices) {
optResults.fullPatternSimulationJobs.push_back(
global.fullPatternSimulationJobs[simulationScenarioIndex]);
optResults.reducedPatternSimulationJobs.push_back(
global.reducedPatternSimulationJobs[simulationScenarioIndex]);
}
return optResults; return optResults;
} }

27
src/reducedmodeloptimizer.hpp
View File

@ -9,6 +9,8 @@
#include "reducedmodeloptimizer_structs.hpp" #include "reducedmodeloptimizer_structs.hpp"
#include "simulationmesh.hpp" #include "simulationmesh.hpp"
#include <Eigen/Dense> #include <Eigen/Dense>
#include <dlib/global_optimization.h>
#include <dlib/optimization.h>
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
#include "polyscope/color_management.h" #include "polyscope/color_management.h"
@ -28,17 +30,17 @@ class ReducedModelOptimizer
std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode; std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode;
public: public:
constexpr static std::array<int, 5> simulationScenariosResolution = {1, 1, 1, 1, 1}; constexpr static std::array<int, 5> simulationScenariosResolution = {2, 2, 6, 6, 6};
inline static int totalNumberOfSimulationScenarios inline static int totalNumberOfSimulationScenarios
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
simulationScenariosResolution.end(), simulationScenariosResolution.end(),
0); 0);
inline static int fanSize{6}; inline static int fanSize{6};
inline static VectorType patternPlaneNormal{0, 0, 1}; inline static VectorType patternPlaneNormal{0, 0, 1};
ReducedModelOptimization::Results optimize( ReducedPatternOptimization::Results optimize(
const ReducedModelOptimization::Settings &xRanges, const ReducedPatternOptimization::Settings &xRanges,
const std::vector<ReducedModelOptimization::BaseSimulationScenario> &simulationScenarios const std::vector<ReducedPatternOptimization::BaseSimulationScenario> &simulationScenarios
= std::vector<ReducedModelOptimization::BaseSimulationScenario>()); = std::vector<ReducedPatternOptimization::BaseSimulationScenario>());
double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const; double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;
ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot); ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot);
@ -64,7 +66,7 @@ public:
double innerHexagonRotationAngle); double innerHexagonRotationAngle);
static double objective(double b, double r, double E); static double objective(double b, double r, double E);
static std::vector<std::shared_ptr<SimulationJob>> createScenarios( static std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationScenarios(
const std::shared_ptr<SimulationMesh> &pMesh, const std::shared_ptr<SimulationMesh> &pMesh,
const std::unordered_map<size_t, size_t> &fullPatternOppositeInterfaceViMap); const std::unordered_map<size_t, size_t> &fullPatternOppositeInterfaceViMap);
@ -85,7 +87,7 @@ public:
static void visualizeResults( static void visualizeResults(
const std::vector<std::shared_ptr<SimulationJob>> &fullPatternSimulationJobs, const std::vector<std::shared_ptr<SimulationJob>> &fullPatternSimulationJobs,
const std::vector<std::shared_ptr<SimulationJob>> &reducedPatternSimulationJobs, const std::vector<std::shared_ptr<SimulationJob>> &reducedPatternSimulationJobs,
const std::vector<ReducedModelOptimization::BaseSimulationScenario> &simulationScenarios, const std::vector<ReducedPatternOptimization::BaseSimulationScenario> &simulationScenarios,
const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
&reducedToFullInterfaceViMap); &reducedToFullInterfaceViMap);
static void registerResultsForDrawing( static void registerResultsForDrawing(
@ -94,7 +96,7 @@ public:
const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
&reducedToFullInterfaceViMap); &reducedToFullInterfaceViMap);
static double computeRawDisplacementError( static double computeRawTranslationalError(
const std::vector<Vector6d> &fullPatternDisplacements, const std::vector<Vector6d> &fullPatternDisplacements,
const std::vector<Vector6d> &reducedPatternDisplacements, const std::vector<Vector6d> &reducedPatternDisplacements,
const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex> const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
@ -136,9 +138,9 @@ private:
const SimulationResults &fullModelResults, const SimulationResults &fullModelResults,
const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap, const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
Eigen::MatrixX3d &optimalDisplacementsOfReducedModel); Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
static ReducedModelOptimization::Results runOptimization( static ReducedPatternOptimization::Results runOptimization(
const ReducedModelOptimization::Settings &settings); const ReducedPatternOptimization::Settings &settings);
std::vector<std::shared_ptr<SimulationJob>> createScenarios( std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationScenarios(
const std::shared_ptr<SimulationMesh> &pMesh); const std::shared_ptr<SimulationMesh> &pMesh);
void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern); void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern);
void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel); void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
@ -148,6 +150,9 @@ private:
static double objective(long n, const double *x); static double objective(long n, const double *x);
DRMSimulationModel simulator; DRMSimulationModel simulator;
void computeObjectiveValueNormalizationFactors(); void computeObjectiveValueNormalizationFactors();
static ReducedPatternOptimization::Results getResults(
const dlib::function_evaluation &optimizationResult_dlib,
const ReducedPatternOptimization::Settings &settings);
}; };
void updateMesh(long n, const double *x); void updateMesh(long n, const double *x);
#endif // REDUCEDMODELOPTIMIZER_HPP #endif // REDUCEDMODELOPTIMIZER_HPP