572 lines
30 KiB
C++
572 lines
30 KiB
C++
#include "reducedmodelevaluator.hpp"
|
|
#include "hexagonremesher.hpp"
|
|
#include "reducedmodel.hpp"
|
|
#include "reducedmodeloptimizer.hpp"
|
|
#include "trianglepatterngeometry.hpp"
|
|
#include <execution>
|
|
#include <filesystem>
|
|
|
|
using FullPatternVertexIndex = VertexIndex;
|
|
using ReducedPatternVertexIndex = VertexIndex;
|
|
|
|
ReducedModelEvaluator::ReducedModelEvaluator()
|
|
{
|
|
pTileIntoSurface = [&]() {
|
|
std::istringstream inputStream_tileIntoTriSurface(tileIntoSurfaceFileContent);
|
|
VCGTriMesh tileInto_triMesh;
|
|
const bool surfaceLoadSuccessfull = tileInto_triMesh.load(inputStream_tileIntoTriSurface);
|
|
tileInto_triMesh.setLabel("instantMeshes_plane_34");
|
|
assert(surfaceLoadSuccessfull);
|
|
return PolygonalRemeshing::remeshWithPolygons(tileInto_triMesh);
|
|
}();
|
|
}
|
|
|
|
//double ReducedModelEvaluator::evaluateOptimizationSettings(
|
|
// const ReducedModelOptimization::Settings &optimizationSettings,
|
|
// const std::vector<std::shared_ptr<PatternGeometry>> &pPatterns,
|
|
// std::vector<ReducedModelEvaluator::Results> &patternEvaluationResults)
|
|
//{
|
|
// assert(!pPatterns.empty());
|
|
// double optimizationError = 0;
|
|
// auto start = std::chrono::high_resolution_clock::now();
|
|
// std::vector<double> averageNormalizedError(pPatterns.size(), 0);
|
|
// patternEvaluationResults.clear();
|
|
// patternEvaluationResults.resize(pPatterns.size());
|
|
// std::for_each(
|
|
// // std::execution::par_unseq,
|
|
// pPatterns.begin(),
|
|
// pPatterns.end(),
|
|
// [&](const std::shared_ptr<ConstPatternGeometry> &pPattern) {
|
|
// // std::cout << "Optimizing " << pPattern->getLabel() << std::endl;
|
|
// ReducedModelOptimization::Results optimizationResults;
|
|
// ReducedModelOptimizer optimizer;
|
|
// optimizer.optimize(*pPattern, optimizationSettings, optimizationResults);
|
|
// const auto evaluationResults
|
|
// = ReducedModelEvaluator::evaluateReducedModel(optimizationResults,
|
|
// tileIntoSurfaceFilePath,
|
|
// scenariosDirPath,
|
|
// fullPatternTessellatedResultsDirPath);
|
|
// const double averageNormalizedErrorOfPattern
|
|
// = std::reduce(evaluationResults.distances_normalizedDrm2reduced.begin(),
|
|
// evaluationResults.distances_normalizedDrm2reduced.end())
|
|
// / evaluationResults.distances_normalizedDrm2reduced.size();
|
|
// const int patternIndex = &pPattern - &patterns[0];
|
|
// averageNormalizedError[patternIndex] = averageNormalizedErrorOfPattern;
|
|
// patternsEvaluationResults[patternIndex] = evaluationResults;
|
|
// });
|
|
// const double strategyAverageNormalizedError = std::reduce(std::execution::par_unseq,
|
|
// averageNormalizedError.begin(),
|
|
// averageNormalizedError.end())
|
|
// / pPointers.size();
|
|
// const auto totalDuration_min = std::chrono::duration_cast<std::chrono::seconds>(
|
|
// std::chrono::high_resolution_clock::now() - start)
|
|
// .count()
|
|
// / 60.0;
|
|
// std::cout << "Optimized pattern(s) in:" << totalDuration_min << " minutes." << std::endl;
|
|
// std::cout << "Average time per pattern:" << totalDuration_min / patternsPointers.size()
|
|
// << " minutes." << std::endl;
|
|
// std::cout << "Objective value:" << strategyAverageNormalizedError << std::endl;
|
|
// return strategyAverageNormalizedError;
|
|
// // std::cout << "After:" << ++numberOfOptimizationRoundsExecuted << " iterations." << std::endl;
|
|
//}
|
|
|
|
ReducedModelEvaluator::Results ReducedModelEvaluator::evaluateReducedModel(
|
|
ReducedModelOptimization::Results &optimizationResult)
|
|
{
|
|
const std::filesystem::path scenariosDirectoryPath
|
|
= "/home/iason/Coding/Projects/Approximating shapes with flat "
|
|
"patterns/ReducedModelEvaluator/Scenarios";
|
|
const std::filesystem::path fullPatternTessellatedResultsDirectoryPath
|
|
= "/home/iason/Coding/Projects/Approximating shapes with flat "
|
|
"patterns/ReducedModelEvaluator/TessellatedResults";
|
|
|
|
return evaluateReducedModel(optimizationResult,
|
|
scenariosDirectoryPath,
|
|
fullPatternTessellatedResultsDirectoryPath);
|
|
}
|
|
//void ReducedModelEvaluator::printResults(const Results &evaluationResults,
|
|
// const std::string &resultsLabel,
|
|
// const std::filesystem::path &resultsOutputPath)
|
|
//{
|
|
// const bool outputPathIsDirectory = !resultsOutputPath.empty()
|
|
// && !resultsOutputPath.has_extension();
|
|
// const bool outputPathIsFile = !resultsOutputPath.empty() && resultsOutputPath.has_extension();
|
|
// assert(outputPathIsDirectory && outputPathIsFile);
|
|
// if (outputPathIsDirectory) {
|
|
// std::filesystem::create_directories(resultsOutputPath);
|
|
// }
|
|
|
|
//#else
|
|
// std::filesystem::path csvOutputFilePath;
|
|
// bool shouldOverwrite = false;
|
|
// if (outputPathIsDirectory) {
|
|
// csvOutputFilePath = std::filesystem::path(resultsOutputPath)
|
|
// .append("distances_" + resultsLabel + ".csv")
|
|
// .string();
|
|
// shouldOverwrite = true;
|
|
// } else if (outputPathIsFile) {
|
|
// csvOutputFilePath = resultsOutputPath;
|
|
// }
|
|
|
|
// csvFile csvOutput(csvOutputFilePath, shouldOverwrite);
|
|
// printResults(evaluationResults, resultsLabel, csvOutput);
|
|
//}
|
|
|
|
void ReducedModelEvaluator::printResults(const Results &evaluationResults,
|
|
const std::string &resultsLabel)
|
|
{
|
|
csvFile csvOutputToCout({}, true);
|
|
Settings exportSettings;
|
|
exportSettings.exportingDirection = Vertical;
|
|
exportSettings.shouldWriteHeader = false;
|
|
exportSettings.resultsLabel = resultsLabel;
|
|
printResults(evaluationResults, exportSettings, csvOutputToCout);
|
|
}
|
|
|
|
void ReducedModelEvaluator::printResults(const Results &evaluationResults,
|
|
const Settings &settings,
|
|
csvFile &csvOutput)
|
|
{
|
|
if (settings.shouldWriteHeader) {
|
|
csvOutput << csvExportingDataStrings[settings.exportingData];
|
|
printHeader(settings, csvOutput);
|
|
// csvOutput << "Average error";
|
|
// csvOutput<<"Cumulative error";
|
|
csvOutput << endrow;
|
|
}
|
|
if (!settings.resultsLabel.empty()) {
|
|
csvOutput << settings.resultsLabel;
|
|
}
|
|
if (settings.exportingDirection == Vertical) {
|
|
printResultsVertically(evaluationResults, csvOutput);
|
|
} else {
|
|
printResultsHorizontally(evaluationResults, csvOutput);
|
|
}
|
|
}
|
|
|
|
void ReducedModelEvaluator::printHeader(const Settings &settings, csvFile &csvOutput)
|
|
{
|
|
if (settings.exportingDirection == Horizontal) {
|
|
// csvOutput << "Job label";
|
|
for (int jobIndex = 0; jobIndex < ReducedModelEvaluator::scenariosTestSetLabels.size();
|
|
jobIndex++) {
|
|
const std::string &jobLabel = ReducedModelEvaluator::scenariosTestSetLabels[jobIndex];
|
|
csvOutput << jobLabel;
|
|
}
|
|
} else {
|
|
std::cout << "Vertical header not defined" << std::endl;
|
|
assert(false);
|
|
std::terminate();
|
|
}
|
|
}
|
|
|
|
void ReducedModelEvaluator::printResultsHorizontally(const Results &evaluationResults,
|
|
csvFile &csvOutput)
|
|
{
|
|
//print header
|
|
//print raw error
|
|
constexpr bool shouldPrintRawError = false;
|
|
if (shouldPrintRawError) {
|
|
// csvOutput << "drm2Reduced";
|
|
double sumOfFull2Reduced = 0;
|
|
int numOfNonEvaluatedScenarios = 0;
|
|
for (int jobIndex = 0; jobIndex < ReducedModelEvaluator::scenariosTestSetLabels.size();
|
|
jobIndex++) {
|
|
const double &distance_fullDrmToReduced = evaluationResults
|
|
.distances_drm2reduced[jobIndex];
|
|
if (distance_fullDrmToReduced == -1) {
|
|
csvOutput << "notEvaluated";
|
|
numOfNonEvaluatedScenarios++;
|
|
} else {
|
|
csvOutput << distance_fullDrmToReduced;
|
|
sumOfFull2Reduced += distance_fullDrmToReduced;
|
|
}
|
|
}
|
|
// const int numOfEvaluatedScenarios = ReducedModelEvaluator::scenariosTestSetLabels.size()
|
|
// - numOfNonEvaluatedScenarios;
|
|
// const double averageDistance_full2Reduced = sumOfFull2Reduced / numOfEvaluatedScenarios;
|
|
// csvOutput << averageDistance_full2Reduced;
|
|
// csvOutput << endrow;
|
|
}
|
|
//print normalized error
|
|
// csvOutput << "norm_drm2Reduced";
|
|
double sumOfNormalizedFull2Reduced = 0;
|
|
for (int jobIndex = 0; jobIndex < ReducedModelEvaluator::scenariosTestSetLabels.size();
|
|
jobIndex++) {
|
|
const double &distance_normalizedFullDrmToReduced
|
|
= evaluationResults.distances_normalizedDrm2reduced[jobIndex];
|
|
if (distance_normalizedFullDrmToReduced == -1) {
|
|
csvOutput << "notEvaluated";
|
|
} else {
|
|
csvOutput << distance_normalizedFullDrmToReduced;
|
|
sumOfNormalizedFull2Reduced += distance_normalizedFullDrmToReduced;
|
|
}
|
|
}
|
|
// const double averageDistance_normalizedFull2Reduced = sumOfNormalizedFull2Reduced
|
|
// / numOfEvaluatedScenarios;
|
|
// csvOutput << averageDistance_normalizedFull2Reduced;
|
|
// csvOutput << endrow;
|
|
}
|
|
|
|
void ReducedModelEvaluator::printResultsVertically(const Results &evaluationResults,
|
|
csvFile &csvOutput)
|
|
{
|
|
#ifdef POLYSCOPE_DEFINED
|
|
csvOutput << "drm2Reduced"
|
|
<< "norm_drm2Reduced";
|
|
#else
|
|
csvOutput << "Job Label"
|
|
<< "drm2Reduced"
|
|
<< "norm_drm2Reduced";
|
|
|
|
#endif
|
|
csvOutput << endrow;
|
|
double sumOfFull2Reduced = 0;
|
|
double sumOfNormalizedFull2Reduced = 0;
|
|
int numOfNonEvaluatedScenarios = 0;
|
|
for (int jobIndex = 0; jobIndex < ReducedModelEvaluator::scenariosTestSetLabels.size();
|
|
jobIndex++) {
|
|
const double &distance_fullDrmToReduced = evaluationResults.distances_drm2reduced[jobIndex];
|
|
const double &distance_normalizedFullDrmToReduced
|
|
= evaluationResults.distances_normalizedDrm2reduced[jobIndex];
|
|
#ifndef POLYSCOPE_DEFINED
|
|
const std::string &jobLabel = ReducedModelEvaluator::scenariosTestSetLabels[jobIndex];
|
|
csvOutput << jobLabel;
|
|
#endif
|
|
if (distance_fullDrmToReduced == -1) {
|
|
csvOutput << "notEvaluated"
|
|
<< "notEvaluated";
|
|
numOfNonEvaluatedScenarios++;
|
|
} else {
|
|
csvOutput << distance_fullDrmToReduced << distance_normalizedFullDrmToReduced;
|
|
sumOfFull2Reduced += distance_fullDrmToReduced;
|
|
sumOfNormalizedFull2Reduced += distance_normalizedFullDrmToReduced;
|
|
}
|
|
csvOutput << endrow;
|
|
// sumOfNormalizedFull2Reduced += distance_normalizedFullDrmToReduced;
|
|
}
|
|
const int numOfEvaluatedScenarios = ReducedModelEvaluator::scenariosTestSetLabels.size()
|
|
- numOfNonEvaluatedScenarios;
|
|
const double averageDistance_full2Reduced = sumOfFull2Reduced / numOfEvaluatedScenarios;
|
|
const double averageDistance_normalizedFull2Reduced = sumOfNormalizedFull2Reduced
|
|
/ numOfEvaluatedScenarios;
|
|
#ifndef POLYSCOPE_DEFINED
|
|
csvOutput << "Average error";
|
|
#endif
|
|
csvOutput << averageDistance_full2Reduced << averageDistance_normalizedFull2Reduced;
|
|
csvOutput << endrow;
|
|
#ifndef POLYSCOPE_DEFINED
|
|
csvOutput << "Cumulative error";
|
|
#endif
|
|
csvOutput << sumOfFull2Reduced << sumOfNormalizedFull2Reduced;
|
|
csvOutput << endrow;
|
|
csvOutput << endrow;
|
|
}
|
|
|
|
//void ReducedModelEvaluator::createFullAndReducedPatternTessellations(){
|
|
|
|
//}
|
|
|
|
//ReducedModelEvaluator::Results ReducedModelEvaluator::evaluateReducedModel(
|
|
// std::vector<ReducedModelOptimization::Results> &optimizationResults,
|
|
// const std::filesystem::path &tileInto_triMesh_filePath,
|
|
// const std::filesystem::path &scenariosDirectoryPath,
|
|
// // const std::filesystem::path &reducedPatternFilePath,
|
|
// const std::filesystem::path &fullPatternTessellatedResultsDirectoryPath)
|
|
//{
|
|
// //Load surface
|
|
// std::shared_ptr<VCGPolyMesh> pTileIntoSurface = [&]() {
|
|
// VCGTriMesh tileInto_triMesh;
|
|
// const bool surfaceLoadSuccessfull = tileInto_triMesh.load(tileInto_triMesh_filePath);
|
|
// assert(surfaceLoadSuccessfull);
|
|
// return PolygonalRemeshing::remeshWithPolygons(tileInto_triMesh);
|
|
// }();
|
|
// const double optimizedBaseTriangleHeight = vcg::Distance(optimizationResult.baseTriangle.cP(0),
|
|
// (optimizationResult.baseTriangle.cP(1)
|
|
// + optimizationResult.baseTriangle.cP(
|
|
// 2))
|
|
// / 2);
|
|
// pTileIntoSurface->moveToCenter();
|
|
// const double scaleFactor = optimizedBaseTriangleHeight
|
|
// / pTileIntoSurface->getAverageFaceRadius();
|
|
// vcg::tri::UpdatePosition<VCGPolyMesh>::Scale(*pTileIntoSurface, scaleFactor);
|
|
// //Tile full pattern into surface
|
|
|
|
//}
|
|
|
|
ReducedModelEvaluator::Results ReducedModelEvaluator::evaluateReducedModel(
|
|
ReducedModelOptimization::Results &optimizationResult,
|
|
const std::filesystem::path &scenariosDirectoryPath,
|
|
const std::filesystem::path &fullPatternTessellatedResultsDirectoryPath)
|
|
{
|
|
// const double optimizedBaseTriangleHeight = vcg::Distance(optimizationResult.baseTriangle.cP(0),
|
|
// (optimizationResult.baseTriangle.cP(1)
|
|
// + optimizationResult.baseTriangle.cP(
|
|
// 2))
|
|
// / 2);
|
|
pTileIntoSurface->moveToCenter();
|
|
const double scaleFactor = optimizationResult.settings.targetBaseTriangleSize
|
|
/ pTileIntoSurface->getAverageFaceRadius();
|
|
vcg::tri::UpdatePosition<VCGPolyMesh>::Scale(*pTileIntoSurface, scaleFactor);
|
|
// tileIntoSurface.registerForDrawing();
|
|
// polyscope::show();
|
|
|
|
//Tile full pattern into surface
|
|
std::vector<PatternGeometry> fullPatterns(1);
|
|
fullPatterns[0].copy(optimizationResult.baseTriangleFullPattern);
|
|
//// Base triangle pattern might contain dangling vertices.Remove those
|
|
fullPatterns[0].interfaceNodeIndex = 3;
|
|
fullPatterns[0].deleteDanglingVertices();
|
|
std::vector<int> perSurfaceFacePatternIndices(pTileIntoSurface->FN(), 0);
|
|
std::vector<std::vector<size_t>> perPatternIndexTiledFullPatternEdgeIndices;
|
|
std::vector<size_t> tileIntoEdgeToTiledFullVi;
|
|
std::shared_ptr<PatternGeometry> pTiledFullPattern
|
|
= PatternGeometry::tilePattern(fullPatterns,
|
|
{},
|
|
*pTileIntoSurface,
|
|
perSurfaceFacePatternIndices,
|
|
tileIntoEdgeToTiledFullVi,
|
|
perPatternIndexTiledFullPatternEdgeIndices);
|
|
pTiledFullPattern->setLabel("Tiled_full_patterns");
|
|
// pTiledFullPattern->registerForDrawing();
|
|
//Tile reduced pattern into surface
|
|
// PatternGeometry reducedPattern;
|
|
ReducedModel reducedModel;
|
|
// reducedModel.registerForDrawing();
|
|
// polyscope::show();
|
|
reducedModel.deleteDanglingVertices();
|
|
// reducedPattern.interfaceNodeIndex = 1;
|
|
// assert(reducedPattern.interfaceNodeIndex == 1);
|
|
std::vector<PatternGeometry> reducedPatterns(1);
|
|
reducedPatterns[0].copy(reducedModel);
|
|
const auto reducedPatternBaseTriangle = reducedModel.computeBaseTriangle();
|
|
ReducedModelOptimization::Results::applyOptimizationResults_reducedModel_nonFanned(
|
|
optimizationResult, reducedPatternBaseTriangle, reducedPatterns[0]);
|
|
|
|
std::vector<std::vector<size_t>> perPatternIndexTiledReducedPatternEdgeIndices;
|
|
std::vector<size_t> tileIntoEdgeToTiledReducedVi;
|
|
std::shared_ptr<PatternGeometry> pTiledReducedPattern
|
|
= PatternGeometry::tilePattern(reducedPatterns,
|
|
{0},
|
|
*pTileIntoSurface,
|
|
perSurfaceFacePatternIndices,
|
|
tileIntoEdgeToTiledReducedVi,
|
|
perPatternIndexTiledReducedPatternEdgeIndices);
|
|
pTiledReducedPattern->setLabel("Tiled_reduced_patterns");
|
|
// pTiledReducedPattern->registerForDrawing();
|
|
// polyscope::show();
|
|
|
|
std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
|
|
fullToReducedViMap; //of only the common vertices
|
|
std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
|
|
reducedToFullViMap; //of only the common vertices
|
|
for (int ei = 0; ei < pTileIntoSurface->EN(); ei++) {
|
|
fullToReducedViMap[tileIntoEdgeToTiledFullVi[ei]] = tileIntoEdgeToTiledReducedVi[ei];
|
|
}
|
|
constructInverseMap(fullToReducedViMap, reducedToFullViMap);
|
|
|
|
std::vector<size_t> tilledFullPatternInterfaceVi;
|
|
tilledFullPatternInterfaceVi.clear();
|
|
tilledFullPatternInterfaceVi.resize(fullToReducedViMap.size());
|
|
size_t viIndex = 0;
|
|
for (std::pair<size_t, size_t> fullToReducedPair : fullToReducedViMap) {
|
|
tilledFullPatternInterfaceVi[viIndex++] = fullToReducedPair.first;
|
|
}
|
|
|
|
//Create simulation meshes
|
|
////Tessellated full pattern simulation mesh
|
|
std::shared_ptr<SimulationMesh> pTiledFullPattern_simulationMesh;
|
|
pTiledFullPattern_simulationMesh = std::make_shared<SimulationMesh>(*pTiledFullPattern);
|
|
//NOTE: Those should be derived from the optimization results instead of hardcoding them
|
|
pTiledFullPattern_simulationMesh->setBeamCrossSection(CrossSectionType{0.002, 0.002});
|
|
if (optimizationResult.fullPatternYoungsModulus == 0) {
|
|
std::cerr << "Full pattern's young modulus not found." << std::endl;
|
|
std::terminate();
|
|
}
|
|
pTiledFullPattern_simulationMesh->setBeamMaterial(0.3,
|
|
optimizationResult.fullPatternYoungsModulus);
|
|
pTiledFullPattern_simulationMesh->reset();
|
|
|
|
////Tessellated reduced pattern simulation mesh
|
|
std::shared_ptr<SimulationMesh> pTiledReducedPattern_simulationMesh;
|
|
pTiledReducedPattern_simulationMesh = std::make_shared<SimulationMesh>(*pTiledReducedPattern);
|
|
const std::vector<size_t> &tiledPatternElementIndicesForReducedPattern
|
|
= perPatternIndexTiledReducedPatternEdgeIndices[0];
|
|
ReducedModelOptimization::Results::applyOptimizationResults_elements(
|
|
optimizationResult, pTiledReducedPattern_simulationMesh);
|
|
// pTiledReducedPattern_simulationMesh->reset();
|
|
Results evaluationResults;
|
|
evaluationResults.distances_drm2reduced.fill(-1);
|
|
evaluationResults.distances_normalizedDrm2reduced.fill(-1);
|
|
DRMSimulationModel::Settings drmSimulationSettings;
|
|
drmSimulationSettings.totalExternalForcesNormPercentageTermination = 1e-3;
|
|
// drmSimulationSettings.load(drmSettingsFilePath);
|
|
drmSimulationSettings.beVerbose = true;
|
|
drmSimulationSettings.maxDRMIterations = 5e6;
|
|
drmSimulationSettings.debugModeStep = 100000;
|
|
drmSimulationSettings.translationalKineticEnergyThreshold = 1e-15;
|
|
drmSimulationSettings.linearGuessForceScaleFactor = 0.8;
|
|
drmSimulationSettings.viscousDampingFactor = 7e-3;
|
|
drmSimulationSettings.xi = 0.9999;
|
|
// drmSimulationSettings.Dtini = 5.86;
|
|
drmSimulationSettings.gamma = 0.25;
|
|
#ifdef POLYSCOPE_DEFINED
|
|
// drmSimulationSettings.shouldDraw = true;
|
|
drmSimulationSettings.shouldCreatePlots = true;
|
|
#endif
|
|
constexpr bool shouldRerunFullPatternSimulation = false;
|
|
// for (int jobIndex = 0; jobIndex < scenariosTestSetLabels.size(); jobIndex++) {
|
|
std::for_each(
|
|
//#ifndef POLYSCOPE_DEFINED
|
|
// std::execution::par_unseq,
|
|
//#endif
|
|
scenariosTestSetLabels.begin(),
|
|
scenariosTestSetLabels.end(),
|
|
[&](const std::string &jobLabel) {
|
|
//check if reduced model scenario exists
|
|
// const std::string &jobLabel = scenariosTestSetLabels[jobIndex];
|
|
const std::filesystem::path tiledReducedPatternJobFilePath
|
|
= std::filesystem::path(scenariosDirectoryPath)
|
|
.append(pTileIntoSurface->getLabel())
|
|
.append(jobLabel)
|
|
.append("ReducedJob")
|
|
.append(SimulationJob::jsonDefaultFileName);
|
|
if (!std::filesystem::exists(tiledReducedPatternJobFilePath)) {
|
|
std::cerr << "Scenario " << jobLabel
|
|
<< " not found in:" << tiledReducedPatternJobFilePath << std::endl;
|
|
// continue; //if not move on to the next scenario
|
|
return;
|
|
}
|
|
//Map the reduced job to the job on the pattern tessellation
|
|
//set jobs
|
|
std::shared_ptr<SimulationJob> pJob_tiledReducedPattern;
|
|
pJob_tiledReducedPattern = std::make_shared<SimulationJob>(SimulationJob());
|
|
pJob_tiledReducedPattern->load(tiledReducedPatternJobFilePath, false);
|
|
pJob_tiledReducedPattern->pMesh = pTiledReducedPattern_simulationMesh;
|
|
std::shared_ptr<SimulationJob> pJob_tiledFullPattern;
|
|
pJob_tiledFullPattern = std::make_shared<SimulationJob>(SimulationJob());
|
|
pJob_tiledFullPattern->pMesh = pTiledFullPattern_simulationMesh;
|
|
pJob_tiledReducedPattern->remap(reducedToFullViMap, *pJob_tiledFullPattern);
|
|
// pJob_tiledReducedPattern->registerForDrawing(pTiledReducedPattern->getLabel());
|
|
// pJob_tiledFullPattern->registerForDrawing(pTiledFullPattern->getLabel());
|
|
// polyscope::show();
|
|
const std::filesystem::path surfaceFolderPath
|
|
= std::filesystem::path(fullPatternTessellatedResultsDirectoryPath)
|
|
.append(pTileIntoSurface->getLabel());
|
|
const std::string scenarioLabel = pJob_tiledFullPattern->getLabel();
|
|
const std::filesystem::path scenarioDirectoryPath
|
|
= std::filesystem::path(surfaceFolderPath).append(scenarioLabel);
|
|
//Save reduced job
|
|
constexpr bool exportReducedJob = false;
|
|
if (exportReducedJob) {
|
|
const std::filesystem::path reducedJobDirectoryPath
|
|
= std::filesystem::path(scenarioDirectoryPath).append("ReducedJob");
|
|
std::filesystem::create_directories(reducedJobDirectoryPath);
|
|
pJob_tiledReducedPattern->save(reducedJobDirectoryPath);
|
|
}
|
|
//Check if the drm simulation of the full pattern has already been computed
|
|
////Full
|
|
const std::string &patternLabel = [&]() {
|
|
const std::string patternLabel = optimizationResult.baseTriangleFullPattern
|
|
.getLabel();
|
|
if (patternLabel.find("_") == std::string::npos) {
|
|
return std::to_string(optimizationResult.baseTriangleFullPattern.EN()) + "_"
|
|
+ patternLabel;
|
|
} else {
|
|
return patternLabel;
|
|
}
|
|
}();
|
|
const auto fullResultsFolderPath = std::filesystem::path(scenarioDirectoryPath)
|
|
.append(patternLabel)
|
|
.append("Results");
|
|
if (shouldRerunFullPatternSimulation && std::filesystem::exists(fullResultsFolderPath)) {
|
|
std::filesystem::remove_all(fullResultsFolderPath);
|
|
}
|
|
|
|
const std::filesystem::path fullPatternJobFolderPath = std::filesystem::path(
|
|
scenarioDirectoryPath)
|
|
.append(patternLabel)
|
|
.append("SimulationJob");
|
|
SimulationResults simulationResults_tiledFullPattern_drm;
|
|
if (std::filesystem::exists(fullResultsFolderPath)) {
|
|
//Load full pattern results
|
|
assert(std::filesystem::exists(fullPatternJobFolderPath));
|
|
simulationResults_tiledFullPattern_drm.load(fullResultsFolderPath,
|
|
fullPatternJobFolderPath);
|
|
//#ifdef POLYSCOPE_DEFINED
|
|
// std::array<double, 3> resultsColor({28.0, 99.0, 227.0});
|
|
// simulationResults_tiledFullPattern_drm.registerForDrawing(resultsColor);
|
|
// std::ifstream ifs("CameraSettings.json");
|
|
// nlohmann::json json;
|
|
// ifs >> json;
|
|
// polyscope::view::setCameraFromJson(json.dump(), false);
|
|
// // polyscope::show();
|
|
// const std::string cameraJson = polyscope::view::getCameraJson();
|
|
// std::filesystem::path jsonFilePath("CameraSettings.json");
|
|
// std::ofstream jsonFile_cameraSettings(jsonFilePath.string());
|
|
// jsonFile_cameraSettings << cameraJson;
|
|
// jsonFile_cameraSettings.close();
|
|
// std::filesystem::create_directories("screenshots");
|
|
// const std::string screenshotOutputFilePath
|
|
// = (std::filesystem::current_path()
|
|
// .append("screenshots")
|
|
// .append(optimizationResult.label + "_" + pJob_tiledFullPattern->getLabel()))
|
|
// .string()
|
|
// + ".png";
|
|
// // std::cout << "Saving image to:" << screenshotOutputFilePath << std::endl;
|
|
// polyscope::screenshot(screenshotOutputFilePath, false);
|
|
// simulationResults_tiledFullPattern_drm.unregister();
|
|
//#endif
|
|
|
|
simulationResults_tiledFullPattern_drm.converged = true;
|
|
} else {
|
|
std::cout << "Drm results not found in:" << fullResultsFolderPath << std::endl;
|
|
//Full
|
|
std::cout << "Executing:" << jobLabel << std::endl;
|
|
DRMSimulationModel drmSimulationModel;
|
|
simulationResults_tiledFullPattern_drm
|
|
= drmSimulationModel.executeSimulation(pJob_tiledFullPattern,
|
|
drmSimulationSettings);
|
|
simulationResults_tiledFullPattern_drm.setLabelPrefix("DRM");
|
|
}
|
|
if (!simulationResults_tiledFullPattern_drm.converged) {
|
|
std::cerr << "Full pattern simulation failed." << std::endl;
|
|
std::cerr << "Not saving results" << std::endl;
|
|
// continue;
|
|
return;
|
|
}
|
|
std::filesystem::create_directories(fullResultsFolderPath);
|
|
const std::filesystem::path drmResultsOutputPath
|
|
= std::filesystem::path(scenarioDirectoryPath).append(patternLabel);
|
|
simulationResults_tiledFullPattern_drm.save(drmResultsOutputPath);
|
|
|
|
LinearSimulationModel linearSimulationModel;
|
|
SimulationResults simulationResults_tiledReducedPattern
|
|
= linearSimulationModel.executeSimulation(pJob_tiledReducedPattern);
|
|
|
|
// simulationResults_tiledReducedPattern.registerForDrawing();
|
|
// simulationResults_tiledFullPattern_drm.registerForDrawing();
|
|
// polyscope::show();
|
|
|
|
//compute the full2reduced distance
|
|
const double distance_fullDrmToReduced
|
|
= simulationResults_tiledFullPattern_drm
|
|
.computeDistance(simulationResults_tiledReducedPattern, fullToReducedViMap);
|
|
double distance_fullSumOfAllVerts = 0;
|
|
for (std::pair<size_t, size_t> fullToReducedPair : fullToReducedViMap) {
|
|
distance_fullSumOfAllVerts += simulationResults_tiledFullPattern_drm
|
|
.displacements[fullToReducedPair.first]
|
|
.getTranslation()
|
|
.norm();
|
|
}
|
|
const double distance_normalizedFullDrmToReduced = distance_fullDrmToReduced
|
|
/ distance_fullSumOfAllVerts;
|
|
const int jobIndex = &jobLabel - &scenariosTestSetLabels[0];
|
|
evaluationResults.distances_drm2reduced[jobIndex] = distance_fullDrmToReduced;
|
|
evaluationResults.distances_normalizedDrm2reduced[jobIndex]
|
|
= distance_normalizedFullDrmToReduced;
|
|
});
|
|
|
|
return evaluationResults;
|
|
}
|