Refactoring. Made optimization parameters command line arguments. Added optimization parameters to the settings. Exporting of optimization parameters. main.py runs a batch of optimization with different optimization parameters

CMakeLists.txt

@@ -45,7 +45,7 @@ else()
                 add_compile_definitions(POLYSCOPE_DEFINED)
         endif()
         set(MYSOURCES_STATIC_LINK false)
-        set(USE_ENSMALLEN true)
+        set(USE_ENSMALLEN false)
         if(${USE_ENSMALLEN})
                 add_compile_definitions(USE_ENSMALLEN)
         endif()

main.py

@@ -15,14 +15,16 @@ import sys
 from datetime import datetime
 from subprocess import check_output
 from shutil import copyfile
+from enum import Enum
 
 numberOfOptimizedPatterns=0
 numberOfSkippedPatterns=0
-numberOfFunctionCalls=0
+numberOfFunctionCalls=10
 start_time = datetime.now()
-def listener(q):
+def listener(q,resultsDir):
-    #print("Entered listener")
+    print("Entered")
-    with open(os.path.join(resultsDir,'results.csv'), 'a') as f:
+    print("result dir in listener:",resultsDir)
+    with open(os.path.join(resultsDir,'results.csv'), 'a',newline='\n') as f:
         while 1:
             m = q.get()
             if m == 'kill':
@@ -35,10 +37,11 @@ def listener(q):
                 global numberOfSkippedPatterns
                 numberOfSkippedPatterns=numberOfSkippedPatterns+1
                 continue
+            print(m)
             f.write(m)
             f.flush()
             global start_time
-            #print("Before")
+            # print("Before")
             if numberOfSkippedPatterns != numberOfOptimizedPatterns:
                 averageTimePerPattern_min=(datetime.now()-start_time).total_seconds()/(60*(numberOfOptimizedPatterns-numberOfSkippedPatterns))
             print("Average minutes/pattern:"+str(averageTimePerPattern_min))
@@ -50,7 +53,7 @@ def listener(q):
             # completionPercentage=numberOfOptimizedPatterns/totalNumberOfPatterns
             # print("Optimized patterns:" + str(completionPercentage))
 
-def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveWeight):
+def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveWeight,optimizationParameters,resultsDir,intermediateResultsDir):
     """Call run(), catch exceptions."""
     dirname = os.path.abspath(os.path.dirname(__file__))
     # dirname="/home/iason/Coding/build/ReducedModelOptimization/Release"
@@ -65,7 +68,7 @@ def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveW
                 reducedPatternFilepath,
                 str(numberOfFunctionCalls),str(translationalObjectiveWeight),
                 #os.path.join(resultsDir,os.path.basename(os.path.dirname(fullPatternFilepath))))
-                putResultsTo)
+                putResultsTo,optimizationParameters,intermediateResultsDir)
 
         patternStartTime=datetime.now()
         #print("Optimizing " + fullPatternFilepath+" at "+str(datetime.now()))
@@ -73,6 +76,7 @@ def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveW
         #popen.wait()
         #output = popen.stdout.read()
         output = check_output(args).decode("utf-8")
+        # print(output)
         #output,error=popen.communicate()
         duration_min=(datetime.now() - patternStartTime).total_seconds()/60
         #print("Optimized " + fullPatternFilepath+" in "+str(duration_min)+" minutes")
@@ -81,25 +85,15 @@ def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveW
     except Exception as e:
         print("error: %s run(*%r, **%r)" % (e, fullPatternFilepath,reducedPatternFilepath))
 
