manolas
/
ReducedModelOptimization
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: manolas:perParameterUpdateFunctions
Branches Tags
manolas:master
manolas:optimizationParameters
manolas:potentialEnergyError
manolas:perParameterUpdateFunctions
manolas:functionCallsComparison
manolas:multipleSimulationScenarios
manolas:linearSimulationModel
..
compare: manolas:master
Branches Tags
manolas:optimizationParameters
manolas:potentialEnergyError
manolas:perParameterUpdateFunctions
manolas:functionCallsComparison
manolas:master
manolas:multipleSimulationScenarios
manolas:linearSimulationModel

No commits in common. "perParameterUpdateFunctions" and "master" have entirely different histories.
perParamet ... master

5 changed files with 553 additions and 1088 deletions
Show Stats Expand all files Collapse all files

102
CMakeLists.txt
View File

@ -1,8 +1,8 @@
cmake_minimum_required(VERSION 3.0) cmake_minimum_required(VERSION 2.8)
project(ReducedModelOptimization) project(ReducedModelOptimization)
set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON) 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 #Add the project cmake scripts to the module path
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
@ -15,6 +15,7 @@ else()
set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1") set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1")
endif() endif()
if(NOT CMAKE_BUILD_TYPE) if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "RelWithDebInfo") set(CMAKE_BUILD_TYPE "RelWithDebInfo")
set(EXTERNAL_DEPS_DIR "C:/Users/iason/Downloads/ReducedModelOptimization/build/externalDependencies/") set(EXTERNAL_DEPS_DIR "C:/Users/iason/Downloads/ReducedModelOptimization/build/externalDependencies/")
@ -25,48 +26,23 @@ endif()
##Create directory for the external libraries ##Create directory for the external libraries
file(MAKE_DIRECTORY ${EXTERNAL_DEPS_DIR}) 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") if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
set(USE_POLYSCOPE false) set(USE_POLYSCOPE FALSE)
set(MYSOURCES_STATIC_LINK true)
set(USE_ENSMALLEN false)
else() else()
set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE TRUE) set(USE_POLYSCOPE 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() endif()
if(${USE_POLYSCOPE})
#dlib download_project(PROJ POLYSCOPE
set(DLIB_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/dlib_bin) GIT_REPOSITORY https://github.com/nmwsharp/polyscope.git
file(MAKE_DIRECTORY ${DLIB_BIN_DIR})
download_project(PROJ DLIB
GIT_REPOSITORY https://github.com/davisking/dlib.git
GIT_TAG master GIT_TAG master
BINARY_DIR ${DLIB_BIN_DIR}
PREFIX ${EXTERNAL_DEPS_DIR} PREFIX ${EXTERNAL_DEPS_DIR}
${UPDATE_DISCONNECTED_IF_AVAILABLE} ${UPDATE_DISCONNECTED_IF_AVAILABLE}
) )
add_subdirectory(${DLIB_SOURCE_DIR} ${DLIB_BINARY_DIR}) add_subdirectory(${POLYSCOPE_SOURCE_DIR} ${POLYSCOPE_BINARY_DIR})
if(${MYSOURCES_STATIC_LINK}) add_compile_definitions(POLYSCOPE_DEFINED)
target_link_libraries(${PROJECT_NAME} "-static" dlib::dlib)
else()
target_link_libraries(${PROJECT_NAME} dlib::dlib)
endif() endif()
add_compile_definitions(DLIB_DEFINED)
set(MYSOURCES_SOURCE_DIR "/home/iason/Coding/Libraries/MySources") set(MYSOURCES_SOURCE_DIR "/home/iason/Coding/Libraries/MySources")
if (EXISTS ${MYSOURCES_SOURCE_DIR}) if (EXISTS ${MYSOURCES_SOURCE_DIR})
@ -81,16 +57,52 @@ download_project(PROJ MYSOURCES
endif() endif()
add_subdirectory(${MYSOURCES_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/MySourcesBinDir) add_subdirectory(${MYSOURCES_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/MySourcesBinDir)
target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20) #dlib
target_include_directories(${PROJECT_NAME} set(DLIB_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}/dlib_bin)
PUBLIC ${MYSOURCES_SOURCE_DIR} file(MAKE_DIRECTORY ${DLIB_BIN_DIR})
) download_project(PROJ DLIB
if(${MYSOURCES_STATIC_LINK}) GIT_REPOSITORY https://github.com/davisking/dlib.git
target_link_libraries(${PROJECT_NAME} -static Eigen3::Eigen MySources) GIT_TAG master
else() BINARY_DIR ${DLIB_BIN_DIR}
target_link_libraries(${PROJECT_NAME} Eigen3::Eigen MySources) PREFIX ${EXTERNAL_DEPS_DIR}
endif() ${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 ##Eigen 3 NOTE: Eigen is required on the system the code is ran
find_package(Eigen3 3.3 REQUIRED) 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()

130
main.py
View File

@ -1,130 +0,0 @@
# 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()

88
src/main.cpp
View File

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

1219
src/reducedmodeloptimizer.cpp
View File

File diff suppressed because it is too large Load Diff

102
src/reducedmodeloptimizer.hpp
View File

@ -9,10 +9,8 @@
#include "reducedmodeloptimizer_structs.hpp" #include "reducedmodeloptimizer_structs.hpp"
#include "simulationmesh.hpp" #include "simulationmesh.hpp"
#include <Eigen/Dense> #include <Eigen/Dense>
#ifdef DLIB_DEFINED
#include <dlib/global_optimization.h> #include <dlib/global_optimization.h>
#include <dlib/optimization.h> #include <dlib/optimization.h>
#endif
#ifdef POLYSCOPE_DEFINED #ifdef POLYSCOPE_DEFINED
#include "polyscope/color_management.h" #include "polyscope/color_management.h"
@ -38,34 +36,9 @@ class ReducedModelOptimizer
constructBaseScenarioFunctions; constructBaseScenarioFunctions;
std::vector<bool> scenarioIsSymmetrical; std::vector<bool> scenarioIsSymmetrical;
int fullPatternNumberOfEdges; int fullPatternNumberOfEdges;
constexpr static double youngsModulus{1 * 1e9};
public: 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> 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}; // constexpr static std::array<int, 5> simulationScenariosResolution = {3, 3, 3, 3, 3};
inline static int totalNumberOfSimulationScenarios inline static int totalNumberOfSimulationScenarios
= std::accumulate(simulationScenariosResolution.begin(), = std::accumulate(simulationScenariosResolution.begin(),
@ -94,13 +67,21 @@ public:
SimulationJob getReducedSimulationJob(const SimulationJob &fullModelSimulationJob); SimulationJob getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);
void initializePatterns( void initializePatterns(PatternGeometry &fullPattern,
PatternGeometry &fullPattern, PatternGeometry &reducedPatterm,
PatternGeometry &reducedPatterm, const int &optimizationParameters);
const std::vector<ReducedPatternOptimization::xRange> &optimizationParameters);
static void runSimulation(const std::string &filename, std::vector<double> &x); 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( static std::vector<std::shared_ptr<SimulationJob>> createFullPatternSimulationJobs(
const std::shared_ptr<SimulationMesh> &pMesh, const std::shared_ptr<SimulationMesh> &pMesh,
const std::unordered_map<size_t, size_t> &fullPatternOppositeInterfaceViMap); const std::unordered_map<size_t, size_t> &fullPatternOppositeInterfaceViMap);
@ -196,30 +177,6 @@ public:
const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>> const std::vector<std::pair<FullPatternVertexIndex, FullPatternVertexIndex>>
&oppositeInterfaceViPairs, &oppositeInterfaceViPairs,
SimulationJob &job); 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: private:
static void computeDesiredReducedModelDisplacements( static void computeDesiredReducedModelDisplacements(
@ -234,14 +191,13 @@ private:
&maxForceMagnitudes); &maxForceMagnitudes);
void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern); void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern);
void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel); void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
static void initializeOptimizationParameters( static void initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh,
const std::shared_ptr<SimulationMesh> &mesh, const int &optimizationParamters);
const std::vector<ReducedPatternOptimization::xRange> &optimizationParamters);
static double objective(long n, const double *x);
DRMSimulationModel simulator; DRMSimulationModel simulator;
void computeObjectiveValueNormalizationFactors(); void computeObjectiveValueNormalizationFactors();
static void getResults(const dlib::function_evaluation &optimizationResult_dlib,
static void getResults(const FunctionEvaluation &optimalObjective,
const ReducedPatternOptimization::Settings &settings, const ReducedPatternOptimization::Settings &settings,
ReducedPatternOptimization::Results &results); ReducedPatternOptimization::Results &results);
double computeFullPatternMaxSimulationForce( double computeFullPatternMaxSimulationForce(
@ -255,30 +211,6 @@ private:
getFullPatternMaxSimulationForces( getFullPatternMaxSimulationForces(
const std::vector<ReducedPatternOptimization::BaseSimulationScenario> const std::vector<ReducedPatternOptimization::BaseSimulationScenario>
&desiredBaseSimulationScenarioIndices); &desiredBaseSimulationScenarioIndices);
#ifdef DLIB_DEFINED
static double objective(const dlib::matrix<double, 0, 1> &x);
#endif
}; };
inline std::function<void(const double &newE, void updateMesh(long n, const double *x);
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 #endif // REDUCEDMODELOPTIMIZER_HPP