Optimization settings file path as input to the reduced model optimizer

src/main.cpp

@@ -21,16 +21,14 @@
 #endif
 int main(int argc, char *argv[])
 {
-    if (argc <= 6) {
+    if (argc <= 5) {
-        std::cerr << "Wrong number of input parameters. Expects at least 6 input parameters."
+        std::cerr << "Wrong number of input parameters. Expects at least 4 input parameters."
                      "Usage:\n"
                      "1)full pattern file path\n"
                      "2)reduced pattern file path\n"
-                     "3)Number of optimizaion function calls\n"
+                     "3)Optimization settings json file path\n"
-                     "4)Translational error weight\n"
+                     "4)Optimization results directory path\n"
-                     "5)Optimization results directory path\n"
+                     "5)[optional]Intermediate results directory path\n"
-                     "6)[optional]Intermediate results directory path\n"
-                     "7)[optional]Optimization parameters\n"
                      "Exiting.."
                   << std::endl;
         return 1;
@@ -54,195 +52,17 @@ int main(int argc, char *argv[])
         std::cerr << "Input optimization settings file does not exist:"
                   << optimizationSettingsFilePath << std::endl;
     }
-
-    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{"R", 0.05, 0.95};
-    ReducedPatternOptimization::xRange innerHexagonAngle{"Theta", -30.0, 30.0};
     ReducedPatternOptimization::Settings settings_optimization;
-    settings_optimization.variablesRanges
+    settings_optimization.load(optimizationSettingsFilePath);
-        = {beamE, beamA, beamI2, beamI3, beamJ, innerHexagonSize, innerHexagonAngle};
-    settings_optimization.numberOfFunctionCalls = std::atoi(argv[3]);
-
-    const bool input_optimizationParametersDefined = argc >= 8;
-    if (input_optimizationParametersDefined) {
-        const std::string optimizationParametersTag = argv[7];
-        std::vector<std::string> split = Utilities::split(optimizationParametersTag, ",");
-        //parse parameter tag
-        std::vector<std::vector<ReducedPatternOptimization::OptimizationParameterIndex>>
-            optimizationParameters;
-        std::vector<ReducedPatternOptimization::OptimizationParameterIndex> parameterGroup;
-        for (std::string &s : split) {
-            //        std::cout<<s<<std::endl;
-            //        s=Utilities::trimLeftAndRightSpaces(s);
-            if (boost::algorithm::contains(s, "{")) {
-                //            std::cout<<"{ detected"<<std::endl;
-                parameterGroup.clear();
-            }
-            if (boost::algorithm::contains(s,
-                                           std::to_string(
-                                               static_cast<int>(ReducedPatternOptimization::E)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::E);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::A)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::A);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::I2)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::I2);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::I3)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::I3);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::J)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::J);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::R)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::R);
-            } else if (boost::algorithm::contains(s,
-                                                  std::to_string(static_cast<int>(
-                                                      ReducedPatternOptimization::Theta)))) {
-                parameterGroup.push_back(ReducedPatternOptimization::Theta);
-            } else {
-                std::cerr << "Wrong optimization parameter input: " << optimizationParametersTag
-                          << std::endl;
-            }
-            if (boost::algorithm::contains(s, "}")) {
-                optimizationParameters.push_back(parameterGroup);
-            }
-        }
-        settings_optimization.optimizationStrategy = optimizationParameters;
-#ifdef POLYSCOPE_DEFINED
-        for (const std::vector<ReducedPatternOptimization::OptimizationParameterIndex> &v :
-             settings_optimization.optimizationStrategy) {
-            for (const ReducedPatternOptimization::OptimizationParameterIndex &i : v) {
-                std::cout << static_cast<int>(i) << " ";
-            }
-            std::cout << std::endl;
-        }
-#endif
-
-    } else {
-        enum OptimizationParameterComparisonScenarioIndex {
-            AllVar,
-            GeoYM,
-            MatGeo,
-            YMMat_Geo,
-            YM_MatGeo,
-            MatGeo_YM,
-            Geo_YM_Mat,
-            YM_Geo_Mat,
-            Geo_Mat,
-            YMGeo_Mat,
-            NumberOfScenarios
-        };
-        const std::vector<
-            std::vector<std::vector<ReducedPatternOptimization::OptimizationParameterIndex>>>
-            optimizationParameters = [&]() {
-                std::vector<
-                    std::vector<std::vector<ReducedPatternOptimization::OptimizationParameterIndex>>>
-                    optimizationParameters(NumberOfScenarios);
-                using namespace ReducedPatternOptimization;
-                optimizationParameters[AllVar] = {{E, A, I2, I3, J, R, Theta}};
-                optimizationParameters[GeoYM] = {{R, Theta, E}};
-                optimizationParameters[MatGeo] = {{A, I2, I3, J, R, Theta}};
-                optimizationParameters[YMMat_Geo] = {{E, A, I2, I3, J}, {R, Theta}};
-                optimizationParameters[YM_MatGeo] = {{E}, {A, I2, I3, J, R, Theta}};
-                optimizationParameters[MatGeo_YM] = {{A, I2, I3, J, R, Theta}, {E}};
-                optimizationParameters[Geo_YM_Mat] = {{R, Theta}, {E}, {A, I2, I3, J}};
-                optimizationParameters[YM_Geo_Mat] = {{E}, {R, Theta}, {A, I2, I3, J}};
-                optimizationParameters[Geo_Mat] = {{R, Theta}, {A, I2, I3, J}};
-                optimizationParameters[YMGeo_Mat] = {{E, R, Theta}, {A, I2, I3, J}};
-                return optimizationParameters;
-            }();
-
-        constexpr OptimizationParameterComparisonScenarioIndex scenario = MatGeo;
-        settings_optimization.optimizationStrategy = optimizationParameters[scenario];
-        if (scenario == YMGeo_Mat) {
-            settings_optimization.optimizationVariablesGroupsWeights = {0.15, 0.85};
-        }
-    }
-    if (settings_optimization.optimizationStrategy.empty()) {
-        std::cerr << "No optimization variables. Exiting.." << std::endl;
-        std::terminate();
-    }
-
-    settings_optimization.normalizationStrategy
-        = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
-    //#ifdef POLYSCOPE_DEFINED
-    //#else
-    settings_optimization.translationNormalizationParameter = 4e-3;
-    settings_optimization.rotationNormalizationParameter = vcg::math::ToRad(3.0);
-
-    //    settings_optimization.translationNormalizationParameter = 0;
-    //    settings_optimization.rotationNormalizationParameter = 0;
-
-    //    settings_optimization.translationNormalizationParameter = 1e-3;
-    //    settings_optimization.rotationNormalizationParameter = vcg::math::ToRad(3.0);
-
-    //    settings_optimization.translationNormalizationParameter = 5e-2;
-    //    settings_optimization.rotationNormalizationParameter = vcg::math::ToRad(3.0);
-
-    //#endif
-    settings_optimization.solverAccuracy = 1e-2;
-    //TODO refactor that
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Axial]
-        .translational
-        = 1.5;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Axial].rotational
-        = 2
-          - settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Axial]
-                .translational;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Shear]
-        .translational
-        = 1.5;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Shear].rotational
-        = 2
-          - settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Shear]
-                .translational;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Bending]
-        .translational
-        = 1.2;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Bending]
-        .rotational
-        = 2
-          - settings_optimization
-                .perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Bending]
-                .translational;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Dome]
-        .translational
-        = 1.95;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Dome].rotational
-        = 2
-          - settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Dome]
-                .translational;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Saddle]
-        .translational
-        = 1.2;
-    settings_optimization.perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Saddle]
-        .rotational
-        = 2
-          - settings_optimization
-                .perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Saddle]
-                .translational;
 
     // Optimize pairthere