-# Press the green button in the gutter to run the script.
+def optimizeBatch(fullPatternDirectory,optimizationParameters,resultsDir,intermediateResultsDir):
-if __name__ == '__main__':
+
-    dirOfThisFile = os.path.abspath(os.path.dirname(__file__))
+    watcher = pool.apply_async(listener, (q,resultsDir))
-    copyFrom="/home/iason/Coding/build/ReducedModelOptimization/Release/ReducedModelOptimization"
+    # print(optimizationParameters)
-    copyfile(copyFrom, os.path.join(dirOfThisFile,"ReducedModelOptimization"))
-    fullPatternDirectory= "/home/iason/Coding/Projects/Approximating shapes with flat patterns/ReducedModelOptimization/TestSet/FullPatterns/selectionOfPatterns"
-    numberOfFunctionCalls=100000
-    optimizationBatchName='variableComparison_AllVars_ensmallen'+'_'+str(int(numberOfFunctionCalls/1000))+'k'
-    resultsDir=os.path.join(dirOfThisFile,os.path.join('Results/OptimizationResults/',optimizationBatchName))
-    #print(resultsDir)
     if not os.path.exists(resultsDir):
         os.makedirs(resultsDir)
       #shutil.rmtree(resultsDir)
-    manager = multiprocessing.Manager()
+    reducedPatternFilepath= "/home/iason/Coding/Projects/Approximating shapes with flat patterns/ReducedModelOptimization/TestSet/ReducedPatterns/single_reduced.ply"
-    q = manager.Queue()
-    reducedPatternFilepath= "TestSet/ReducedPatterns/single_reduced.ply"
     fullPatternFilepaths=[]
-    pool=multiprocessing.Pool(11)
-    watcher = pool.apply_async(listener, (q,))
     for subdir, dirs, files in os.walk(fullPatternDirectory):
         #print(subdir)
       #print(dirs)
@@ -114,7 +108,9 @@ if __name__ == '__main__':
       #print(optimizationPairs)
     jobs=[]
     translationalObjectiveWeights=[1.2] #[x/10 for x in range(2,18,2)]
-    jobs.extend(list(itertools.product(fullPatternFilepaths,[reducedPatternFilepath],translationalObjectiveWeights)))
+    optimizationParameters_str=list(map(str, optimizationParameters))
+    print(str(optimizationParameters))
+    jobs.extend(list(itertools.product(fullPatternFilepaths,[reducedPatternFilepath],translationalObjectiveWeights,[str(optimizationParameters)],[resultsDir],[intermediateResultsDir])))
     #print(optimizationPairs)
     totalNumberOfPatterns=len(jobs)
     print("Runnning:",optimizationBatchName)
@@ -125,8 +121,52 @@ if __name__ == '__main__':
     print("Start time:", start_time)
     pool.starmap(optimize,jobs)
     print("Completed")
-    # f.close()
     q.put('kill')
+    # f.close()
+
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+
+    # resultsDir="uninitialized dir"
+    manager = multiprocessing.Manager()
+    q = manager.Queue()
+    pool=multiprocessing.Pool(2)
+    #get latest optimization binary
+    copyFrom="/home/iason/Coding/build/ReducedModelOptimization/Release/ReducedModelOptimization"
+    dirOfThisFile = os.path.abspath(os.path.dirname(__file__))
+    copyfile(copyFrom, os.path.join(dirOfThisFile,"ReducedModelOptimization"))
+
+    fullPatternDirectory= "/home/iason/Coding/Projects/Approximating shapes with flat patterns/ReducedModelOptimization/TestSet/FullPatterns/selectionOfPatterns"
+    intermediateResultsDir='/home/iason/Coding/build/ReducedModelOptimization/IntermediateResults'
+
+    E=0
+    A=1
+    I2=2
+    I3=3
+    J=4
+    R=5
+    Theta=6
+    
+    # optimizationParametersScenarios=[]
+    optimizationParametersScenarios={
+        "AllVar":{E, A, I2, I3, J, R, Theta},
+        "GeoYM":{R, Theta, E},
+        "noYM":{A, I2, I3, J, R, Theta},
+        "YMMat_Geo":[{E, A, I2, I3, J}, {R, Theta}],
+        "YM_MatGeo":[{E}, {A, I2, I3, J, R, Theta}],
+        "MatGeo_YM":[{A, I2, I3, J, R, Theta}, {E}],
+        "Geo_YM_Mat":[{R, Theta}, {E}, {A, I2, I3, J}],
+        "YM_Geo_Mat":[{E}, {R, Theta}, {A, I2, I3, J}],
+        "Geo_Mat":[{R, Theta}, {A, I2, I3, J}],
+        "YMGeo_Mat":[{E, R, Theta}, {A, I2, I3, J}]
+    }
+
+
+    for key, optimizationParameters in optimizationParametersScenarios.items():
+        optimizationBatchName='variableComparison_'+key+'_'+str(int(numberOfFunctionCalls/1000))+'k'
+        resultsDir=os.path.join(dirOfThisFile,os.path.join('Results/OptimizationResults/',optimizationBatchName))
+        optimizeBatch(fullPatternDirectory,optimizationParameters,resultsDir,intermediateResultsDir)
+
     pool.close()
     pool.join()
