Merged potentialEnergyError branch

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "deps/MySources"]
+	path = deps/MySources
+	url = https://gitea-s2i2s.isti.cnr.it/manolas/MySources

CMakeLists.txt

@@ -1,20 +1,19 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.0)
 project(ReducedModelOptimization)
+#message(STATUS "The compiler ${CMAKE_CXX_COMPILER}")
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-        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)
 
 #Download external dependencies NOTE: If the user has one of these libs it shouldn't be downloaded again.
 include(${CMAKE_MODULE_PATH}/DownloadProject.cmake)
-if (CMAKE_VERSION VERSION_LESS 3.2)
-    set(UPDATE_DISCONNECTED_IF_AVAILABLE "")
-else()
-    set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1")
-endif()
-
+#if (CMAKE_VERSION VERSION_LESS 3.2)
+#    set(UPDATE_DISCONNECTED_IF_AVAILABLE "")
+#else()
+#    set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1")
+#endif()
 
 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE "RelWithDebInfo")
@@ -26,63 +25,6 @@ endif()
 ##Create directory for the external libraries
 file(MAKE_DIRECTORY ${EXTERNAL_DEPS_DIR})
 
-##Polyscope
-if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
-        set(USE_POLYSCOPE FALSE)
-else()
-        set(USE_POLYSCOPE TRUE)
-endif()
-if(${USE_POLYSCOPE})
-download_project(PROJ               POLYSCOPE
-                 GIT_REPOSITORY     https://github.com/nmwsharp/polyscope.git
-                 GIT_TAG	    master
-                 PREFIX             ${EXTERNAL_DEPS_DIR}
-                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
-)
-add_subdirectory(${POLYSCOPE_SOURCE_DIR} ${POLYSCOPE_BINARY_DIR})
-add_compile_definitions(POLYSCOPE_DEFINED)
-endif()
-
-
-set(MYSOURCES_SOURCE_DIR "/home/iason/Coding/Libraries/MySources")
-if (EXISTS ${MYSOURCES_SOURCE_DIR})
-else()
-##MySources
-download_project(PROJ               MYSOURCES
-                 GIT_REPOSITORY     https://gitea-s2i2s.isti.cnr.it/manolas/MySources.git
-                 GIT_TAG	    master
-                 PREFIX             ${EXTERNAL_DEPS_DIR}
-                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
-                 )
-endif()
-add_subdirectory(${MYSOURCES_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/MySourcesBinDir)
-
-#dlib
-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(${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)
 
@@ -90,19 +32,69 @@ 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)
+add_executable(${PROJECT_NAME} ${SOURCES})
+
+if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
+        set(USE_POLYSCOPE false)
+        set(MYSOURCES_STATIC_LINK true)
+        set(USE_ENSMALLEN true)
+else()
+#    set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+        set(USE_POLYSCOPE true)
+        if(${USE_POLYSCOPE})
+                add_compile_definitions(POLYSCOPE_DEFINED)
+        endif()
+        set(MYSOURCES_STATIC_LINK false)
+        set(USE_ENSMALLEN true)
+#        if(NOT ${MYSOURCES_STATIC_LINK})
+#                set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC" )
+#                set( CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fPIC" )
+#        endif()
+endif()
+if(${USE_ENSMALLEN})
+        add_compile_definitions(USE_ENSMALLEN)
+endif()
+
+#dlib
+set(DLIB_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/dlib)
+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(${DLIB_SOURCE_DIR} ${DLIB_BIN_DIR})
+if(${MYSOURCES_STATIC_LINK})
+        target_link_libraries(${PROJECT_NAME} PUBLIC -static dlib::dlib)
+else()
+        target_link_libraries(${PROJECT_NAME} PUBLIC dlib::dlib)
+endif()
+add_compile_definitions(DLIB_DEFINED)
+
+set(MYSOURCES_SOURCE_DIR "/home/iason/Coding/Libraries/MySources")
+set(MYSOURCES_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/MySourcesBinDir)
+if (EXISTS ${MYSOURCES_SOURCE_DIR})
+else()
+##MySources
+download_project(PROJ               MYSOURCES
+                 GIT_REPOSITORY     https://gitea-s2i2s.isti.cnr.it/manolas/MySources.git
+                 GIT_TAG	    master
+                 PREFIX             ${EXTERNAL_DEPS_DIR}
+                 BINARY_DIR         ${MYSOURCES_BIN_DIR}
+                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
+                 )
+endif()
+add_subdirectory(${MYSOURCES_SOURCE_DIR} ${MYSOURCES_BIN_DIR})
 
 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)
