2020-11-23 10:06:45 +01:00
|
|
|
#ifndef REDUCEDMODELOPTIMIZER_HPP
|
|
|
|
#define REDUCEDMODELOPTIMIZER_HPP
|
|
|
|
|
|
|
|
#include "beamformfinder.hpp"
|
2021-02-10 12:19:37 +01:00
|
|
|
#include "csvfile.hpp"
|
2020-11-23 10:06:45 +01:00
|
|
|
#include "edgemesh.hpp"
|
|
|
|
#include "elementalmesh.hpp"
|
2020-12-09 16:58:48 +01:00
|
|
|
#include "matplot/matplot.h"
|
2020-11-23 10:06:45 +01:00
|
|
|
#include <Eigen/Dense>
|
|
|
|
|
2021-03-01 13:34:27 +01:00
|
|
|
#ifdef POLYSCOPE_DEFINED
|
|
|
|
#include "polyscope/color_management.h"
|
|
|
|
#endif // POLYSCOPE_DEFINED
|
2020-12-14 10:07:43 +01:00
|
|
|
using FullPatternVertexIndex = VertexIndex;
|
|
|
|
using ReducedPatternVertexIndex = VertexIndex;
|
2020-11-23 10:06:45 +01:00
|
|
|
|
|
|
|
class ReducedModelOptimizer {
|
2020-12-16 20:31:58 +01:00
|
|
|
std::shared_ptr<SimulationMesh> m_pReducedPatternSimulationMesh;
|
2021-01-04 13:12:25 +01:00
|
|
|
std::shared_ptr<SimulationMesh> m_pFullPatternSimulationMesh;
|
2020-12-14 10:07:43 +01:00
|
|
|
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
|
2020-11-27 11:45:20 +01:00
|
|
|
m_fullToReducedInterfaceViMap;
|
2020-12-14 10:07:43 +01:00
|
|
|
std::unordered_map<FullPatternVertexIndex, FullPatternVertexIndex>
|
2020-11-27 11:45:20 +01:00
|
|
|
m_fullPatternOppositeInterfaceViMap;
|
|
|
|
std::unordered_map<size_t, size_t> nodeToSlot;
|
|
|
|
std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode;
|
2020-12-16 20:31:58 +01:00
|
|
|
std::vector<double> initialGuess;
|
2021-03-01 13:34:27 +01:00
|
|
|
#ifdef POLYSCOPE_DEFINED
|
|
|
|
struct StaticColors {
|
|
|
|
glm::vec3 fullInitial;
|
|
|
|
glm::vec3 fullDeformed;
|
|
|
|
glm::vec3 reducedInitial;
|
|
|
|
glm::vec3 reducedDeformed;
|
|
|
|
StaticColors() {
|
|
|
|
fullInitial = {0.416666, 0.109804, 0.890196};
|
|
|
|
fullDeformed = {0.583333, 0.890196, 0.109804};
|
|
|
|
reducedInitial = {0.890196, 0.109804, 0.193138};
|
|
|
|
reducedDeformed = {0.109804, 0.890196, 0.806863};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
inline static StaticColors colors;
|
|
|
|
#endif // POLYSCOPE_DEFINED
|
2020-11-23 10:06:45 +01:00
|
|
|
|
|
|
|
public:
|
2020-12-21 16:56:21 +01:00
|
|
|
enum SimulationScenario {
|
|
|
|
Axial,
|
|
|
|
Shear,
|
|
|
|
Bending,
|
2021-01-04 13:12:25 +01:00
|
|
|
Dome,
|
2020-12-21 16:56:21 +01:00
|
|
|
Saddle,
|
|
|
|
NumberOfSimulationScenarios
|
|
|
|
};
|
2021-02-11 12:52:27 +01:00
|
|
|
|
2021-01-22 15:39:36 +01:00
|
|
|
struct xRange {
|
|
|
|
std::string label;
|
|
|
|
double min;
|
|
|
|
double max;
|
|
|
|
std::string toString() const {
|
|
|
|
return label + "=[" + std::to_string(min) + "," + std::to_string(max) +
|
|
|
|
"]";
|
|
|
|
}
|
|
|
|
};
|
2021-02-11 12:52:27 +01:00
|
|
|
struct Results;
|
2021-01-22 15:39:36 +01:00
|
|
|
|
|
|
|
struct Settings {
|
2021-03-01 13:34:27 +01:00
|
|
|
enum NormalizationStrategy {
|
|
|
|
NonNormalized,
|
|
|
|
Epsilon,
|
|
|
|
MaxDisplacement,
|
|
|
|
EqualDisplacements
|
|
|
|
};
|
|
|
|
inline static vector<std::string> normalizationStrategyStrings{
|
|
|
|
"NonNormalized", "Epsilon", "MaxDsiplacement", "EqualDisplacements"};
|
2021-01-22 15:39:36 +01:00
|
|
|
std::vector<xRange> xRanges;
|
2021-02-10 12:19:37 +01:00
|
|
|
int numberOfFunctionCalls{100};
|
2021-02-12 18:58:40 +01:00
|
|
|
double solutionAccuracy{1e-2};
|
2021-03-01 13:34:27 +01:00
|
|
|
NormalizationStrategy normalizationStrategy{Epsilon};
|
|
|
|
double normalizationParameter{0.003};
|
2021-02-10 12:19:37 +01:00
|
|
|
|
|
|
|
std::string toString() const {
|
|
|
|
std::string settingsString;
|
|
|
|
if (!xRanges.empty()) {
|
|
|
|
std::string xRangesString;
|
|
|
|
for (const xRange &range : xRanges) {
|
|
|
|
xRangesString += range.toString() + " ";
|
|
|
|
}
|
|
|
|
settingsString += xRangesString;
|
|
|
|
}
|
2021-02-25 09:09:38 +01:00
|
|
|
settingsString +=
|
|
|
|
"FuncCalls=" + std::to_string(numberOfFunctionCalls) +
|
|
|
|
" Accuracy=" + std::to_string(solutionAccuracy) +
|
2021-03-01 13:34:27 +01:00
|
|
|
" Norm=" + normalizationStrategyStrings[normalizationStrategy];
|
2021-02-10 12:19:37 +01:00
|
|
|
|
|
|
|
return settingsString;
|
|
|
|
}
|
|
|
|
|
2021-02-22 10:28:01 +01:00
|
|
|
void writeHeaderTo(csvFile &os) const {
|
|
|
|
if (!xRanges.empty()) {
|
|
|
|
for (const xRange &range : xRanges) {
|
|
|
|
os << range.label + " max";
|
|
|
|
os << range.label + " min";
|
2021-02-10 12:19:37 +01:00
|
|
|
}
|
|
|
|
}
|
2021-02-22 10:28:01 +01:00
|
|
|
os << "Function Calls";
|
|
|
|
os << "Solution Accuracy";
|
2021-03-01 13:34:27 +01:00
|
|
|
os << "Normalization strategy";
|
2021-02-22 10:28:01 +01:00
|
|
|
// os << std::endl;
|
|
|
|
}
|
2021-02-10 12:19:37 +01:00
|
|
|
|
2021-02-22 10:28:01 +01:00
|
|
|
void writeSettingsTo(csvFile &os) const {
|
2021-02-10 12:19:37 +01:00
|
|
|
if (!xRanges.empty()) {
|
|
|
|
for (const xRange &range : xRanges) {
|
2021-02-19 16:32:15 +01:00
|
|
|
os << range.max;
|
|
|
|
os << range.min;
|
2021-02-10 12:19:37 +01:00
|
|
|
}
|
|
|
|
}
|
2021-02-19 16:32:15 +01:00
|
|
|
os << numberOfFunctionCalls;
|
|
|
|
os << solutionAccuracy;
|
2021-03-01 13:34:27 +01:00
|
|
|
os << normalizationStrategyStrings[normalizationStrategy] + "_" +
|
|
|
|
std::to_string(normalizationParameter);
|
2021-02-10 12:19:37 +01:00
|
|
|
}
|
2021-01-22 15:39:36 +01:00
|
|
|
};
|
2021-02-24 18:41:12 +01:00
|
|
|
struct Results {
|
|
|
|
double time{-1};
|
|
|
|
int numberOfSimulationCrashes{0};
|
|
|
|
std::vector<double> x;
|
|
|
|
double objectiveValue;
|
2021-03-01 13:34:27 +01:00
|
|
|
double rawObjectiveValue;
|
2021-02-24 21:10:42 +01:00
|
|
|
std::vector<double> objectiveValuePerSimulationScenario;
|
2021-02-24 18:41:12 +01:00
|
|
|
std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs;
|
|
|
|
std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs;
|
|
|
|
|
|
|
|
void save(const string &saveToPath) const {
|
|
|
|
assert(std::filesystem::is_directory(saveToPath));
|
|
|
|
|
|
|
|
const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
|
|
|
|
for (int simulationJobIndex = 0;
|
|
|
|
simulationJobIndex < numberOfSimulationJobs; simulationJobIndex++) {
|
|
|
|
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob =
|
|
|
|
fullPatternSimulationJobs[simulationJobIndex];
|
|
|
|
std::filesystem::path simulationJobFolderPath(
|
|
|
|
std::filesystem::path(saveToPath)
|
|
|
|
.append(pFullPatternSimulationJob->label));
|
|
|
|
std::filesystem::create_directory(simulationJobFolderPath);
|
|
|
|
const auto fullPatternDirectoryPath =
|
|
|
|
std::filesystem::path(simulationJobFolderPath).append("Full");
|
|
|
|
std::filesystem::create_directory(fullPatternDirectoryPath);
|
|
|
|
pFullPatternSimulationJob->save(fullPatternDirectoryPath.string());
|
|
|
|
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob =
|
|
|
|
reducedPatternSimulationJobs[simulationJobIndex];
|
|
|
|
const auto reducedPatternDirectoryPath =
|
|
|
|
std::filesystem::path(simulationJobFolderPath).append("Reduced");
|
|
|
|
if (!std::filesystem::exists(reducedPatternDirectoryPath)) {
|
|
|
|
std::filesystem::create_directory(reducedPatternDirectoryPath);
|
|
|
|
}
|
|
|
|
pReducedPatternSimulationJob->save(
|
|
|
|
reducedPatternDirectoryPath.string());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void load(const string &loadFromPath) {
|
|
|
|
assert(std::filesystem::is_directory(loadFromPath));
|
|
|
|
|
|
|
|
for (const auto &directoryEntry :
|
|
|
|
filesystem::directory_iterator(loadFromPath)) {
|
|
|
|
const auto simulationScenarioPath = directoryEntry.path();
|
|
|
|
if (!std::filesystem::is_directory(simulationScenarioPath)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Load reduced pattern files
|
|
|
|
for (const auto &fileEntry : filesystem::directory_iterator(
|
|
|
|
std::filesystem::path(simulationScenarioPath)
|
|
|
|
.append("Full"))) {
|
|
|
|
const auto filepath = fileEntry.path();
|
|
|
|
if (filepath.extension() == ".json") {
|
|
|
|
SimulationJob job;
|
|
|
|
job.load(filepath.string());
|
|
|
|
fullPatternSimulationJobs.push_back(
|
|
|
|
std::make_shared<SimulationJob>(job));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load full pattern files
|
|
|
|
for (const auto &fileEntry : filesystem::directory_iterator(
|
|
|
|
std::filesystem::path(simulationScenarioPath)
|
|
|
|
.append("Reduced"))) {
|
|
|
|
const auto filepath = fileEntry.path();
|
|
|
|
if (filepath.extension() == ".json") {
|
|
|
|
SimulationJob job;
|
|
|
|
job.load(filepath.string());
|
|
|
|
reducedPatternSimulationJobs.push_back(
|
|
|
|
std::make_shared<SimulationJob>(job));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if POLYSCOPE_DEFINED
|
|
|
|
void draw() const {
|
|
|
|
initPolyscope();
|
|
|
|
FormFinder simulator;
|
|
|
|
assert(fullPatternSimulationJobs.size() ==
|
|
|
|
reducedPatternSimulationJobs.size());
|
2021-03-01 13:34:27 +01:00
|
|
|
fullPatternSimulationJobs[0]->pMesh->registerForDrawing(
|
|
|
|
colors.fullInitial);
|
|
|
|
reducedPatternSimulationJobs[0]->pMesh->registerForDrawing(
|
|
|
|
colors.reducedInitial);
|
2021-02-24 18:41:12 +01:00
|
|
|
|
|
|
|
const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
|
|
|
|
for (int simulationJobIndex = 0;
|
|
|
|
simulationJobIndex < numberOfSimulationJobs; simulationJobIndex++) {
|
|
|
|
// Drawing of full pattern results
|
|
|
|
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob =
|
|
|
|
fullPatternSimulationJobs[simulationJobIndex];
|
|
|
|
pFullPatternSimulationJob->registerForDrawing(
|
|
|
|
fullPatternSimulationJobs[0]->pMesh->getLabel());
|
|
|
|
SimulationResults fullModelResults =
|
|
|
|
simulator.executeSimulation(pFullPatternSimulationJob);
|
2021-03-01 13:34:27 +01:00
|
|
|
fullModelResults.registerForDrawing(colors.fullDeformed);
|
2021-02-24 18:41:12 +01:00
|
|
|
// Drawing of reduced pattern results
|
|
|
|
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob =
|
|
|
|
reducedPatternSimulationJobs[simulationJobIndex];
|
|
|
|
SimulationResults reducedModelResults =
|
|
|
|
simulator.executeSimulation(pReducedPatternSimulationJob);
|
2021-03-01 13:34:27 +01:00
|
|
|
reducedModelResults.registerForDrawing(colors.reducedDeformed);
|
|
|
|
polyscope::options::programName =
|
|
|
|
fullPatternSimulationJobs[0]->pMesh->getLabel();
|
2021-02-24 18:41:12 +01:00
|
|
|
polyscope::show();
|
|
|
|
// Save a screensh
|
2021-02-24 21:10:42 +01:00
|
|
|
const std::string screenshotFilename =
|
|
|
|
"/home/iason/Coding/Projects/Approximating shapes with flat "
|
|
|
|
"patterns/RodModelOptimizationForPatterns/Results/Images/" +
|
|
|
|
pFullPatternSimulationJob->pMesh->getLabel() + "_" +
|
|
|
|
simulationScenarioStrings[simulationJobIndex];
|
|
|
|
polyscope::screenshot(screenshotFilename, false);
|
2021-02-24 18:41:12 +01:00
|
|
|
fullModelResults.unregister();
|
|
|
|
reducedModelResults.unregister();
|
2021-02-24 21:10:42 +01:00
|
|
|
// double error = computeError(
|
|
|
|
// reducedModelResults.displacements,fullModelResults.displacements,
|
|
|
|
// );
|
|
|
|
// std::cout << "Error of simulation scenario "
|
|
|
|
// <<
|
|
|
|
// simulationScenarioStrings[simulationScenarioIndex]
|
|
|
|
// << " is "
|
|
|
|
// << error << std::endl;
|
2021-02-24 18:41:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // POLYSCOPE_DEFINED
|
|
|
|
void saveMeshFiles() const {
|
|
|
|
const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
|
|
|
|
assert(numberOfSimulationJobs != 0 &&
|
|
|
|
fullPatternSimulationJobs.size() ==
|
|
|
|
reducedPatternSimulationJobs.size());
|
|
|
|
|
|
|
|
fullPatternSimulationJobs[0]->pMesh->savePly(
|
|
|
|
"FullPattern_undeformed.ply");
|
|
|
|
reducedPatternSimulationJobs[0]->pMesh->savePly(
|
|
|
|
"ReducedPattern_undeformed.ply");
|
|
|
|
FormFinder simulator;
|
|
|
|
for (int simulationJobIndex = 0;
|
|
|
|
simulationJobIndex < numberOfSimulationJobs; simulationJobIndex++) {
|
|
|
|
// Drawing of full pattern results
|
|
|
|
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob =
|
|
|
|
fullPatternSimulationJobs[simulationJobIndex];
|
|
|
|
SimulationResults fullModelResults =
|
|
|
|
simulator.executeSimulation(pFullPatternSimulationJob);
|
|
|
|
fullModelResults.saveDeformedModel();
|
|
|
|
|
|
|
|
// Drawing of reduced pattern results
|
|
|
|
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob =
|
|
|
|
reducedPatternSimulationJobs[simulationJobIndex];
|
|
|
|
SimulationResults reducedModelResults =
|
|
|
|
simulator.executeSimulation(pReducedPatternSimulationJob);
|
|
|
|
reducedModelResults.saveDeformedModel();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
writeHeaderTo(const ReducedModelOptimizer::Settings &settings_optimization,
|
|
|
|
csvFile &os) {
|
2021-03-01 13:34:27 +01:00
|
|
|
os << "Total raw Obj value";
|
2021-02-24 21:10:42 +01:00
|
|
|
os << "Total Obj value";
|
|
|
|
for (int simulationScenarioIndex = 0;
|
|
|
|
simulationScenarioIndex <
|
|
|
|
SimulationScenario::NumberOfSimulationScenarios;
|
|
|
|
simulationScenarioIndex++) {
|
|
|
|
os << "Obj value " + simulationScenarioStrings[simulationScenarioIndex];
|
|
|
|
}
|
2021-02-24 18:41:12 +01:00
|
|
|
for (const ReducedModelOptimizer::xRange &range :
|
|
|
|
settings_optimization.xRanges) {
|
|
|
|
os << range.label;
|
|
|
|
}
|
|
|
|
os << "Time(s)";
|
|
|
|
os << "#Crashes";
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
writeResultsTo(const ReducedModelOptimizer::Settings &settings_optimization,
|
|
|
|
csvFile &os) const {
|
2021-03-01 13:34:27 +01:00
|
|
|
os << rawObjectiveValue;
|
2021-02-24 18:41:12 +01:00
|
|
|
os << objectiveValue;
|
2021-02-24 21:10:42 +01:00
|
|
|
for (double scenarioObjValue : objectiveValuePerSimulationScenario) {
|
|
|
|
os << scenarioObjValue;
|
|
|
|
}
|
2021-02-24 18:41:12 +01:00
|
|
|
for (const double &optimalX : x) {
|
|
|
|
os << optimalX;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int unusedXVarCounter = 0;
|
|
|
|
unusedXVarCounter < settings_optimization.xRanges.size() - x.size();
|
|
|
|
unusedXVarCounter++) {
|
|
|
|
os << "-";
|
|
|
|
}
|
|
|
|
|
|
|
|
os << time;
|
|
|
|
if (numberOfSimulationCrashes == 0) {
|
|
|
|
os << "-";
|
|
|
|
} else {
|
|
|
|
os << numberOfSimulationCrashes;
|
|
|
|
}
|
2021-02-10 12:19:37 +01:00
|
|
|
}
|
2021-01-22 15:39:36 +01:00
|
|
|
};
|
|
|
|
|
2021-01-04 13:12:25 +01:00
|
|
|
inline static const std::string simulationScenarioStrings[] = {
|
2021-02-24 18:41:12 +01:00
|
|
|
"Axial", "Shear", "Bending", "Dome", "Saddle"};
|
2021-01-22 15:39:36 +01:00
|
|
|
Results optimize(const Settings &xRanges,
|
|
|
|
const std::vector<SimulationScenario> &simulationScenarios =
|
|
|
|
std::vector<SimulationScenario>());
|
2020-11-23 10:06:45 +01:00
|
|
|
double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;
|
|
|
|
|
2020-11-27 11:45:20 +01:00
|
|
|
ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot);
|
2021-01-04 13:12:25 +01:00
|
|
|
static void computeReducedModelSimulationJob(
|
2020-11-23 10:06:45 +01:00
|
|
|
const SimulationJob &simulationJobOfFullModel,
|
2021-01-04 13:12:25 +01:00
|
|
|
const std::unordered_map<size_t, size_t> &simulationJobFullToReducedMap,
|
2020-11-23 10:06:45 +01:00
|
|
|
SimulationJob &simulationJobOfReducedModel);
|
|
|
|
|
|
|
|
SimulationJob
|
|
|
|
getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);
|
|
|
|
|
2020-12-21 16:56:21 +01:00
|
|
|
void initializePatterns(
|
|
|
|
FlatPattern &fullPattern, FlatPattern &reducedPatterm,
|
|
|
|
const std::unordered_set<size_t> &reducedModelExcludedEges);
|
2020-11-27 11:45:20 +01:00
|
|
|
|
2020-12-16 20:31:58 +01:00
|
|
|
void setInitialGuess(std::vector<double> v);
|
|
|
|
|
2021-01-04 13:12:25 +01:00
|
|
|
static void runBeamOptimization();
|
|
|
|
|
|
|
|
static void runSimulation(const std::string &filename,
|
|
|
|
std::vector<double> &x);
|
|
|
|
|
2021-01-12 13:41:40 +01:00
|
|
|
static double objective(double x0, double x1, double x2, double x3);
|
2021-02-24 18:41:12 +01:00
|
|
|
static double objective(double b, double r, double E);
|
2021-01-12 13:41:40 +01:00
|
|
|
|
2021-02-11 12:52:27 +01:00
|
|
|
static std::vector<std::shared_ptr<SimulationJob>>
|
|
|
|
createScenarios(const std::shared_ptr<SimulationMesh> &pMesh,
|
|
|
|
const std::unordered_map<size_t, size_t>
|
|
|
|
&fullPatternOppositeInterfaceViMap);
|
|
|
|
static void createSimulationMeshes(
|
|
|
|
FlatPattern &fullModel, FlatPattern &reducedModel,
|
|
|
|
std::shared_ptr<SimulationMesh> &pFullPatternSimulationMesh,
|
|
|
|
std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh);
|
|
|
|
static void computeMaps(
|
|
|
|
const std::unordered_set<size_t> &reducedModelExcludedEdges,
|
|
|
|
const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode,
|
|
|
|
FlatPattern &fullPattern, FlatPattern &reducedPattern,
|
|
|
|
std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
|
|
|
|
&reducedToFullInterfaceViMap,
|
|
|
|
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
|
|
|
|
&fullToReducedInterfaceViMap,
|
|
|
|
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
|
|
|
|
&fullPatternOppositeInterfaceViMap);
|
2021-03-01 13:34:27 +01:00
|
|
|
static void
|
|
|
|
visualizeResults(const std::vector<std::shared_ptr<SimulationJob>>
|
|
|
|
&fullPatternSimulationJobs,
|
|
|
|
const std::vector<std::shared_ptr<SimulationJob>>
|
|
|
|
&reducedPatternSimulationJobs,
|
|
|
|
const std::vector<SimulationScenario> &simulationScenarios,
|
|
|
|
const std::unordered_map<ReducedPatternVertexIndex,
|
|
|
|
FullPatternVertexIndex>
|
|
|
|
&reducedToFullInterfaceViMap);
|
2021-02-24 21:10:42 +01:00
|
|
|
static void registerResultsForDrawing(
|
2021-02-24 18:41:12 +01:00
|
|
|
const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob,
|
|
|
|
const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob,
|
2021-02-25 09:09:38 +01:00
|
|
|
const std::unordered_map<ReducedPatternVertexIndex,
|
|
|
|
FullPatternVertexIndex>
|
2021-03-01 13:34:27 +01:00
|
|
|
&reducedToFullInterfaceViMap);
|
2021-02-24 18:41:12 +01:00
|
|
|
|
|
|
|
static double
|
|
|
|
computeRawError(const std::vector<Vector6d> &reducedPatternDisplacements,
|
|
|
|
const std::vector<Vector6d> &fullPatternDisplacements,
|
|
|
|
const std::unordered_map<ReducedPatternVertexIndex,
|
|
|
|
FullPatternVertexIndex>
|
|
|
|
&reducedToFullInterfaceViMap);
|
2021-02-11 12:52:27 +01:00
|
|
|
|
2021-02-24 18:41:12 +01:00
|
|
|
static double
|
|
|
|
computeError(const std::vector<Vector6d> &reducedPatternDisplacements,
|
|
|
|
const std::vector<Vector6d> &fullPatternDisplacements,
|
|
|
|
const std::unordered_map<ReducedPatternVertexIndex,
|
|
|
|
FullPatternVertexIndex>
|
|
|
|
&reducedToFullInterfaceViMap,
|
|
|
|
const double &normalizationFactor);
|
2021-02-11 12:52:27 +01:00
|
|
|
|
2020-11-23 10:06:45 +01:00
|
|
|
private:
|
2021-01-04 13:12:25 +01:00
|
|
|
static void computeDesiredReducedModelDisplacements(
|
2020-11-23 10:06:45 +01:00
|
|
|
const SimulationResults &fullModelResults,
|
2021-01-04 13:12:25 +01:00
|
|
|
const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
|
2020-11-27 11:45:20 +01:00
|
|
|
Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
|
2021-02-12 17:09:56 +01:00
|
|
|
static Results runOptimization(const Settings &settings);
|
2021-01-04 13:12:25 +01:00
|
|
|
std::vector<std::shared_ptr<SimulationJob>>
|
2020-11-27 11:45:20 +01:00
|
|
|
createScenarios(const std::shared_ptr<SimulationMesh> &pMesh);
|
|
|
|
void computeMaps(FlatPattern &fullModel, FlatPattern &reducedPattern,
|
|
|
|
const std::unordered_set<size_t> &reducedModelExcludedEges);
|
|
|
|
void createSimulationMeshes(FlatPattern &fullModel,
|
|
|
|
FlatPattern &reducedModel);
|
2021-01-04 13:12:25 +01:00
|
|
|
static void
|
2021-01-17 12:46:33 +01:00
|
|
|
initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh);
|
2020-12-09 16:58:48 +01:00
|
|
|
|
2021-01-04 13:12:25 +01:00
|
|
|
static double objective(long n, const double *x);
|
2021-02-01 15:10:24 +01:00
|
|
|
FormFinder simulator;
|
2021-03-01 13:34:27 +01:00
|
|
|
void computeObjectiveValueNormalizationFactors();
|
2020-11-23 10:06:45 +01:00
|
|
|
};
|
|
|
|
#endif // REDUCEDMODELOPTIMIZER_HPP
|