-    const std::string pairName = fullPattern.getLabel(); // + "@" + reducedPattern.getLabel();
+    const std::string pairName = std::to_string(fullPattern.EN()) + "#"
-    const std::string optimizationName
+                                 + fullPattern.getLabel(); // + "@" + reducedPattern.getLabel();
-        = pairName + "(" + std::to_string(settings_optimization.numberOfFunctionCalls) + "_"
+    const std::string optimizationName = pairName + "("
-          + to_string_with_precision(
+                                         + std::to_string(
-              settings_optimization
+                                             settings_optimization.numberOfFunctionCalls)
-                  .perBaseScenarioObjectiveWeights[ReducedPatternOptimization::Axial]
+                                         + ")";
-                  .translational)
+    const std::string optimizationResultsDirectory = argv[4];
-          + ")";
-    const std::string optimizationResultsDirectory = argv[5];
     std::string resultsOutputDir;
     bool optimizationResultFolderExists = false;
     const std::filesystem::path crashedJobsDirPath(
@@ -277,9 +97,9 @@ int main(int argc, char *argv[])
         const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
         assert(interfaceNodeIndex == numberOfNodesPerSlot[0] + numberOfNodesPerSlot[3]);
         ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
-        const bool input_intermediateResultsDirectoryDefined = argc >= 7;
+        const bool input_intermediateResultsDirectoryDefined = argc == 6;
         if (input_intermediateResultsDirectoryDefined) {
-            optimizer.setIntermediateResultsDirectoryPath(std::filesystem::path(argv[6]));
+            optimizer.setIntermediateResultsDirectoryPath(std::filesystem::path(argv[5]));
         }
         optimizer.initializePatterns(fullPattern,
                                      reducedPattern,

src/reducedmodeloptimizer.cpp

@@ -1808,12 +1808,12 @@ void ReducedModelOptimizer::computeObjectiveValueNormalizationFactors()
         if (global.optimizationSettings.normalizationStrategy
             == Settings::NormalizationStrategy::Epsilon) {
             const double epsilon_translationalDisplacement = global.optimizationSettings
-                                                                 .translationNormalizationParameter;
+                                                                 .translationNormalizationEpsilon;
             global.translationalDisplacementNormalizationValues[simulationScenarioIndex]
                 = std::max(fullPatternTranslationalDisplacementNormSum[simulationScenarioIndex],
                            epsilon_translationalDisplacement);
             const double epsilon_rotationalDisplacement = global.optimizationSettings
-                                                              .rotationNormalizationParameter;
+                                                              .rotationNormalizationEpsilon;
             global.rotationalDisplacementNormalizationValues[simulationScenarioIndex]
                 = std::max(fullPatternAngularDistance[simulationScenarioIndex],
                            epsilon_rotationalDisplacement);