+if(${MYSOURCES_STATIC_LINK})
+        target_link_libraries(${PROJECT_NAME} PUBLIC #[[-static]] MySources)
 else()
-        target_link_libraries(${PROJECT_NAME} -static Eigen3::Eigen dlib::dlib MySources)
+        target_link_libraries(${PROJECT_NAME} PUBLIC MySources)
 endif()
+
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20)

deps/MySources

@@ -0,0 +1 @@
+Subproject commit f79e0acb4f3361939cc495956b7afb52a318d02b

main.py

@@ -0,0 +1,172 @@
+# 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
+from shutil import copyfile
+from enum import Enum
+
+numberOfOptimizedPatterns=0
+numberOfSkippedPatterns=0
+numberOfFunctionCalls=10
+start_time = datetime.now()
+def listener(q,resultsDir):
+    print("Entered")
+    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':
+                # 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,optimizationParameters,resultsDir,intermediateResultsDir):
+    """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,intermediateResultsDir,optimizationParameters)
+
+        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")
+        # print(output)
+        #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))
+
+def optimizeBatch(fullPatternDirectory,optimizationParameters,resultsDir,intermediateResultsDir):
+
+    watcher = pool.apply_async(listener, (q,resultsDir))
+    # print(optimizationParameters)
+    if not os.path.exists(resultsDir):
+        os.makedirs(resultsDir)
+      #shutil.rmtree(resultsDir)
+    reducedPatternFilepath= "/home/iason/Coding/Projects/Approximating shapes with flat patterns/ReducedModelOptimization/TestSet/ReducedPatterns/single_reduced.ply"
+    fullPatternFilepaths=[]
+    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)]
+    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)
+    print("Number of function calls:",numberOfFunctionCalls)
+    print("Full pattern test set directory:"+fullPatternDirectory)
+    print("Total number of optimization jobs:"+ str(totalNumberOfPatterns))
+    print("Results directory:"+str(resultsDir))
+    print("Start time:", start_time)
+    pool.starmap(optimize,jobs)
+    print("Completed")
+    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/variableComparison_ensmallen/',
+                                                           optimizationBatchName))
+        optimizeBatch(fullPatternDirectory,optimizationParameters,resultsDir,intermediateResultsDir)
+
+    pool.close()
+    pool.join()

src/main.cpp

@@ -1,15 +1,18 @@
 #include "csvfile.hpp"
 #include "drmsimulationmodel.hpp"
 #include "edgemesh.hpp"
+#include "reducedmodelevaluator.hpp"
 #include "reducedmodeloptimizer.hpp"
 #include "simulationhistoryplotter.hpp"
 #include "trianglepattterntopology.hpp"
+#include <boost/algorithm/string.hpp>
 #include <chrono>
 #include <filesystem>
 #include <iostream>
 #include <iterator>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <vcg/complex/algorithms/update/position.h>
 
 #ifdef POLYSCOPE_DEFINED
@@ -17,126 +20,199 @@
 #include "polyscope/point_cloud.h"
 #include "polyscope/polyscope.h"
 #endif
-int main(int argc, char *argv[]) {
-  if (argc < 3) {
-    std::cerr << "Specify at least the two pattern filepaths to be "
-                 "optimized.Exiting.."
-              << std::endl;
-    std::terminate();
-  }
+int main(int argc, char *argv[])
+{
+#ifdef POLYSCOPE_DEFINED
+//    ReducedModelOptimization::Results optResults;
+//    optResults.load("/home/iason/Desktop/selectionOfPatterns_0.2To1.6/selectionOfPatterns/1.2/"
+//                    "ConvergedJobs/12@single_reduced(100000_1.20)");
+//    ReducedModelEvaluator::evaluateReducedModel(optResults);
+//    return 0;
+#endif
+    if (argc < 3) {
+        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)Optimization results directory path\n"
+                     "4)[optional]Intermediate results directory path\n"
+                     "5)[optional]Optimization settings json file path\n"
+                     "Exiting.."
+                  << std::endl;
+        std::cerr << "Input arguments are:" << std::endl;
+        std::copy(argv + 1, argv + argc, std::ostream_iterator<const char *>(std::cout, "\n"));
+        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);
+    // 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{"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};
-  const bool input_numberOfFunctionCallsDefined = argc >= 4;
-  settings_optimization.numberOfFunctionCalls =
-      input_numberOfFunctionCallsDefined ? std::atoi(argv[3]) : 100;
-  settings_optimization.normalizationStrategy
-      = ReducedPatternOptimization::Settings::NormalizationStrategy::Epsilon;
+    // Set the optization settings
+    ReducedModelOptimization::Settings settings_optimization;
+    if (argc > 5) {
+        const std::filesystem::path optimizationSettingsFilePath = argv[5];
+        if (!std::filesystem::exists(optimizationSettingsFilePath)) {
+            std::cerr << "Input optimization settings file does not exist:"
+                      << optimizationSettingsFilePath << std::endl;
+        }
+#ifdef POLYSCOPE_DEFINED
+//    settings_optimization.save(optimizationSettingsFilePath.parent_path());
+//    std::cout << "Save settings to:" << optimizationSettingsFilePath << std::endl;
+#else
+//        settings_optimization.load(optimizationSettingsFilePath);
+#endif
+    }
+    //    settings_optimization.normalizationStrategy
+    //        = ReducedModelOptimization::Settings::NormalizationStrategy::NonNormalized;
+    settings_optimization.optimizationStrategy = {{ReducedModelOptimization::A,
+                                                   ReducedModelOptimization::I2,
+                                                   ReducedModelOptimization::I3,
+                                                   ReducedModelOptimization::J,
+                                                   ReducedModelOptimization::R,
+                                                   ReducedModelOptimization::Theta}};
+    //        settings_optimization.setDefault();
+    //    settings_optimization.rotationNormalizationEpsilon = 0;
 
-  settings_optimization.normalizationParameter = 0.0003;
-  settings_optimization.solverAccuracy = 0.001;
-  settings_optimization.objectiveWeights.translational = std::atof(argv[4]);
-  settings_optimization.objectiveWeights.rotational = 2 - std::atof(argv[4]);
+    // Optimize pairthere
+    const std::string optimizationName = std::to_string(fullPattern.EN()) + "#"
+                                         + fullPattern.getLabel();
+    const std::string optimizationResultsDirectory = argv[3];
+    std::string resultsOutputDir;
+    bool optimizationResultFolderExists = false;
+    const std::filesystem::path crashedJobsDirPath(
+        std::filesystem::path(optimizationResultsDirectory)
+            .append("CrashedJobs")
+            .append(optimizationName));
+    if (std::filesystem::exists(crashedJobsDirPath)) {
+        resultsOutputDir = crashedJobsDirPath.string();
+        optimizationResultFolderExists = true;
+    }
+    const std::filesystem::path convergedJobsDirPath(
+        std::filesystem::path(optimizationResultsDirectory)
+            .append("ConvergedJobs")
+            .append(optimizationName));
+    if (std::filesystem::exists(convergedJobsDirPath)) {
+        resultsOutputDir = convergedJobsDirPath.string();
+        optimizationResultFolderExists = true;
+    }
 
-  // Optimize pair
-  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)
-                                       + ")";
-  const bool input_resultDirectoryDefined = argc >= 6;
-  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)
-                                                     .append("CrashedJobs")
-                                                     .append(optimizationName));
-  if (std::filesystem::exists(crashedJobsDirPath)) {
-      resultsOutputDir = crashedJobsDirPath.string();
-      optimizationResultFolderExists = true;
-  }
-  const std::filesystem::path convergedJobsDirPath(
-      std::filesystem::path(optimizationResultsDirectory)
-          .append("ConvergedJobs")
-          .append(optimizationName));
-  if (std::filesystem::exists(convergedJobsDirPath)) {
-      resultsOutputDir = convergedJobsDirPath.string();
-      optimizationResultFolderExists = true;
-  }
+    ReducedModelOptimization::Results optimizationResults;
+    constexpr bool shouldReoptimize = true;
+    bool optimizationAlreadyComputed = false;
+    if (!shouldReoptimize && optimizationResultFolderExists) {
+        const bool resultsWereSuccessfullyLoaded = optimizationResults.load(resultsOutputDir);
+        if (resultsWereSuccessfullyLoaded && optimizationResults.settings == settings_optimization) {
+            optimizationAlreadyComputed = true;
+        }
+    }
 
-  ReducedPatternOptimization::Results optimizationResults;
-  bool optimizationAlreadyComputed = optimizationResultFolderExists;
-  //  bool optimizationAlreadyComputed = false;
-  //  if (optimizationResultFolderExists) {
-  //      const bool resultsWereSuccessfullyLoaded = optimizationResults.load(resultsOutputDir);
-  //      if (resultsWereSuccessfullyLoaded && optimizationResults.settings == settings_optimization) {
-  //      }
-  //  }
+    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);
+        const bool input_intermediateResultsDirectoryDefined = argc == 5;
+        if (input_intermediateResultsDirectoryDefined) {
+            optimizer.setIntermediateResultsDirectoryPath(std::filesystem::path(argv[4]));
+        }
+        optimizer.initializePatterns(fullPattern,
+                                     reducedPattern,
+                                     settings_optimization.variablesRanges);
+        optimizer.optimize(settings_optimization, optimizationResults);
+        optimizationResults.label = optimizationName;
+        optimizationResults.baseTriangleFullPattern.copy(fullPattern);
+        optimizationResults.settings = settings_optimization;
+        auto end = std::chrono::system_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        optimizationResults.time = elapsed.count() / 1000.0;
 
-  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,
-                                   reducedPattern,
-                                   settings_optimization.xRanges.size());
-      optimizer.optimize(settings_optimization, optimizationResults);
-      optimizationResults.label = optimizationName;
-      optimizationResults.baseTriangleFullPattern.copy(fullPattern);
-      optimizationResults.settings = settings_optimization;
-      auto end = std::chrono::system_clock::now();
-      auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
-      optimizationResults.time = elapsed.count() / 1000.0;
-
-      if (optimizationResults.wasSuccessful) {
-          resultsOutputDir = convergedJobsDirPath.string();
-          csvFile csv_results({}, false);
-          //          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();
-      }
-      optimizationResults.save(resultsOutputDir, true);
-  }
+        if (!optimizationResults.wasSuccessful) {
+            //          resultsOutputDir = crashedJobsDirPath.string();
+            return 1;
+        }
+        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 << optimizationName;
+        csv_resultsLocalFile << optimizationName;
+        optimizationResults.writeResultsTo(csvVector);
+        settings_optimization.writeSettingsTo(csv_results);
+        csv_results << endrow;
+        csv_resultsLocalFile << endrow;
+    }
 
 #ifdef POLYSCOPE_DEFINED
-  //    optimizationResults.saveMeshFiles();
-  optimizationResults.draw();
-#endif
+    std::vector<std::string> scenarioLabels(
+        optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    const double colorAxial = 1;
+    const double colorShear = 3;
+    const double colorBending = 5;
+    const double colorDome = 0.1;
+    const double colorSaddle = 0;
+    std::vector<double> colors(
+        optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    for (int scenarioIndex = 0; scenarioIndex < scenarioLabels.size(); scenarioIndex++) {
+        scenarioLabels[scenarioIndex]
+            = optimizationResults.reducedPatternSimulationJobs[scenarioIndex]->getLabel();
+        if (scenarioLabels[scenarioIndex].rfind("Axial", 0) == 0) {
+            colors[scenarioIndex] = colorAxial;
 
-  return 0;
+        } else if (scenarioLabels[scenarioIndex].rfind("Shear", 0) == 0) {
+            colors[scenarioIndex] = colorShear;
+
+        } else if (scenarioLabels[scenarioIndex].rfind("Bending", 0) == 0) {
+            colors[scenarioIndex] = colorBending;
+
+        } else if (scenarioLabels[scenarioIndex].rfind("Dome", 0) == 0) {
+            colors[scenarioIndex] = colorDome;
+        } else if (scenarioLabels[scenarioIndex].rfind("Saddle", 0) == 0) {
+            colors[scenarioIndex] = colorSaddle;
+        } else {
+            std::cerr << "Label could not be identified" << std::endl;
+        }
+    }
+    std::vector<double> y(optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    for (int scenarioIndex = 0; scenarioIndex < scenarioLabels.size(); scenarioIndex++) {
+        y[scenarioIndex]
+            //          = optimizationResults.objectiveValue.perSimulationScenario_rawTranslational[scenarioIndex]
+            //            + optimizationResults.objectiveValue.perSimulationScenario_rawRotational[scenarioIndex];
+            = optimizationResults.objectiveValue
+                  .perSimulationScenario_total_unweighted[scenarioIndex];
+    }
+    std::vector<double> x = matplot::linspace(0, y.size() - 1, y.size());
+    std::vector<double> markerSizes(y.size(), 5);
+    SimulationResultsReporter::createPlot("scenario index",
+                                          "error",
+                                          x,
+                                          y,
+                                          markerSizes,
+                                          colors,
+                                          std::filesystem::path(resultsOutputDir)
+                                              .append("perScenarioObjectiveValues.png"));
+    //    optimizationResults.saveMeshFiles();
+    std::cout << "Saved results to:" << resultsOutputDir << std::endl;
+    //    optimizationResults.draw();
+
+    const auto evaluationResults = ReducedModelEvaluator::evaluateReducedModel(optimizationResults);
+    ReducedModelEvaluator::printResults(evaluationResults, optimizationResults.label);
+#endif
+    return 0;
 }

src/main.cpp.orig

@@ -0,0 +1,218 @@
+#include "csvfile.hpp"
+#include "drmsimulationmodel.hpp"
+#include "edgemesh.hpp"
+#include "reducedmodelevaluator.hpp"
+#include "reducedmodeloptimizer.hpp"
+#include "simulationhistoryplotter.hpp"
+#include "trianglepattterntopology.hpp"
+#include <boost/algorithm/string.hpp>
+#include <chrono>
+#include <filesystem>
+#include <iostream>
+#include <iterator>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#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
+int main(int argc, char *argv[])
+{
+<<<<<<< HEAD
+    //    ReducedModelOptimization::Results optResults;
+    //    optResults.load("/home/iason/Desktop/finding_submissionCode/"
+    //                    "build-ReducedModelOptimization-Clang-RelWithDebInfo/OptimizationResults/"
+    //                    "ConvergedJobs/12@single_reduced(100000_1.20)");
+    //    ReducedModelEvaluator::evaluateReducedModel(optResults);
+    if (argc <= 5) {
+=======
+#ifdef POLYSCOPE_DEFINED
+//    ReducedModelOptimization::Results optResults;
+//    optResults.load("/home/iason/Desktop/selectionOfPatterns_0.2To1.6/selectionOfPatterns/1.2/"
+//                    "ConvergedJobs/12@single_reduced(100000_1.20)");
+//    ReducedModelEvaluator::evaluateReducedModel(optResults);
+//    return 0;
+#endif
+    if (argc < 3) {
+>>>>>>> potentialEnergyError
+        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)Optimization results directory path\n"
+                     "4)[optional]Intermediate results directory path\n"
+                     "5)[optional]Optimization settings json file path\n"
+                     "Exiting.."
+                  << std::endl;
+        std::cerr << "Input arguments are:" << std::endl;
+        std::copy(argv + 1, argv + argc, std::ostream_iterator<const char *>(std::cout, "\n"));
+        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
+    ReducedModelOptimization::Settings settings_optimization;
+    if (argc > 5) {
+        const std::filesystem::path optimizationSettingsFilePath = argv[5];
+        if (!std::filesystem::exists(optimizationSettingsFilePath)) {
+            std::cerr << "Input optimization settings file does not exist:"
+                      << optimizationSettingsFilePath << std::endl;
+        }
+#ifdef POLYSCOPE_DEFINED
+//    settings_optimization.save(optimizationSettingsFilePath.parent_path());
+//    std::cout << "Save settings to:" << optimizationSettingsFilePath << std::endl;
+#else
+        settings_optimization.load(optimizationSettingsFilePath);
+#endif
+    }
+    //        settings_optimization.setDefault();
+    //    settings_optimization.rotationNormalizationEpsilon = 0;
+
+    // Optimize pairthere
+    const std::string optimizationName = std::to_string(fullPattern.EN()) + "#"
+                                         + fullPattern.getLabel();
+    const std::string optimizationResultsDirectory = argv[3];
+    std::string resultsOutputDir;
+    bool optimizationResultFolderExists = false;
+    const std::filesystem::path crashedJobsDirPath(
+        std::filesystem::path(optimizationResultsDirectory)
+            .append("CrashedJobs")
+            .append(optimizationName));
+    if (std::filesystem::exists(crashedJobsDirPath)) {
+        resultsOutputDir = crashedJobsDirPath.string();
+        optimizationResultFolderExists = true;
+    }
+    const std::filesystem::path convergedJobsDirPath(
+        std::filesystem::path(optimizationResultsDirectory)
+            .append("ConvergedJobs")
+            .append(optimizationName));
+    if (std::filesystem::exists(convergedJobsDirPath)) {
+        resultsOutputDir = convergedJobsDirPath.string();
+        optimizationResultFolderExists = true;
+    }
+
+    ReducedModelOptimization::Results optimizationResults;
+    constexpr bool shouldReoptimize = true;
+    bool optimizationAlreadyComputed = false;
+    if (!shouldReoptimize && optimizationResultFolderExists) {
+        const bool resultsWereSuccessfullyLoaded = optimizationResults.load(resultsOutputDir);
+        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);
+        const bool input_intermediateResultsDirectoryDefined = argc == 5;
+        if (input_intermediateResultsDirectoryDefined) {
+            optimizer.setIntermediateResultsDirectoryPath(std::filesystem::path(argv[4]));
+        }
+        optimizer.initializePatterns(fullPattern,
+                                     reducedPattern,
+                                     settings_optimization.variablesRanges);
+        optimizer.optimize(settings_optimization, optimizationResults);
+        optimizationResults.label = optimizationName;
+        optimizationResults.baseTriangleFullPattern.copy(fullPattern);
+        optimizationResults.settings = settings_optimization;
+        auto end = std::chrono::system_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        optimizationResults.time = elapsed.count() / 1000.0;
+
+        if (!optimizationResults.wasSuccessful) {
+            //          resultsOutputDir = crashedJobsDirPath.string();
+            return 1;
+        }
+        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 << optimizationName;
+        csv_resultsLocalFile << optimizationName;
+        optimizationResults.writeResultsTo(csvVector);
+        settings_optimization.writeSettingsTo(csv_results);
+        csv_results << endrow;
+        csv_resultsLocalFile << endrow;
+    }
+
+#ifdef POLYSCOPE_DEFINED
+    ReducedModelEvaluator::evaluateReducedModel(optimizationResults);
+    std::vector<std::string> scenarioLabels(
+        optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    const double colorAxial = 1;
+    const double colorShear = 3;
+    const double colorBending = 5;
+    const double colorDome = 0.1;
+    const double colorSaddle = 0;
+    std::vector<double> colors(
+        optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    for (int scenarioIndex = 0; scenarioIndex < scenarioLabels.size(); scenarioIndex++) {
+        scenarioLabels[scenarioIndex]
+            = optimizationResults.reducedPatternSimulationJobs[scenarioIndex]->getLabel();
+        if (scenarioLabels[scenarioIndex].rfind("Axial", 0) == 0) {
+            colors[scenarioIndex] = colorAxial;
+
+        } else if (scenarioLabels[scenarioIndex].rfind("Shear", 0) == 0) {
+            colors[scenarioIndex] = colorShear;
+
+        } else if (scenarioLabels[scenarioIndex].rfind("Bending", 0) == 0) {
+            colors[scenarioIndex] = colorBending;
+
+        } else if (scenarioLabels[scenarioIndex].rfind("Dome", 0) == 0) {
+            colors[scenarioIndex] = colorDome;
+        } else if (scenarioLabels[scenarioIndex].rfind("Saddle", 0) == 0) {
+            colors[scenarioIndex] = colorSaddle;
+        } else {
+            std::cerr << "Label could not be identified" << std::endl;
+        }
+    }
+    std::vector<double> y(optimizationResults.objectiveValue.perSimulationScenario_total.size());
+    for (int scenarioIndex = 0; scenarioIndex < scenarioLabels.size(); scenarioIndex++) {
+        y[scenarioIndex]
+            //          = optimizationResults.objectiveValue.perSimulationScenario_rawTranslational[scenarioIndex]
+            //            + optimizationResults.objectiveValue.perSimulationScenario_rawRotational[scenarioIndex];
+            = optimizationResults.objectiveValue
+                  .perSimulationScenario_total_unweighted[scenarioIndex];
+    }
+    std::vector<double> x = matplot::linspace(0, y.size() - 1, y.size());
+    std::vector<double> markerSizes(y.size(), 5);
+    SimulationResultsReporter::createPlot("scenario index",
+                                          "error",
+                                          x,
+                                          y,
+                                          markerSizes,
+                                          colors,
+                                          std::filesystem::path(resultsOutputDir)
+                                              .append("perScenarioObjectiveValues.png"));
+    //    optimizationResults.saveMeshFiles();
+    std::cout << "Saved results to:" << resultsOutputDir << std::endl;
+    optimizationResults.draw();
+
+#endif
+  return 0;
+}

src/reducedmodeloptimizer.hpp

@@ -5,12 +5,16 @@
 #include "drmsimulationmodel.hpp"
 #include "edgemesh.hpp"
 #include "linearsimulationmodel.hpp"
+#ifdef POLYSCOPE_DEFINED
 #include "matplot/matplot.h"
+#endif
 #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,10 +40,37 @@ class ReducedModelOptimizer
         constructBaseScenarioFunctions;
     std::vector<bool> scenarioIsSymmetrical;
     int fullPatternNumberOfEdges;
+    constexpr static double youngsModulus{1 * 1e9};
+    std::filesystem::path intermediateResultsDirectoryPath;
 
 public:
-    constexpr static std::array<int, 5> simulationScenariosResolution = {11, 11, 20, 20, 20};
-    //    constexpr static std::array<int, 5> simulationScenariosResolution = {3, 3, 3, 3, 3};
+    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 th= {"Theta"};
+    //        inline const static std::string R = {"R"};
+    //    };
+    //    inline constexpr static ParameterLabels parameterLabels();
+
+    inline static std::array<std::string, ReducedModelOptimization::NumberOfOptimizationVariables>
+        parameterLabels = {"E", "A", "I2", "I3", "J", "Theta", "R"};
+    constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
+        simulationScenariosResolution = {11, 11, 20, 20, 20};
+    constexpr static std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
+        baseScenarioWeights = {1, 1, 2, 3, 2};
     inline static int totalNumberOfSimulationScenarios
         = std::accumulate(simulationScenariosResolution.begin(),
                           simulationScenariosResolution.end(),
@@ -48,15 +79,15 @@ public:
     inline static double initialHexagonSize{0.3};
     inline static VectorType patternPlaneNormal{0, 0, 1};
     void optimize(
-        const ReducedPatternOptimization::Settings &xRanges,
-        ReducedPatternOptimization::Results &results,
-        const std::vector<ReducedPatternOptimization::BaseSimulationScenario> &simulationScenarios
-        = std::vector<ReducedPatternOptimization::BaseSimulationScenario>(
-            {ReducedPatternOptimization::Axial,
-             ReducedPatternOptimization::Shear,
-             ReducedPatternOptimization::Bending,
-             ReducedPatternOptimization::Dome,
-             ReducedPatternOptimization::Saddle}));
+        const ReducedModelOptimization::Settings &xRanges,
+        ReducedModelOptimization::Results &results,
+        const std::vector<ReducedModelOptimization::BaseSimulationScenario> &simulationScenarios
+        = std::vector<ReducedModelOptimization::BaseSimulationScenario>(
+            {ReducedModelOptimization::Axial,
+             ReducedModelOptimization::Shear,
+             ReducedModelOptimization::Bending,
+             ReducedModelOptimization::Dome,
+             ReducedModelOptimization::Saddle}));
     double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;
 
     ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot);
@@ -67,21 +98,8 @@ public:
 
     SimulationJob getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);
 
-    void initializePatterns(PatternGeometry &fullPattern,
-                            PatternGeometry &reducedPatterm,
-                            const int &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);
@@ -103,7 +121,7 @@ public:
     static void visualizeResults(
         const std::vector<std::shared_ptr<SimulationJob>> &fullPatternSimulationJobs,
         const std::vector<std::shared_ptr<SimulationJob>> &reducedPatternSimulationJobs,
-        const std::vector<ReducedPatternOptimization::BaseSimulationScenario> &simulationScenarios,
+        const std::vector<ReducedModelOptimization::BaseSimulationScenario> &simulationScenarios,
         const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
             &reducedToFullInterfaceViMap);
     static void registerResultsForDrawing(
@@ -130,14 +148,13 @@ public:
                             double innerHexagonSize,
                             double innerHexagonRotationAngle);
     static double computeRawRotationalError(
-        const std::vector<Eigen::Quaternion<double>> &rotatedQuaternion_fullPattern,
-        const std::vector<Eigen::Quaternion<double>> &rotatedQuaternion_reducedPattern,
+        const std::vector<Eigen::Quaterniond> &rotatedQuaternion_fullPattern,
+        const std::vector<Eigen::Quaterniond> &rotatedQuaternion_reducedPattern,
         const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
             &reducedToFullInterfaceViMap);
 
-    static double computeRotationalError(
-        const std::vector<Eigen::Quaternion<double>> &rotatedQuaternion_fullPattern,
-        const std::vector<Eigen::Quaternion<double>> &rotatedQuaternion_reducedPattern,
+    static double computeRotationalError(const std::vector<Eigen::Quaterniond> &rotatedQuaternion_fullPattern,
+        const std::vector<Eigen::Quaterniond> &rotatedQuaternion_reducedPattern,
         const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
             &reducedToFullInterfaceViMap,
         const double &normalizationFactor);
@@ -147,7 +164,9 @@ public:
         const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
             &reducedToFullInterfaceViMap,
         const double &normalizationFactor_translationalDisplacement,
-        const double &normalizationFactor_rotationalDisplacement);
+        const double &normalizationFactor_rotationalDisplacement,
+        const double &scenarioWeight,
+        const ReducedModelOptimization::Settings::ObjectiveWeights &objectiveWeights);
     static void constructAxialSimulationScenario(
         const double &forceMagnitude,
         const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>>
@@ -177,40 +196,103 @@ 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);
+
+    void initializePatterns(PatternGeometry &fullPattern,
+                            PatternGeometry &reducedPattern,
+                            const std::array<ReducedModelOptimization::xRange,
+                                             ReducedModelOptimization::NumberOfOptimizationVariables>
+                                &optimizationParameters);
+
+    void setIntermediateResultsDirectoryPath(
+        const std::filesystem::path &newIntermediateResultsDirectoryPath);
 
 private:
     static void computeDesiredReducedModelDisplacements(
         const SimulationResults &fullModelResults,
         const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
         Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
-    static void runOptimization(const ReducedPatternOptimization::Settings &settings,
-                                ReducedPatternOptimization::Results &results);
-    std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationJobs(
-        const std::shared_ptr<SimulationMesh> &pMesh,
-        const std::vector<std::pair<ReducedPatternOptimization::BaseSimulationScenario, double>>
-            &maxForceMagnitudes);
+    static void runOptimization(const ReducedModelOptimization::Settings &settings,
+                                ReducedModelOptimization::Results &results);
     void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern);
     void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
-    static void initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh,
-                                                 const int &optimizationParamters);
+    static void initializeOptimizationParameters(
+        const std::shared_ptr<SimulationMesh> &mesh,
+        const std::array<ReducedModelOptimization::xRange,
+                         ReducedModelOptimization::NumberOfOptimizationVariables>
+            &optimizationParamters);
 
-    static double objective(long n, const double *x);
     DRMSimulationModel simulator;
     void computeObjectiveValueNormalizationFactors();
-    static void getResults(const dlib::function_evaluation &optimizationResult_dlib,
-                           const ReducedPatternOptimization::Settings &settings,
-                           ReducedPatternOptimization::Results &results);
-    double computeFullPatternMaxSimulationForce(
-        const ReducedPatternOptimization::BaseSimulationScenario &scenario);
-    std::vector<std::pair<ReducedPatternOptimization::BaseSimulationScenario, double>>
-    computeFullPatternMaxSimulationForces(
-        const std::vector<ReducedPatternOptimization::BaseSimulationScenario>
-            &desiredBaseSimulationScenarioIndices);
 
-    std::vector<std::pair<ReducedPatternOptimization::BaseSimulationScenario, double>>
+    static void getResults(const FunctionEvaluation &optimalObjective,
+                           const ReducedModelOptimization::Settings &settings,
+                           ReducedModelOptimization::Results &results);
+    double computeFullPatternMaxSimulationForce(
+        const ReducedModelOptimization::BaseSimulationScenario &scenario) const;
+
+#ifdef DLIB_DEFINED
+    static double objective(const dlib::matrix<double, 0, 1> &x);
+#endif
+    void computeScenarioWeights(const std::vector<ReducedModelOptimization::BaseSimulationScenario>
+                                    &baseSimulationScenarios);
+    std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
+    computeFullPatternMaxSimulationForces(
+        const std::vector<ReducedModelOptimization::BaseSimulationScenario>
+            &desiredBaseSimulationScenario) const;
+    std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationJobs(
+        const std::shared_ptr<SimulationMesh> &pMesh,
+        const std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
+            &baseScenarioMaxForceMagnitudes) const;
+    std::array<double, ReducedModelOptimization::NumberOfBaseSimulationScenarios>
     getFullPatternMaxSimulationForces(
-        const std::vector<ReducedPatternOptimization::BaseSimulationScenario>
-            &desiredBaseSimulationScenarioIndices);
+        const std::vector<ReducedModelOptimization::BaseSimulationScenario>
+            &desiredBaseSimulationScenarioIndices,
+        const std::filesystem::path &intermediateResultsDirectoryPath,
+        const bool &recomputeForceMagnitudes);
 };
-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