-

src/main.cpp

@@ -10,51 +10,156 @@
 #include <iterator>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <vcg/complex/algorithms/update/position.h>
+#include <boost/algorithm/string.hpp>
 
 #ifdef POLYSCOPE_DEFINED
 #include "polyscope/curve_network.h"
 #include "polyscope/point_cloud.h"
 #include "polyscope/polyscope.h"
 #endif
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
-  if (argc < 3) {
+{
-    std::cerr << "Specify at least the two pattern filepaths to be "
+    if (argc <= 7) {
-                 "optimized.Exiting.."
+        std::cerr << "Wrong number of input parameters. Expects at least 6 input parameters."
-              << std::endl;
+                     "Usage:\n"
+                     "1)full pattern file path\n"
+                     "2)reduced pattern file path\n"
+                     "3)Number of optimizaion function calls\n"
+                     "4)Translational error weight\n"
+                     "5)Optimization results directory path\n"
+                     "6)[optional]Optimization parameters\n"
+                     "7)[optional]Intermediate results directory path\n"
+                     "Exiting.."
+                  << std::endl;
+        return 1;
+    }
+
+    // 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.prependToLabel(std::to_string(fullPattern.EN()) + "#");
+    fullPattern.scale(0.03, interfaceNodeIndex);
+    ////Reduced pattern
+    const std::string filepath_reducedPattern = argv[2];
+    PatternGeometry reducedPattern(filepath_reducedPattern);
+    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{"R", 0.05, 0.95};
+    ReducedPatternOptimization::xRange innerHexagonAngle{"Theta", -30.0, 30.0};
+    ReducedPatternOptimization::Settings settings_optimization;
+    settings_optimization.parameterRanges
+        = {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.optimizationVariables=optimizationParameters;
+        #ifdef POLYSCOPE_DEFINED
+        for(const std::vector<ReducedPatternOptimization::OptimizationParameterIndex>& v:settings_optimization.optimizationVariables){
+        for(const ReducedPatternOptimization::OptimizationParameterIndex& i:v ){
+        std::cout<<static_cast<int>(i)<<" ";
+        }
+        std::cout<<std::endl;
+        }
+        #endif
+
+    } else {
+        enum OptimizationParameterComparisonScenarioIndex {
+            AllVar,
+            GeoYM,
+            noYM,
+            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[noYM] = {{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 = YMGeo_Mat;
+        settings_optimization.optimizationVariables = optimizationParameters[scenario];
+    }
+    if(settings_optimization.optimizationVariables.empty()){
+    std::cerr<<"No optimization variables. Exiting.."<<std::endl;
     std::terminate();
-  }
+    }
 
-  // Populate the pattern pair to be optimized
+    const bool input_intermediateResultsDirectoryDefined = argc >= 7;
-  const int interfaceNodeIndex=3;
+    if (input_intermediateResultsDirectoryDefined) {
-  ////Full pattern
+        settings_optimization.intermediateResultsDirectoryPath = std::filesystem::path(argv[6]);
-  const std::string filepath_fullPattern = argv[1];
+    }
-  PatternGeometry fullPattern(filepath_fullPattern);
-  //  fullPattern.prependToLabel(std::to_string(fullPattern.EN()) + "#");
-  fullPattern.scale(0.03, interfaceNodeIndex);
-  ////Reduced pattern
-  const std::string filepath_reducedPattern = argv[2];
-  PatternGeometry reducedPattern(filepath_reducedPattern);
-  reducedPattern.scale(0.03, interfaceNodeIndex);
 
-  // Set the optization settings
+    settings_optimization.normalizationStrategy
-  ReducedPatternOptimization::xRange beamE{"E", 0.001, 1000};
+        = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
-  ReducedPatternOptimization::xRange beamA{"A", 0.001, 1000};
-  ReducedPatternOptimization::xRange beamI{"I", 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.parameterRanges
-      = {beamE, beamA, beamI2, beamI3, beamJ, innerHexagonSize, innerHexagonAngle};
-  const bool input_numberOfFunctionCallsDefined = argc >= 4;
-  settings_optimization.numberOfFunctionCalls = input_numberOfFunctionCallsDefined
-                                                    ? std::atoi(argv[3])
-                                                    : 100;
-  settings_optimization.normalizationStrategy
-      = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
 #ifdef POLYSCOPE_DEFINED
   settings_optimization.translationNormalizationParameter = 0;
   settings_optimization.rotationNormalizationParameter = 0;
@@ -80,11 +185,7 @@ int main(int argc, char *argv[]) {
                                        + to_string_with_precision(
                                            settings_optimization.objectiveWeights.translational)
                                        + ")" + "_" + xConcatNames;
-  const bool input_resultDirectoryDefined = argc >= 6;
+  const std::string optimizationResultsDirectory = argv[5];
-  const std::string optimizationResultsDirectory = input_resultDirectoryDefined
-                                                       ? argv[5]
-                                                       : std::filesystem::current_path().append(
-                                                           "OptimizationResults").string();
   std::string resultsOutputDir;
   bool optimizationResultFolderExists = false;
   const std::filesystem::path crashedJobsDirPath(std::filesystem::path(optimizationResultsDirectory)

src/reducedmodeloptimizer.cpp

@@ -30,10 +30,10 @@ struct GlobalOptimizationVariables
     std::vector<double> objectiveValueHistory;
     std::vector<double> plotColors;
     std::array<double,
-               ReducedModelOptimizer::OptimizationParameterIndex::NumberOfOptimizationParameters>
+               ReducedPatternOptimization::OptimizationParameterIndex::NumberOfOptimizationParameters>
         parametersInitialValue;
     std::array<double,
-               ReducedModelOptimizer::OptimizationParameterIndex::NumberOfOptimizationParameters>
+               ReducedPatternOptimization::OptimizationParameterIndex::NumberOfOptimizationParameters>
         optimizationInitialValue;
     std::vector<int> simulationScenarioIndices;
     double minY{DBL_MAX};
@@ -949,7 +949,7 @@ ReducedModelOptimizer::getFullPatternMaxSimulationForces(
     const std::filesystem::path &intermediateResultsDirectoryPath)
 {
     std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes;
-#ifdef POLYSCOPE_DEFINED
+    //#ifdef POLYSCOPE_DEFINED
     const std::filesystem::path forceMagnitudesDirectoryPath(
         std::filesystem::path(intermediateResultsDirectoryPath).append("ForceMagnitudes"));
     std::filesystem::path patternMaxForceMagnitudesFilePath(
@@ -965,11 +965,11 @@ ReducedModelOptimizer::getFullPatternMaxSimulationForces(
             = static_cast<std::array<double, NumberOfBaseSimulationScenarios>>(json.at("maxMagn"));
         return fullPatternSimulationScenarioMaxMagnitudes;
     }
-#endif
+    //#endif
     fullPatternSimulationScenarioMaxMagnitudes = computeFullPatternMaxSimulationForces(
         desiredBaseSimulationScenarioIndices);
 
-#ifdef POLYSCOPE_DEFINED
+    //#ifdef POLYSCOPE_DEFINED
     nlohmann::json json;
     json["maxMagn"] = fullPatternSimulationScenarioMaxMagnitudes;
 
@@ -977,7 +977,7 @@ ReducedModelOptimizer::getFullPatternMaxSimulationForces(
     std::ofstream jsonFile(patternMaxForceMagnitudesFilePath.string());
     jsonFile << json;
 
-#endif
+    //#endif
     assert(fullPatternSimulationScenarioMaxMagnitudes.size()
            == desiredBaseSimulationScenarioIndices.size());
 
@@ -995,94 +995,65 @@ void ReducedModelOptimizer::runOptimization(const Settings &settings,
 #if POLYSCOPE_DEFINED
 //    global.plotColors.reserve(settings.numberOfFunctionCalls);
 #endif
-#ifdef USE_ENSMALLEN
+    assert(!settings.optimizationVariables.empty());
-#else
+    const std::vector<std::vector<OptimizationParameterIndex>> &optimizationParametersGroups
-#endif
+        = settings.optimizationVariables;
-    enum OptimizationParameterComparisonScenarioIndex {
-        AllVar,     //ok
-        GeoYM,      //ok
-        noYM,       //ok
-        YMMat_Geo,  //ok
-        YM_MatGeo,  //executing
-        MatGeo_YM,  //ok
-        Geo_YM_Mat, //ok
-        YM_Geo_Mat, //ok
-        Geo_Mat,    //ok
-        YMGeo_Mat,
-        NumberOfScenarios
-    };
-    const std::vector<std::vector<std::vector<OptimizationParameterIndex>>> scenarioParameters =
-        [&]() {
-            std::vector<std::vector<std::vector<OptimizationParameterIndex>>> scenarioParameters(
-                NumberOfScenarios);
-            scenarioParameters[AllVar] = {{E, A, I2, I3, J, R, Theta}};
-            scenarioParameters[GeoYM] = {{R, Theta, E}};
-            scenarioParameters[noYM] = {{A, I2, I3, J, R, Theta}};
-            scenarioParameters[YMMat_Geo] = {{E, A, I2, I3, J}, {R, Theta}};
-            scenarioParameters[YM_MatGeo] = {{E}, {A, I2, I3, J, R, Theta}};
-            scenarioParameters[MatGeo_YM] = {{A, I2, I3, J, R, Theta}, {E}};
-            scenarioParameters[Geo_YM_Mat] = {{R, Theta}, {E}, {A, I2, I3, J}};
-            scenarioParameters[YM_Geo_Mat] = {{E},{R, Theta}, {A, I2, I3, J}};
-            scenarioParameters[Geo_Mat] = {{R, Theta}, {A, I2, I3, J}};
-            scenarioParameters[YMGeo_Mat] = {{E, R, Theta}, {A, I2, I3, J}};
-            return scenarioParameters;
 
-        }();
+#ifndef USE_ENSMALLEN
-
-    constexpr OptimizationParameterComparisonScenarioIndex scenario = YM_MatGeo;
-    const std::vector<std::vector<OptimizationParameterIndex>> scenarioParameterGroups
-        = scenarioParameters[scenario];
     const int totalNumberOfOptimizationParameters
-        = std::accumulate(scenarioParameterGroups.begin(),
+        = std::accumulate(optimizationParametersGroups.begin(),
-                          scenarioParameterGroups.end(),
+                          optimizationParametersGroups.end(),
                           0,
                           [](const int &sum,
                              const std::vector<OptimizationParameterIndex> &parameterGroup) {
                               return sum + parameterGroup.size();
                           });
+#endif
 
     FunctionEvaluation optimization_optimalResult;
     optimization_optimalResult.x.resize(NumberOfOptimizationParameters,0);
         for (int optimizationParameterIndex = E;
              optimizationParameterIndex != NumberOfOptimizationParameters;
              optimizationParameterIndex++) {
-            optimization_optimalResult.x[optimizationParameterIndex]=global.parametersInitialValue[optimizationParameterIndex];
+            optimization_optimalResult.x[optimizationParameterIndex]
-             }
+                = global.parametersInitialValue[optimizationParameterIndex];
-    for (const std::vector<OptimizationParameterIndex> &parameterGroup : scenarioParameterGroups) {
+        }
-    FunctionEvaluation parameterGroup_optimalResult;
+        for (const std::vector<OptimizationParameterIndex> &parameterGroup :
-        //Set update function. TODO: Make this function immutable by defining it once and using the global variable to set parameterGroup
+             optimizationParametersGroups) {
-        function_updateReducedPattern = [&](const std::vector<double> &x,
+            FunctionEvaluation parameterGroup_optimalResult;
-                                            std::shared_ptr<SimulationMesh> &pMesh) {
+            //Set update function. TODO: Make this function immutable by defining it once and using the global variable to set parameterGroup
+            function_updateReducedPattern = [&](const std::vector<double> &x,
+                                                std::shared_ptr<SimulationMesh> &pMesh) {
+                for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
+                    const OptimizationParameterIndex parameterIndex = parameterGroup[xIndex];
+                    //                const double parameterInitialValue=optimizationSettings.parameterRanges[parameterIndex].initialValue;
+                    const double parameterNewValue = [&]() {
+                        if (parameterIndex == R || parameterIndex == Theta) {
+                            return x[xIndex] /*+ parameterInitialValue*/;
+                        }
+                        //and the material parameters exponentially(?).TODO: Check what happens if I make all linear
+                        const double parameterInitialValue
+                            = global.parametersInitialValue[parameterIndex];
+                        return x[xIndex] * parameterInitialValue;
+                    }();
+                    //                std::cout << "Optimization parameter:" << parameterIndex << std::endl;
+                    //                std::cout << "New value:" << parameterNewValue << std::endl;
+                    global.functions_updateReducedPatternParameter[parameterIndex](parameterNewValue,
+                                                                                   pMesh);
+                }
+                pMesh->reset(); //NOTE: I could put this code into each updateParameter function for avoiding unessecary calculations
+            };
+
+            std::vector<double> xMin;
+            std::vector<double> xMax;
+            xMin.resize(parameterGroup.size());
+            xMax.resize(parameterGroup.size());
             for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
                 const OptimizationParameterIndex parameterIndex = parameterGroup[xIndex];
-                //                const double parameterInitialValue=optimizationSettings.parameterRanges[parameterIndex].initialValue;
+
-                const double parameterNewValue = [&]() {
+                xMin[xIndex] = settings.parameterRanges[parameterIndex].min;
-                    if (parameterIndex == R || parameterIndex == Theta) {
+                xMax[xIndex] = settings.parameterRanges[parameterIndex].max;
-                        return x[xIndex] /*+ parameterInitialValue*/;
-                    }
-                    //and the material parameters exponentially(?).TODO: Check what happens if I make all linear
-                    const double parameterInitialValue
-                        = global.parametersInitialValue[parameterIndex];
-                    return x[xIndex] * parameterInitialValue;
-                }();
-                //                std::cout << "Optimization parameter:" << parameterIndex << std::endl;
-                //                std::cout << "New value:" << parameterNewValue << std::endl;
-                global.functions_updateReducedPatternParameter[parameterIndex](parameterNewValue,
-                                                                               pMesh);
             }
-            pMesh->reset(); //NOTE: I could put this code into each updateParameter function for avoiding unessecary calculations
-        };
-
-        std::vector<double> xMin;
-        std::vector<double> xMax;
-        xMin.resize(parameterGroup.size());
-        xMax.resize(parameterGroup.size());
-        for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
-            const OptimizationParameterIndex parameterIndex = parameterGroup[xIndex];
-
-            xMin[xIndex] = settings.parameterRanges[parameterIndex].min;
-            xMax[xIndex] = settings.parameterRanges[parameterIndex].max;
-        }
 #ifdef USE_ENSMALLEN
         arma::mat x(parameterGroup.size(), 1);
         for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
@@ -1229,10 +1200,9 @@ void ReducedModelOptimizer::runOptimization(const Settings &settings,
 optimization_optimalResult.y=parameterGroup_optimalResult.y;
         for (int xIndex = 0; xIndex < parameterGroup.size(); xIndex++) {
             const OptimizationParameterIndex parameterIndex = parameterGroup[xIndex];
-optimization_optimalResult.x[parameterIndex]=parameterGroup_optimalResult.x[xIndex];
+            optimization_optimalResult.x[parameterIndex] = parameterGroup_optimalResult.x[xIndex];
-}
+        }
-
+        }
-    }
     getResults(optimization_optimalResult, settings, results);
 }
 
@@ -1806,6 +1776,7 @@ void ReducedModelOptimizer::optimize(
     ReducedPatternOptimization::Results &results,
     const std::vector<BaseSimulationScenario> &desiredBaseSimulationScenarioIndices)
 {
+    assert(!optimizationSettings.optimizationVariables.empty());
     for (int baseSimulationScenarioIndex : desiredBaseSimulationScenarioIndices) {
         //Increase the size of the vector holding the simulation scenario indices
         global.simulationScenarioIndices.resize(
@@ -1831,14 +1802,9 @@ void ReducedModelOptimizer::optimize(
     global.optimizationSettings = optimizationSettings;
     global.pFullPatternSimulationMesh = m_pFullPatternSimulationMesh;
 
-#ifdef POLYSCOPE_DEFINED
     const std::filesystem::path intermediateResultsDirectoryPath(
-        std::filesystem::current_path().parent_path().append("IntermediateResults"));
+        optimizationSettings.intermediateResultsDirectoryPath);
-#else
-    const std::filesystem::path intermediateResultsDirectoryPath(
-        std::filesystem::current_path().append("IntermediateResults"));
 
-#endif
     std::array<double, NumberOfBaseSimulationScenarios> fullPatternSimulationScenarioMaxMagnitudes
         = getFullPatternMaxSimulationForces(desiredBaseSimulationScenarioIndices,
                                             intermediateResultsDirectoryPath);

src/reducedmodeloptimizer.hpp

@@ -52,20 +52,20 @@ public:
         double y = std::numeric_limits<double>::quiet_NaN();
     };
 
-    struct ParameterLabels
+    //    struct ParameterLabels
-    {
+    //    {
-        inline const static std::string E = {"E"};
+    //        inline const static std::string E = {"E"};
-        inline const static std::string A = {"A"};
+    //        inline const static std::string A = {"A"};
-        inline const static std::string I2 = {"I2"};
+    //        inline const static std::string I2 ={"I2"};
-        inline const static std::string I3 = {"I3"};
+    //        inline const static std::string I3 ={"I3"};
-        inline const static std::string J = {"J"};
+    //        inline const static std::string J = {"J"};
-        inline const static std::string theta = {"Theta"};
+    //        inline const static std::string th= {"Theta"};
-        inline const static std::string R = {"R"};
+    //        inline const static std::string R = {"R"};
-    };
+    //    };
-    inline constexpr static ParameterLabels parameterLabels();
+    //    inline constexpr static ParameterLabels parameterLabels();
-
-    enum OptimizationParameterIndex { E, A, I2, I3, J, R, Theta, NumberOfOptimizationParameters };
 
+    inline static std::array<std::string, ReducedPatternOptimization::NumberOfOptimizationParameters>
+        parameterLabels = {"R", "A", "I2", "I3", "J", "Theta", "R"};
     constexpr static std::array<int, ReducedPatternOptimization::NumberOfBaseSimulationScenarios>
         simulationScenariosResolution = {11, 11, 20, 20, 20};
     constexpr static std::array<int, ReducedPatternOptimization::NumberOfBaseSimulationScenarios>