Added ensmallen,armadillo. Parametrized optimization with choice of optimization parameters

CMakeLists.txt

@@ -1,8 +1,8 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.0)
 project(ReducedModelOptimization)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-        message(STATUS "The compiler ${CMAKE_CXX_COMPILER}")
+message(STATUS "The compiler ${CMAKE_CXX_COMPILER}")
 
 #Add the project cmake scripts to the module path
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
@@ -15,7 +15,6 @@ else()
     set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1")
 endif()
 
-
 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE "RelWithDebInfo")
 set(EXTERNAL_DEPS_DIR "C:/Users/iason/Downloads/ReducedModelOptimization/build/externalDependencies/")
@@ -26,23 +25,48 @@ endif()
 ##Create directory for the external libraries
 file(MAKE_DIRECTORY ${EXTERNAL_DEPS_DIR})
 
-##Polyscope
+
+#Add the project sources
+file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+
+if(MSVC)
+        add_compile_definitions(_HAS_STD_BYTE=0)
+endif(MSVC)
+
+add_executable(${PROJECT_NAME} ${SOURCES})
+
 if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
-        set(USE_POLYSCOPE FALSE)
+        set(USE_POLYSCOPE false)
+        set(MYSOURCES_STATIC_LINK true)
+        set(USE_ENSMALLEN false)
 else()
-        set(USE_POLYSCOPE TRUE)
+    set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+        set(USE_POLYSCOPE true)
+        add_compile_definitions(POLYSCOPE_DEFINED)
+        set(MYSOURCES_STATIC_LINK false)
+        set(USE_ENSMALLEN true)
+        if(${USE_ENSMALLEN})
+                add_compile_definitions(USE_ENSMALLEN)
+        endif()
 endif()
