def __init__(self, OptimizationSettings, Analyzer, Communicator, ModelPartController):
default_algorithm_settings = Parameters("""
{
"name" : "penalized_projection",
"correction_scaling" : 1.0,
"use_adaptive_correction" : true,
"max_iterations" : 100,
"relative_tolerance" : 1e-3,
"line_search" : {
"line_search_type" : "manual_stepping",
"normalize_search_direction" : true,
"step_size" : 1.0
}
}""")
self.algorithm_settings = OptimizationSettings["optimization_algorithm"]
self.algorithm_settings.RecursivelyValidateAndAssignDefaults(default_algorithm_settings)
self.Analyzer = Analyzer
self.Communicator = Communicator
self.ModelPartController = ModelPartController
self.objectives = OptimizationSettings["objectives"]
self.constraints = OptimizationSettings["constraints"]
self.OptimizationModelPart = ModelPartController.GetOptimizationModelPart()
self.DesignSurface = ModelPartController.GetDesignSurface()
self.Mapper = mapper_factory.CreateMapper(self.DesignSurface, self.DesignSurface, OptimizationSettings["design_variables"]["filter"])
self.DataLogger = data_logger_factory.CreateDataLogger(ModelPartController, Communicator, OptimizationSettings)
self.OptimizationUtilities = OptimizationUtilities(self.DesignSurface, OptimizationSettings)
def __init__(self, OptimizationSettings, ModelPartController, Analyzer,
Communicator):
self.OptimizationSettings = OptimizationSettings
self.ModelPartController = ModelPartController
self.Analyzer = Analyzer
self.Communicator = Communicator
self.OptimizationModelPart = ModelPartController.GetOptimizationModelPart(
)
self.DesignSurface = ModelPartController.GetDesignSurface()
self.maxIterations = OptimizationSettings["optimization_algorithm"][
"max_iterations"].GetInt() + 1
self.projectionOnNormalsIsSpecified = OptimizationSettings[
"optimization_algorithm"][
"project_gradients_on_surface_normals"].GetBool()
self.onlyObjectiveId = OptimizationSettings["objectives"][0][
"identifier"].GetString()
self.dampingIsSpecified = OptimizationSettings["design_variables"][
"damping"]["perform_damping"].GetBool()
self.Mapper = mapper_factory.CreateMapper(ModelPartController,
OptimizationSettings)
self.DataLogger = data_logger_factory.CreateDataLogger(
ModelPartController, Communicator, OptimizationSettings)
self.GeometryUtilities = GeometryUtilities(self.DesignSurface)
self.OptimizationUtilities = OptimizationUtilities(
self.DesignSurface, OptimizationSettings)
if self.dampingIsSpecified:
damping_regions = self.ModelPartController.GetDampingRegions()
self.DampingUtilities = DampingUtilities(self.DesignSurface,
damping_regions,
self.OptimizationSettings)
def CreateAlgorithm(OptimizationModelPart, Analyzer, OptimizationSettings):
AlgorithmName = OptimizationSettings["optimization_algorithm"][
"name"].GetString()
DesignSurface = GetDesignSurfaceFromOptimizationModelPart(
OptimizationModelPart, OptimizationSettings)
DampingRegions = GetDampingRegionsFromOptimizationModelPart(
OptimizationModelPart, OptimizationSettings)
Mapper = mapper_factory.CreateMapper(DesignSurface, OptimizationSettings)
Communicator = communicator_factory.CreateCommunicator(
OptimizationSettings)
DataLogger = optimization_data_logger_factory.CreateDataLogger(
OptimizationModelPart, DesignSurface, Communicator,
OptimizationSettings)
if AlgorithmName == "steepest_descent":
return AlgorithmSteepestDescent(DesignSurface, DampingRegions,
Analyzer, Mapper, Communicator,
DataLogger, OptimizationSettings)
elif AlgorithmName == "penalized_projection":
return AlgorithmPenalizedProjection(DesignSurface, DampingRegions,
Analyzer, Mapper, Communicator,
DataLogger, OptimizationSettings)
else:
raise NameError(
"The following optimization algorithm not supported by the algorithm driver (name may be misspelled): "
+ AlgorithmName)
def InitializeOptimizationLoop(self):
self.model_part_controller.Initialize()
self.analyzer.InitializeBeforeOptimizationLoop()
self.design_surface = self.model_part_controller.GetDesignSurface()
self.mapper = mapper_factory.CreateMapper(self.design_surface, self.design_surface, self.mapper_settings)
self.mapper.Initialize()
self.data_logger = data_logger_factory.CreateDataLogger(self.model_part_controller, self.communicator, self.optimization_settings)
self.data_logger.InitializeDataLogging()
self.optimization_utilities = OptimizationUtilities(self.design_surface, self.optimization_settings)
def __init__(self, optimization_settings, analyzer, communicator,
model_part_controller):
default_algorithm_settings = Parameters("""
{
"name" : "trust_region",
"max_step_length" : 1.0,
"step_length_tolerance" : 1e-3,
"step_length_reduction_factor" : 0.5,
"max_iterations" : 10,
"far_away_length" : 2.0,
"subopt_max_itr" : 50,
"subopt_tolerance" : 1e-10,
"bisectioning_max_itr" : 30,
"bisectioning_tolerance" : 1e-2,
"obj_share_during_correction" : 1
}""")
self.algorithm_settings = optimization_settings[
"optimization_algorithm"]
self.algorithm_settings.RecursivelyValidateAndAssignDefaults(
default_algorithm_settings)
self.objectives = optimization_settings["objectives"]
self.constraints = optimization_settings["constraints"]
self.analyzer = analyzer
self.communicator = communicator
self.model_part_controller = model_part_controller
self.optimization_model_part = model_part_controller.GetOptimizationModelPart(
)
self.design_surface = model_part_controller.GetDesignSurface()
self.mapper = mapper_factory.CreateMapper(
self.design_surface,
optimization_settings["design_variables"]["filter"])
self.data_logger = data_logger_factory.CreateDataLogger(
model_part_controller, communicator, optimization_settings)
self.geometry_utilities = GeometryUtilities(self.design_surface)
self.optimization_utilities = OptimizationUtilities(
self.design_surface, optimization_settings)
self.is_damping_specified = optimization_settings["design_variables"][
"damping"]["perform_damping"].GetBool()
if self.is_damping_specified:
damping_regions = self.model_part_controller.GetDampingRegions()
self.damping_utilities = DampingUtilities(self.design_surface,
damping_regions,
optimization_settings)
def __init__(self, OptimizationSettings, Analyzer, Communicator,
ModelPartController):
default_algorithm_settings = Parameters("""
{
"name" : "steepest_descent",
"max_iterations" : 100,
"relative_tolerance" : 1e-3,
"line_search" : {
"line_search_type" : "manual_stepping",
"normalize_search_direction" : true,
"step_size" : 1.0
}
}""")
self.algorithm_settings = OptimizationSettings[
"optimization_algorithm"]
self.algorithm_settings.RecursivelyValidateAndAssignDefaults(
default_algorithm_settings)
self.Analyzer = Analyzer
self.Communicator = Communicator
self.ModelPartController = ModelPartController
self.objectives = OptimizationSettings["objectives"]
self.constraints = OptimizationSettings["constraints"]
self.OptimizationModelPart = ModelPartController.GetOptimizationModelPart(
)
self.DesignSurface = ModelPartController.GetDesignSurface()
self.Mapper = mapper_factory.CreateMapper(
self.DesignSurface,
OptimizationSettings["design_variables"]["filter"])
self.DataLogger = data_logger_factory.CreateDataLogger(
ModelPartController, Communicator, OptimizationSettings)
self.GeometryUtilities = GeometryUtilities(self.DesignSurface)
self.OptimizationUtilities = OptimizationUtilities(
self.DesignSurface, OptimizationSettings)
self.isDampingSpecified = OptimizationSettings["design_variables"][
"damping"]["perform_damping"].GetBool()
if self.isDampingSpecified:
damping_regions = self.ModelPartController.GetDampingRegions()
self.DampingUtilities = DampingUtilities(self.DesignSurface,
damping_regions,
OptimizationSettings)
def optimize( self ):
timer = timer_factory.CreateTimer()
algorithmName = self.optimizationSettings["optimization_algorithm"]["name"].GetString()
print("\n> ==============================================================================================================")
print("> ",timer.getTimeStamp(),": Starting optimization using the following algorithm: ", algorithmName)
print("> ==============================================================================================================\n")
designSurface = self.__getDesignSurfaceFromInputModelPart()
dampingRegions = self.__getdampingRegionsFromInputModelPart()
mapper = mapper_factory.CreateMapper( designSurface, self.optimizationSettings )
communicator = communicator_factory.CreateCommunicator( self.optimizationSettings )
algorithm = algorithm_factory.CreateAlgorithm( designSurface, dampingRegions, self.analyzer, mapper, communicator, self.optimizationSettings )
algorithm.execute()
print("\n> ==============================================================================================================")
print("> Finished optimization ")
print("> ==============================================================================================================\n")
for node in plate_with_trias.Nodes:
node.SetSolutionStepValue(PRESSURE, (0.5 - node.X) * (0.5 - node.Y))
# =======================================================================================================
# Perform tests
# =======================================================================================================
# Test matrix-free mapper
mapper_settings = Parameters("""
{
"filter_function_type" : "linear",
"filter_radius" : 0.4,
"max_nodes_in_filter_radius" : 10000,
"matrix_free_filtering" : true
}""")
matrix_mapper = mapper_factory.CreateMapper(plate_with_trias, plate_with_trias,
mapper_settings)
matrix_mapper.Map(CONTROL_POINT_UPDATE, CONTROL_POINT_CHANGE)
matrix_mapper.InverseMap(CONTROL_POINT_CHANGE, SHAPE_UPDATE)
norm_2_result = Norm2OfVectorVariable(plate_with_trias, SHAPE_UPDATE)
TestCase().assertAlmostEqual(norm_2_result, 1.283132791556226, 12)
# Test matrix mapper
mapper_settings = Parameters("""
{
"filter_function_type" : "linear",
"filter_radius" : 0.4,
"max_nodes_in_filter_radius" : 1000
}""")
matrix_mapper = mapper_factory.CreateMapper(plate_with_trias, plate_with_trias,
mapper_settings)
def InitializeOptimizationLoop(self):
self.model_part_controller.ImportOptimizationModelPart()
self.model_part_controller.SetMinimalBufferSize(2)
self.model_part_controller.InitializeMeshController()
self.model_part_controller.ComputeUnitSurfaceNormals()
self.analyzer.InitializeBeforeOptimizationLoop()
self.design_surface = self.model_part_controller.GetDesignSurface()
self.mapper = mapper_factory.CreateMapper(self.design_surface,
self.design_surface,
self.mapper_settings)
self.mapper.Initialize()
self.data_logger = data_logger_factory.CreateDataLogger(
self.model_part_controller, self.communicator,
self.optimization_settings)
self.data_logger.InitializeDataLogging()
self.optimization_utilities = OptimizationUtilities(
self.design_surface, self.optimization_settings)
# Specify bounds
if self.bead_side == "positive":
VariableUtils().SetScalarVar(ALPHA, 0.5, self.design_surface.Nodes)
VariableUtils().SetScalarVar(ALPHA_MAPPED, 0.5,
self.design_surface.Nodes)
self.lower_bound = 0.0
self.upper_bound = 1.0
elif self.bead_side == "negative":
VariableUtils().SetScalarVar(ALPHA, -0.5,
self.design_surface.Nodes)
VariableUtils().SetScalarVar(ALPHA_MAPPED, -0.5,
self.design_surface.Nodes)
self.lower_bound = -1.0
self.upper_bound = 0.0
elif self.bead_side == "both":
VariableUtils().SetScalarVar(ALPHA, 0.0, self.design_surface.Nodes)
VariableUtils().SetScalarVar(ALPHA_MAPPED, 0.0,
self.design_surface.Nodes)
self.lower_bound = -1.0
self.upper_bound = 1.0
else:
raise RuntimeError("Specified bead direction mode not supported!")
# Identify fixed design areas
VariableUtils().SetFlag(BOUNDARY, False,
self.optimization_model_part.Nodes)
radius = self.mapper_settings["filter_radius"].GetDouble()
search_based_functions = SearchBasedFunctions(
self.optimization_model_part)
for itr in range(self.algorithm_settings["fix_boundaries"].size()):
sub_model_part_name = self.algorithm_settings["fix_boundaries"][
itr].GetString()
node_set = self.optimization_model_part.GetSubModelPart(
sub_model_part_name).Nodes
search_based_functions.FlagNodesInRadius(node_set, BOUNDARY,
radius)
# Specify bead direction
bead_direction = self.algorithm_settings["bead_direction"].GetVector()
if len(bead_direction) == 0:
for node in self.design_surface.Nodes:
normalized_normal = node.GetSolutionStepValue(
NORMALIZED_SURFACE_NORMAL)
node.SetValue(BEAD_DIRECTION, normalized_normal)
elif len(bead_direction) == 3:
norm = math.sqrt(bead_direction[0]**2 + bead_direction[1]**2 +
bead_direction[2]**2)
normalized_bead_direction = [
value / norm for value in bead_direction
]
VariableUtils().SetNonHistoricalVectorVar(
BEAD_DIRECTION, normalized_bead_direction,
self.design_surface.Nodes)
else:
raise RuntimeError(
"Wrong definition of bead direction. Options are: 1) [] -> takes surface normal, 2) [x.x,x.x,x.x] -> takes specified vector."
)
