ReducedModelOptimization/src/main.cpp

126 lines
5.4 KiB
C++
Raw Normal View History

2021-01-22 15:39:36 +01:00
#include "csvfile.hpp"
#include "drmsimulationmodel.hpp"
2020-11-23 10:06:45 +01:00
#include "edgemesh.hpp"
#include "reducedmodeloptimizer.hpp"
#include "simulationhistoryplotter.hpp"
2020-12-09 16:58:48 +01:00
#include "trianglepattterntopology.hpp"
2020-11-23 10:06:45 +01:00
#include <chrono>
#include <filesystem>
#include <iostream>
#include <iterator>
2020-11-23 10:06:45 +01:00
#include <stdexcept>
#include <string>
2020-12-09 16:58:48 +01:00
#include <vcg/complex/algorithms/update/position.h>
#ifdef POLYSCOPE_DEFINED
#include "polyscope/curve_network.h"
#include "polyscope/point_cloud.h"
#include "polyscope/polyscope.h"
#endif
2020-11-23 10:06:45 +01:00
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cerr << "Specify at least the two pattern filepaths to be "
"optimized.Exiting.."
2021-02-19 16:32:15 +01:00
<< std::endl;
std::terminate();
}
2021-02-19 16:32:15 +01:00
// Populate the pattern pair to be optimized
const int interfaceNodeIndex=3;
////Full pattern
const std::string filepath_fullPattern = argv[1];
PatternGeometry fullPattern(filepath_fullPattern);
fullPattern.setLabel(
std::filesystem::path(filepath_fullPattern).stem().string());
fullPattern.scale(0.03,interfaceNodeIndex);
////Reduced pattern
const std::string filepath_reducedPattern = argv[2];
PatternGeometry reducedPattern(filepath_reducedPattern);
reducedPattern.setLabel(std::filesystem::path(filepath_reducedPattern).stem().string());
reducedPattern.scale(0.03, interfaceNodeIndex);
// Set the optization settings
ReducedPatternOptimization::xRange beamE{"E", 0.001, 1000};
ReducedPatternOptimization::xRange beamA{"A", 0.001, 1000};
ReducedPatternOptimization::xRange beamI2{"I2", 0.001, 1000};
ReducedPatternOptimization::xRange beamI3{"I3", 0.001, 1000};
ReducedPatternOptimization::xRange beamJ{"J", 0.001, 1000};
ReducedPatternOptimization::xRange innerHexagonSize{"HexSize", 0.05, 0.95};
ReducedPatternOptimization::xRange innerHexagonAngle{"HexAngle", -30.0, 30.0};
ReducedPatternOptimization::Settings settings_optimization;
settings_optimization.xRanges = {beamE,beamA,beamJ,beamI2,beamI3,
innerHexagonSize, innerHexagonAngle};
2021-02-25 09:09:38 +01:00
const bool input_numberOfFunctionCallsDefined = argc >= 4;
settings_optimization.numberOfFunctionCalls =
2021-02-25 09:09:38 +01:00
input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
settings_optimization.normalizationStrategy
= ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
settings_optimization.normalizationParameter = 0.0003;
settings_optimization.solutionAccuracy = 0.001;
settings_optimization.objectiveWeights.translational = std::atof(argv[4]);
settings_optimization.objectiveWeights.rotational = 2 - std::atof(argv[4]);
// Optimize pair
const std::string pairName =
fullPattern.getLabel() + "@" + reducedPattern.getLabel();
2021-02-19 16:32:15 +01:00
const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
assert(interfaceNodeIndex==numberOfNodesPerSlot[0]+numberOfNodesPerSlot[3]);
ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
2021-03-30 18:30:49 +02:00
optimizer.initializePatterns(fullPattern, reducedPattern, settings_optimization.xRanges.size());
ReducedPatternOptimization::Results optimizationResults
// = optimizer.optimize(
// settings_optimization);
= optimizer.optimize(settings_optimization);
// Export results
const bool input_resultDirectoryDefined = argc >= 6;
std::string optimizationResultsDirectory = input_resultDirectoryDefined
? argv[5]
: std::filesystem::current_path().append(
"OptimizationResults");
std::string resultsOutputDir;
if (optimizationResults.numberOfSimulationCrashes != 0) {
const auto crashedJobsDirPath = std::filesystem::path(
optimizationResultsDirectory.append("CrashedJobs")
.append(
pairName + "(" + std::to_string(settings_optimization.numberOfFunctionCalls) + "_"
+ to_string_with_precision(settings_optimization.objectiveWeights.translational)
+ ")"));
std::filesystem::create_directories(crashedJobsDirPath);
resultsOutputDir = crashedJobsDirPath.string();
} else {
std::filesystem::path convergedJobsDirPath(
std::filesystem::path(optimizationResultsDirectory)
.append("ConvergedJobs")
.append(
pairName + "(" + std::to_string(settings_optimization.numberOfFunctionCalls) + "_"
+ to_string_with_precision(settings_optimization.objectiveWeights.translational)
+ ")"));
std::filesystem::create_directories(convergedJobsDirPath);
resultsOutputDir = convergedJobsDirPath.string();
}
optimizationResults.save(resultsOutputDir);
// Write results in csv
2021-02-19 16:32:15 +01:00
csvFile csv_results({}, false);
// csvFile csv_results(std::filesystem::path(dirPath_thisOptimization)
// .append("results.csv")
// .string(),
// false);
csv_results << "Name";
optimizationResults.writeHeaderTo(csv_results);
settings_optimization.writeHeaderTo(csv_results);
csv_results << endrow;
csv_results << pairName;
optimizationResults.writeResultsTo(settings_optimization, csv_results);
settings_optimization.writeSettingsTo(csv_results);
csv_results << endrow;
#ifdef POLYSCOPE_DEFINED
optimizationResults.saveMeshFiles();
2021-03-30 18:30:49 +02:00
optimizationResults.draw();
#endif
2020-11-23 10:06:45 +01:00
return 0;
}