-if(${USE_POLYSCOPE})
+
-download_project(PROJ               POLYSCOPE
+#dlib
-                 GIT_REPOSITORY     https://github.com/nmwsharp/polyscope.git
+set(DLIB_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/dlib_bin)
+file(MAKE_DIRECTORY ${DLIB_BIN_DIR})
+download_project(PROJ               DLIB
+                 GIT_REPOSITORY     https://github.com/davisking/dlib.git
                  GIT_TAG	    master
+                 BINARY_DIR         ${DLIB_BIN_DIR}
                  PREFIX             ${EXTERNAL_DEPS_DIR}
                  ${UPDATE_DISCONNECTED_IF_AVAILABLE}
 )
-add_subdirectory(${POLYSCOPE_SOURCE_DIR} ${POLYSCOPE_BINARY_DIR})
+add_subdirectory(${DLIB_SOURCE_DIR} ${DLIB_BINARY_DIR})
-add_compile_definitions(POLYSCOPE_DEFINED)
+if(${MYSOURCES_STATIC_LINK})
+        target_link_libraries(${PROJECT_NAME} "-static" dlib::dlib)
+else()
+        target_link_libraries(${PROJECT_NAME} dlib::dlib)
 endif()
-
+add_compile_definitions(DLIB_DEFINED)
 
 set(MYSOURCES_SOURCE_DIR "/home/iason/Coding/Libraries/MySources")
 if (EXISTS ${MYSOURCES_SOURCE_DIR})
@@ -57,52 +81,16 @@ download_project(PROJ               MYSOURCES
 endif()
 add_subdirectory(${MYSOURCES_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/MySourcesBinDir)
 
-#dlib
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20)
-set(DLIB_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/dlib_bin)
+target_include_directories(${PROJECT_NAME}
-file(MAKE_DIRECTORY ${DLIB_BIN_DIR})
+        PUBLIC ${MYSOURCES_SOURCE_DIR}
-download_project(PROJ               DLIB
+        )
-                 GIT_REPOSITORY     https://github.com/davisking/dlib.git
+if(${MYSOURCES_STATIC_LINK})
-                 GIT_TAG	    master
+        target_link_libraries(${PROJECT_NAME} -static Eigen3::Eigen MySources)
-                 BINARY_DIR         ${DLIB_BIN_DIR}
+else()
-                 PREFIX             ${EXTERNAL_DEPS_DIR}
+        target_link_libraries(${PROJECT_NAME} Eigen3::Eigen MySources)
-                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
+endif()
-)
-add_subdirectory(${DLIB_SOURCE_DIR} ${DLIB_BINARY_DIR})
-
-##vcglib devel branch
-download_project(PROJ		    vcglib_devel
-                 GIT_REPOSITORY     https://github.com/IasonManolas/vcglib.git
-                 GIT_TAG	    devel
-                 PREFIX             ${EXTERNAL_DEPS_DIR}
-                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
-)
-file(GLOB EXT_SOURCES ${vcglib_devel_SOURCE_DIR}/wrap/ply/plylib.cpp)
 
 ##Eigen 3 NOTE: Eigen is required on the system the code is ran
 find_package(Eigen3 3.3 REQUIRED)
 
-#find_package(OpenMP REQUIRED)
-
-#Add the project sources
-file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-
-if(MSVC)
-        add_compile_definitions(_HAS_STD_BYTE=0)
-endif(MSVC)
-
-add_executable(${PROJECT_NAME} ${SOURCES} ${EXT_SOURCES})
-target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20)
-
-target_include_directories(${PROJECT_NAME}
-        PUBLIC ${vcglib_devel_SOURCE_DIR}
-        PUBLIC ${MYSOURCES_SOURCE_DIR}
-        PUBLIC ${MYSOURCES_SOURCE_DIR}/boost_graph
-        )
-
-
-target_link_directories(${PROJECT_NAME} PRIVATE ${MYSOURCES_SOURCE_DIR}/boost_graph/libs/)
-if(${USE_POLYSCOPE})
-        target_link_libraries(${PROJECT_NAME} polyscope Eigen3::Eigen  dlib::dlib MySources)
-else()
-        target_link_libraries(${PROJECT_NAME} -static Eigen3::Eigen dlib::dlib MySources)
-endif()

main.py

@@ -0,0 +1,130 @@
+# This is a sample Python script.
+
+# Press Shift+F10 to execute it or replace it with your code.
+# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
+
+
+import multiprocessing
+import subprocess
+import os
+from os import listdir
+from os.path import isfile, join
+import itertools
+import shutil
+import sys
+from datetime import datetime
+from subprocess import check_output
+
+numberOfOptimizedPatterns=0
+numberOfSkippedPatterns=0
+numberOfFunctionCalls=0
+start_time = datetime.now()
+def listener(q):
+    #print("Entered listener")
+    with open(os.path.join(resultsDir,'results.csv'), 'a') as f:
+        while 1:
+            m = q.get()
+            if m == 'kill':
+                # f.write('killed')
+                break
+            global numberOfOptimizedPatterns
+            numberOfOptimizedPatterns = numberOfOptimizedPatterns + 1
+            print("Optimized patterns:" + str(numberOfOptimizedPatterns))
+            if not m:
+                global numberOfSkippedPatterns
+                numberOfSkippedPatterns=numberOfSkippedPatterns+1
+                continue
+            f.write(m)
+            f.flush()
+            global start_time
+            #print("Before")
+            if numberOfSkippedPatterns != numberOfOptimizedPatterns:
+                averageTimePerPattern_min=(datetime.now()-start_time).total_seconds()/(60*(numberOfOptimizedPatterns-numberOfSkippedPatterns))
+            print("Average minutes/pattern:"+str(averageTimePerPattern_min))
+            #print("After")
+            # global totalNumberOfPatterns
+            # print(totalNumberOfPatterns)
+            # global totalNumberOfPatterns
+            # print(totalNumberOfPatterns)
+            # completionPercentage=numberOfOptimizedPatterns/totalNumberOfPatterns
+            # print("Optimized patterns:" + str(completionPercentage))
+
+def optimize(fullPatternFilepath, reducedPatternFilepath,translationalObjectiveWeight):
+    """Call run(), catch exceptions."""
+    # dirname = os.path.abspath(os.path.dirname(__file__))
+    dirname="/home/iason/Coding/build/ReducedModelOptimization/Release"
+    executableFilepath = os.path.join(dirname, 'ReducedModelOptimization')
+    #putResultsTo=os.path.join(resultsDir,str(translationalObjectiveWeight))
+    #putResultsTo=os.path.join(putResultsTo,os.path.basename(os.path.dirname(os.path.dirname(fullPatternFilepath))))
+    putResultsTo=os.path.join(resultsDir,os.path.basename(os.path.dirname(os.path.dirname(fullPatternFilepath))))
+    try:
+        # global resultsDir
+        p = args = (executableFilepath,
+                fullPatternFilepath,
+                reducedPatternFilepath,
+                str(numberOfFunctionCalls),str(translationalObjectiveWeight),
+                #os.path.join(resultsDir,os.path.basename(os.path.dirname(fullPatternFilepath))))
+                putResultsTo)
+
+        patternStartTime=datetime.now()
+        #print("Optimizing " + fullPatternFilepath+" at "+str(datetime.now()))
+        popen = subprocess.Popen(args, stdout=subprocess.PIPE,bufsize=1005024)
+        #popen.wait()
+        #output = popen.stdout.read()
+        output = check_output(args).decode("utf-8")
+        #output,error=popen.communicate()
+        duration_min=(datetime.now() - patternStartTime).total_seconds()/60
+        #print("Optimized " + fullPatternFilepath+" in "+str(duration_min)+" minutes")
+        q.put(output)
+
+    except Exception as e:
+        print("error: %s run(*%r, **%r)" % (e, fullPatternFilepath,reducedPatternFilepath))
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+    dirOfThisFile = os.path.abspath(os.path.dirname(__file__))
+    fullPatternDirectory= "/home/iason/Coding/Projects/Approximating shapes with flat patterns/ReducedModelOptimization/TestSet/FullPatterns/selectionOfPatterns"
+    #resultsDir=os.path.join(dirOfThisFile,os.path.join('Results/OptimizationResults/',os.path.basename(fullPatternDirectory)))
+    numberOfFunctionCalls=100000
+    optimizationBatchName='variableComparison_allVars_joint_forConfirmation'+'_'+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()
+    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)
+      #print(files)
+      #if !os.path.exists(resultsDir):
+      # Write results
+      #fullPatternFilepaths.extend([join(subdir, fullPatternFilepath) for fullPatternFilepath in listdir(subdir) if isfile(join(subdir, fullPatternFilepath))])
+      fullPatternFilepaths.extend(os.path.join(subdir, fullPatternFile) for fullPatternFile in files if fullPatternFile.endswith(".ply"))
+      #fullPatternFilepaths.extend([os.path.join(fullPatternDirect])
+      #print(fullPatternFilepaths)
+
+      #print(optimizationPairs)
+    jobs=[]
+    translationalObjectiveWeights=[1.2] #[x/10 for x in range(2,18,2)]
+    jobs.extend(list(itertools.product(fullPatternFilepaths,[reducedPatternFilepath],translationalObjectiveWeights)))
+    #print(optimizationPairs)
+    totalNumberOfPatterns=len(jobs)
+    print("Runnning:",optimizationBatchName)
+    print("Number of function calls:",numberOfFunctionCalls)
+    print("Full pattern test set directory:"+fullPatternDirectory)
+    print("Total number of optimization jobs:"+ str(totalNumberOfPatterns))
+
+    print("Start time:", start_time)
+    pool.starmap(optimize,jobs)
+    print("Completed")
+    # f.close()
+    q.put('kill')
+    pool.close()
+    pool.join()
+

src/main.cpp

@@ -40,33 +40,45 @@ int main(int argc, char *argv[]) {
   // Set the optization settings
   ReducedPatternOptimization::xRange beamE{"E", 0.001, 1000};
   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{"HexSize", 0.05, 0.95};
+  ReducedPatternOptimization::xRange innerHexagonSize{"R", 0.05, 0.95};
-  ReducedPatternOptimization::xRange innerHexagonAngle{"HexAngle", -30.0, 30.0};
+  ReducedPatternOptimization::xRange innerHexagonAngle{"Theta", -30.0, 30.0};
   ReducedPatternOptimization::Settings settings_optimization;
-  settings_optimization.xRanges = {beamE,beamA,beamJ,beamI2,beamI3,
+  settings_optimization.parameterRanges
-                                   innerHexagonSize, innerHexagonAngle};
+      = {beamE, beamA, beamI2, beamI3, beamJ, innerHexagonSize, innerHexagonAngle};
   const bool input_numberOfFunctionCallsDefined = argc >= 4;
-  settings_optimization.numberOfFunctionCalls =
+  settings_optimization.numberOfFunctionCalls = input_numberOfFunctionCallsDefined
-      input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
+                                                    ? std::atoi(argv[3])
+                                                    : 100;
   settings_optimization.normalizationStrategy
       = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
-
+  settings_optimization.splitGeometryMaterialOptimization = false;
-  settings_optimization.normalizationParameter = 0.0003;
+  settings_optimization.translationNormalizationParameter = 3e-4;
-  settings_optimization.solverAccuracy = 0.001;
+  settings_optimization.rotationNormalizationParameter = vcg::math::ToRad(3.0);
+  //  settings_optimization.translationNormalizationParameter = 1e-15;
+  //  settings_optimization.rotationNormalizationParameter = vcg::math::ToRad(1e-15);
+  settings_optimization.solverAccuracy = 1e-3;
+  //  settings_optimization.solverAccuracy = 1e-1;
   settings_optimization.objectiveWeights.translational = std::atof(argv[4]);
   settings_optimization.objectiveWeights.rotational = 2 - std::atof(argv[4]);
 
-  // Optimize pair
+  std::string xConcatNames;
-  const std::string pairName = fullPattern.getLabel() + "@" + reducedPattern.getLabel();
+  for (const auto &x : settings_optimization.parameterRanges) {
+      xConcatNames.append(x.label + "_");
+  }
+  xConcatNames.pop_back();
+
+  // Optimize pairthere
+  const std::string pairName = fullPattern.getLabel(); // + "@" + reducedPattern.getLabel();
   const std::string optimizationName = pairName + "("
                                        + std::to_string(settings_optimization.numberOfFunctionCalls)
                                        + "_"
                                        + to_string_with_precision(
                                            settings_optimization.objectiveWeights.translational)
-                                       + ")";
+                                       + ")" + "_" + xConcatNames;
   const bool input_resultDirectoryDefined = argc >= 6;
   const std::string optimizationResultsDirectory = input_resultDirectoryDefined
                                                        ? argv[5]
@@ -91,22 +103,21 @@ int main(int argc, char *argv[]) {
   }
 
   ReducedPatternOptimization::Results optimizationResults;
-  bool optimizationAlreadyComputed = optimizationResultFolderExists;
+  constexpr bool shouldReoptimize = true;
-  //  bool optimizationAlreadyComputed = false;
+  bool optimizationAlreadyComputed = false;
-  //  if (optimizationResultFolderExists) {
+  if (!shouldReoptimize && optimizationResultFolderExists) {
-  //      const bool resultsWereSuccessfullyLoaded = optimizationResults.load(resultsOutputDir);
+      const bool resultsWereSuccessfullyLoaded = optimizationResults.load(resultsOutputDir);
-  //      if (resultsWereSuccessfullyLoaded && optimizationResults.settings == settings_optimization) {
+      if (resultsWereSuccessfullyLoaded && optimizationResults.settings == settings_optimization) {
-  //      }
+          optimizationAlreadyComputed = true;
-  //  }
+      }
+  }
 
   if (!optimizationAlreadyComputed) {
       auto start = std::chrono::system_clock::now();
       const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
       assert(interfaceNodeIndex == numberOfNodesPerSlot[0] + numberOfNodesPerSlot[3]);
       ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
-      optimizer.initializePatterns(fullPattern,
+      optimizer.initializePatterns(fullPattern, reducedPattern, settings_optimization.parameterRanges);
-                                   reducedPattern,
-                                   settings_optimization.xRanges.size());
       optimizer.optimize(settings_optimization, optimizationResults);
       optimizationResults.label = optimizationName;
       optimizationResults.baseTriangleFullPattern.copy(fullPattern);
@@ -115,22 +126,27 @@ int main(int argc, char *argv[]) {
       auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
       optimizationResults.time = elapsed.count() / 1000.0;
 
-      if (optimizationResults.wasSuccessful) {
+      if (!optimizationResults.wasSuccessful) {
-          resultsOutputDir = convergedJobsDirPath.string();
+          //          resultsOutputDir = crashedJobsDirPath.string();
-          csvFile csv_results({}, false);
+          return 1;
-          //          csvFile csv_results(std::filesystem::path(resultsOutputDir).append("optimizationDistances.csv"), false);
-          csv_results << "Name";
-          optimizationResults.writeHeaderTo(csv_results);
-          settings_optimization.writeHeaderTo(csv_results);
-          csv_results << endrow;
-          csv_results << std::to_string(fullPattern.EN()) + "#" + pairName;
-          optimizationResults.writeResultsTo(settings_optimization, csv_results);
-          settings_optimization.writeSettingsTo(csv_results);
-          csv_results << endrow;
-      } else {
-          resultsOutputDir = crashedJobsDirPath.string();
       }
+      resultsOutputDir = convergedJobsDirPath.string();
       optimizationResults.save(resultsOutputDir, true);
+      csvFile csv_resultsLocalFile(std::filesystem::path(resultsOutputDir).append("results.csv"),
+                                   true);
+      csvFile csv_results({}, false);
+      std::vector<csvFile *> csvVector{&csv_resultsLocalFile, &csv_results};
+      csv_results << "Name";
+      csv_resultsLocalFile << "Name";
+      optimizationResults.writeHeaderTo(csvVector);
+      settings_optimization.writeHeaderTo(csv_results);
+      csv_results << endrow;
+      csv_resultsLocalFile << endrow;
+      csv_results << std::to_string(fullPattern.EN()) + "#" + pairName;
+      optimizationResults.writeResultsTo(csvVector);
+      settings_optimization.writeSettingsTo(csv_results);
+      csv_results << endrow;
+      csv_resultsLocalFile << endrow;
   }
 
 #ifdef POLYSCOPE_DEFINED

src/reducedmodeloptimizer.hpp

@@ -9,8 +9,10 @@
 #include "reducedmodeloptimizer_structs.hpp"
 #include "simulationmesh.hpp"
 #include <Eigen/Dense>
+#ifdef DLIB_DEFINED
 #include <dlib/global_optimization.h>
 #include <dlib/optimization.h>
+#endif
 
 #ifdef POLYSCOPE_DEFINED
 #include "polyscope/color_management.h"
@@ -36,9 +38,34 @@ class ReducedModelOptimizer
         constructBaseScenarioFunctions;
     std::vector<bool> scenarioIsSymmetrical;
     int fullPatternNumberOfEdges;
+    constexpr static double youngsModulus{1 * 1e9};
 
 public:
+    struct FunctionEvaluation
+    {
+        FunctionEvaluation() = default;
+        FunctionEvaluation(const std::vector<double> &x, double y) : x(x), y(y) {}
+
+        std::vector<double> x;
+        double y = std::numeric_limits<double>::quiet_NaN();
+    };
+
+    struct ParameterLabels
+    {
+        inline const static std::string E = {"E"};
+        inline const static std::string A = {"A"};
+        inline const static std::string I2 = {"I2"};
+        inline const static std::string I3 = {"I3"};
+        inline const static std::string J = {"J"};
+        inline const static std::string theta = {"Theta"};
+        inline const static std::string R = {"R"};
+    };
+    inline constexpr static ParameterLabels parameterLabels();
+
+    enum OptimizationParameterIndex { E, A, I2, I3, J, R, Theta, NumberOfOptimizationParameters };
+
     constexpr static std::array<int, 5> simulationScenariosResolution = {11, 11, 20, 20, 20};
+    constexpr static std::array<int, 5> baseScenarioWeights = {1, 1, 5, 5, 5};
     //    constexpr static std::array<int, 5> simulationScenariosResolution = {3, 3, 3, 3, 3};
     inline static int totalNumberOfSimulationScenarios
         = std::accumulate(simulationScenariosResolution.begin(),
@@ -67,21 +94,13 @@ public:
 
     SimulationJob getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);
 
-    void initializePatterns(PatternGeometry &fullPattern,
+    void initializePatterns(
-                            PatternGeometry &reducedPatterm,
+        PatternGeometry &fullPattern,
-                            const int &optimizationParameters);
+        PatternGeometry &reducedPatterm,
+        const std::vector<ReducedPatternOptimization::xRange> &optimizationParameters);
 
     static void runSimulation(const std::string &filename, std::vector<double> &x);
 
-    static double objective(double x2,
-                            double A,
-                            double J,
-                            double I2,
-                            double I3,
-                            double x3,
-                            double innerHexagonRotationAngle);
-    static double objective(double b, double r, double E);
-
     static std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationJobs(
         const std::shared_ptr<SimulationMesh> &pMesh,
         const std::unordered_map<size_t, size_t> &fullPatternOppositeInterfaceViMap);
@@ -177,6 +196,30 @@ public:
         const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>>
             &oppositeInterfaceViPairs,
         SimulationJob &job);
+    static std::function<void(const std::vector<double> &x,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern;
+    static std::function<void(const double &newE,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_E;
+    static std::function<void(const double &newA,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_A;
+    static std::function<void(const double &newI,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_I;
+    static std::function<void(const double &newI2,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_I2;
+    static std::function<void(const double &newI3,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_I3;
+    static std::function<void(const double &newJ,
+                              std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+        function_updateReducedPattern_material_J;
+    static double objective(const std::vector<double> &x);
+    static void initializeUpdateReducedPatternFunctions();
+    static double objective(const double &xValue);
 
 private:
     static void computeDesiredReducedModelDisplacements(
@@ -191,13 +234,14 @@ private:
             &maxForceMagnitudes);
     void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern);
     void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
-    static void initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh,
+    static void initializeOptimizationParameters(
-                                                 const int &optimizationParamters);
+        const std::shared_ptr<SimulationMesh> &mesh,
+        const std::vector<ReducedPatternOptimization::xRange> &optimizationParamters);
 
-    static double objective(long n, const double *x);
     DRMSimulationModel simulator;
     void computeObjectiveValueNormalizationFactors();
-    static void getResults(const dlib::function_evaluation &optimizationResult_dlib,
+
+    static void getResults(const FunctionEvaluation &optimalObjective,
                            const ReducedPatternOptimization::Settings &settings,
                            ReducedPatternOptimization::Results &results);
     double computeFullPatternMaxSimulationForce(
@@ -211,6 +255,30 @@ private:
     getFullPatternMaxSimulationForces(
         const std::vector<ReducedPatternOptimization::BaseSimulationScenario>
             &desiredBaseSimulationScenarioIndices);
+
+#ifdef DLIB_DEFINED
+    static double objective(const dlib::matrix<double, 0, 1> &x);
+#endif
 };
-void updateMesh(long n, const double *x);
+inline std::function<void(const double &newE,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_E;
+inline std::function<void(const double &newA,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_A;
+inline std::function<void(const double &newI,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_I;
+inline std::function<void(const double &newI2,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_I2;
+inline std::function<void(const double &newI3,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_I3;
+inline std::function<void(const double &newJ,
+                          std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh)>
+    ReducedModelOptimizer::function_updateReducedPattern_material_J;
+inline std::function<void(const std::vector<double> &x, std::shared_ptr<SimulationMesh> &m)>
+    ReducedModelOptimizer::function_updateReducedPattern;
+
 #endif // REDUCEDMODELOPTIMIZER_HPP