KratosShapeOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_base.py

@@ -0,0 +1,30 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# ==============================================================================
+class AnalyzerBaseClass:
+    # --------------------------------------------------------------------------
+    def __init__(self):
+        pass
+
+    # --------------------------------------------------------------------------
+    def InitializeBeforeOptimizationLoop(self):
+        pass
+
+    # --------------------------------------------------------------------------
+    def AnalyzeDesignAndReportToCommunicator(self, current_design, optimization_iteration, communicator):
+        raise RuntimeError("Analyzer base class is called. Please check your implementation of the function >> AnalyzeDesignAndReportToCommunicator << .")
+
+    # --------------------------------------------------------------------------
+    def FinalizeAfterOptimizationLoop(self):
+        pass
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_empty.py

@@ -0,0 +1,21 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# Additional imports
+from .analyzer_base import AnalyzerBaseClass
+
+# ==============================================================================
+class EmptyAnalyzer( AnalyzerBaseClass ):
+    # --------------------------------------------------------------------------
+    def AnalyzeDesignAndReportToCommunicator( self, currentDesign, optimizationIteration, communicator ):
+        pass
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_factory.py

@@ -0,0 +1,310 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# additional imports
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers.analyzer_internal import KratosInternalAnalyzer
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers.analyzer_empty import EmptyAnalyzer
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers.analyzer_base import AnalyzerBaseClass
+import KratosMultiphysics.kratos_utilities as kratos_utilities
+import csv, math
+import copy
+
+# ==============================================================================
+def CreateAnalyzer(optimization_settings, model_part_controller, external_analyzer):
+    objectives = optimization_settings["objectives"]
+    constraints = optimization_settings["constraints"]
+
+    internal_objectives = _IdentifyInternalResponsesRecursively(objectives)
+    internal_constraints = _IdentifyInternalResponsesRecursively(constraints)
+    internal_responses = internal_objectives + internal_constraints
+    # internal_responses = [ (response_id_1, kratos_settings_1),
+    #                        (response_id_2, kratos_settings_2),
+    #                        ... ]
+
+    if len(internal_responses) > 0:
+        internal_analyzer = KratosInternalAnalyzer(internal_responses, model_part_controller)
+    else:
+        internal_analyzer = EmptyAnalyzer()
+
+    dependency_graph, exist_dependencies = _CreateDependencyGraphRecursively(objectives)
+    # dependency_graph = [ (response_id_1, weight_1, [], combination_type),
+    #                      (response_id_2, weight_2, [], combination_type),
+    #                      (response_id_3, [ (response_id_3a, weight_3a, [], combination_type),
+    #                                        (response_id_3b, weight_3b, [], combination_type),
+    #                                        (response_id_3c, weight_3c, [...]) ], weight_3, combination_type),
+    #                      ... ]
+
+    if exist_dependencies:
+        return AnalyzerWithDependencies(internal_analyzer, model_part_controller, external_analyzer, dependency_graph)
+    else:
+        return Analyzer(internal_analyzer, model_part_controller, external_analyzer)
+
+# ------------------------------------------------------------------------------
+def _IdentifyInternalResponsesRecursively(responses):
+    internal_responses = []
+
+    for itr in range(responses.size()):
+        response_i = responses[itr]
+
+        if response_i.Has("is_combined"):
+            if response_i["is_combined"].GetBool():
+                internal_responses += _IdentifyInternalResponsesRecursively(response_i["combined_responses"])
+
+        if response_i["analyzer"].GetString() == "kratos":
+            identifier = response_i["identifier"].GetString()
+            kratos_settings = response_i["response_settings"]
+            internal_responses.append([identifier, kratos_settings])
+
+    return internal_responses
+
+# ------------------------------------------------------------------------------
+def _CreateDependencyGraphRecursively(responses):
+    dependency_graph = []
+    exist_dependencies = False
+
+    for itr in range(responses.size()):
+        response_i = responses[itr]
+        identifier = response_i["identifier"].GetString()
+        weight = response_i["weight"].GetDouble()
+        combination_type = response_i["combination_type"].GetString()
+
+        if response_i.Has("is_combined"):
+            if response_i["is_combined"].GetBool():
+                exist_dependencies = True
+                sub_dependency_graph, _ = _CreateDependencyGraphRecursively(response_i["combined_responses"])
+                dependency_graph.append((identifier, weight, sub_dependency_graph, combination_type))
+            else:
+                dependency_graph.append((identifier, weight, [], None))
+
+    return dependency_graph, exist_dependencies
+
+# ==============================================================================
+class Analyzer(AnalyzerBaseClass):
+    # --------------------------------------------------------------------------
+    def __init__(self, internal_analyzer, model_part_controller, external_analyzer):
+        self.model_part_controller = model_part_controller
+        self.internal_analyzer = internal_analyzer
+        self.external_analyzer = external_analyzer
+
+        if isinstance(internal_analyzer, EmptyAnalyzer) and  isinstance(external_analyzer, EmptyAnalyzer):
+            raise RuntimeError("Neither an internal nor an external analyzer is defined!")
+
+    # --------------------------------------------------------------------------
+    def InitializeBeforeOptimizationLoop(self):
+        self.internal_analyzer.InitializeBeforeOptimizationLoop()
+        self.external_analyzer.InitializeBeforeOptimizationLoop()
+
+    # --------------------------------------------------------------------------
+    def AnalyzeDesignAndReportToCommunicator(self, current_design, unique_iterator, communicator):
+        self.internal_analyzer.AnalyzeDesignAndReportToCommunicator(current_design, unique_iterator, communicator)
+        self.external_analyzer.AnalyzeDesignAndReportToCommunicator(current_design, unique_iterator, communicator)
+
+        self.__ResetPossibleShapeModificationsFromAnalysis()
+
+    # --------------------------------------------------------------------------
+    def FinalizeAfterOptimizationLoop(self):
+        self.internal_analyzer.FinalizeAfterOptimizationLoop()
+        self.external_analyzer.FinalizeAfterOptimizationLoop()
+
+    # --------------------------------------------------------------------------
+    def __ResetPossibleShapeModificationsFromAnalysis( self ):
+        self.model_part_controller.SetMeshToReferenceMesh()
+        self.model_part_controller.SetDeformationVariablesToZero()
+
+# ==============================================================================
+class AnalyzerWithDependencies(Analyzer):
+    # --------------------------------------------------------------------------
+    def __init__(self, internal_analyzer, model_part_controller, external_analyzer, dependency_graph):
+        super().__init__(internal_analyzer, model_part_controller, external_analyzer)
+
+        self.dependency_graph = dependency_graph
+        self.response_combination_filename = "response_combination.csv"
+        self.gradient_max_norms = {}
+
+    # --------------------------------------------------------------------------
+    def InitializeBeforeOptimizationLoop(self):
+        super().InitializeBeforeOptimizationLoop()
+
+        self.__InitializeOutputOfResponses()
+
+    # --------------------------------------------------------------------------
+    def AnalyzeDesignAndReportToCommunicator(self, current_design, unique_iterator, communicator):
+        self.__RequestResponsesAccordingDependencies(communicator)
+
+        super().AnalyzeDesignAndReportToCommunicator(current_design, unique_iterator, communicator)
+
+        self.__CombineResponsesAccordingDependencies(communicator)
+        self.__ComputeGradientNorms(communicator)
+        self.__WriteResultsOfCombinedResponses(unique_iterator,communicator)
+
+    # --------------------------------------------------------------------------
+    def __InitializeOutputOfResponses(self):
+        kratos_utilities.DeleteFileIfExisting(self.response_combination_filename)
+
+        with open(self.response_combination_filename, 'w') as csvfile:
+            writer = csv.writer(csvfile, delimiter=',')
+            response_ids = self.__GetIdentifiersRecursively(self.dependency_graph)
+
+            writer.writerow(["---------------------------------"])
+            for itr, identifier in enumerate(response_ids):
+                writer.writerow(["f"+str(itr)+": "+identifier])
+            writer.writerow(["---------------------------------"])
+
+            row = []
+            row.append("{:>4s}".format("itr"))
+            for itr, identifier in enumerate(response_ids):
+                row.append("{:>13s}".format("f"+str(itr)+"_value"))
+            for itr, identifier in enumerate(response_ids):
+                row.append("{:>13s}".format("||df"+str(itr)+"dx_st||"))
+            writer.writerow(row)
+
+    # --------------------------------------------------------------------------
+    def __GetIdentifiersRecursively(self, dependencies):
+        response_ids = []
+
+        for response_id, _, dependencies, _ in dependencies:
+            response_ids += [response_id]
+            if len(dependencies) > 0:
+                sub_identifiers = self.__GetIdentifiersRecursively(dependencies)
+                response_ids += sub_identifiers
+
+        return response_ids
+
+    # --------------------------------------------------------------------------
+    def __RequestResponsesAccordingDependencies(self, communicator):
+        for response_id, _, dependencies, _ in self.dependency_graph:
+            sub_response_ids = self.__GetIdentifiersRecursively(dependencies)
+
+            if communicator.isRequestingValueOf(response_id):
+                for sub_response_id in sub_response_ids:
+                    communicator.requestValueOf(sub_response_id)
+
+            if communicator.isRequestingGradientOf(response_id):
+                for sub_response_id in sub_response_ids:
+                    communicator.requestGradientOf(sub_response_id)
+
+    # --------------------------------------------------------------------------
+    def __CombineResponsesAccordingDependencies(self, communicator):
+        for response_id, _, dependencies, combination_type in self.dependency_graph:
+            if len(dependencies) > 0:
+                if communicator.isRequestingValueOf(response_id):
+                    combined_value = self.__ComputeCombinedValuesRecursively(dependencies, combination_type, communicator)
+                    communicator.reportValue(response_id, combined_value)
+
+        for response_id, _, dependencies, _ in self.dependency_graph:
+            if len(dependencies) > 0:
+                if communicator.isRequestingGradientOf(response_id):
+                    combined_gradient = self.__ComputeCombinedGradientsRecursively(dependencies, communicator)
+                    communicator.reportGradient(response_id, combined_gradient)
+
+    # --------------------------------------------------------------------------
+    def __ComputeCombinedValuesRecursively(self, dependencies, combination_type, communicator):
+        combined_value = None
+        relevant_responses = []
+
+        for response_id, weight, sub_dependencies, sub_combination_type in dependencies:
+            if len(sub_dependencies) > 0:
+                value = self.__ComputeCombinedValuesRecursively(sub_dependencies, sub_combination_type, communicator)
+                communicator.reportValue(response_id, value)
+            else:
+                value = communicator.getStandardizedValue(response_id)
+
+            value = weight*value
+
+            if combined_value is None:
+                combined_value = value
+                relevant_responses.append(response_id)
+            else:
+                if combination_type == "sum":
+                    combined_value += value
+                    relevant_responses.append(response_id)
+                elif combination_type == "max":
+                    if value > combined_value:
+                        relevant_responses = [response_id]
+                        combined_value = value
+                elif combination_type == "min":
+                    if value < combined_value:
+                        relevant_responses = [response_id]
+                        combined_value = value
+                else:
+                    raise NameError("The following combination_type is not supported:" + combination_type)
+
+        for response_id, _, _, _ in dependencies:
+            if response_id not in relevant_responses:
+                communicator.updateRequest(response_id, request_value=True, request_gradient=False)
+
+        return combined_value
+
+    # --------------------------------------------------------------------------
+    def __ComputeCombinedGradientsRecursively(self, dependencies, communicator):
+        combined_gradient = {}
+
+        for response_id, weight, sub_dependencies, _ in dependencies:
+            if communicator.isRequestingGradientOf(response_id):
+                if len(sub_dependencies) > 0:
+                    gradient = self.__ComputeCombinedGradientsRecursively(sub_dependencies, communicator)
+                    communicator.reportGradient(response_id, gradient)
+                else:
+                    gradient = communicator.getStandardizedGradient(response_id)
+
+                for vector in gradient.values():
+                    vector[0] *= weight
+                    vector[1] *= weight
+                    vector[2] *= weight
+
+                if not combined_gradient:
+                    # initialize combined gradient with zeros
+                    combined_gradient = {key: [0.0, 0.0, 0.0] for key in gradient.keys()}
+
+                # Perform nodal sum
+                for key_a, vector_a in combined_gradient.items():
+                    vector_b = gradient[key_a]
+                    vector_a[0] += vector_b[0]
+                    vector_a[1] += vector_b[1]
+                    vector_a[2] += vector_b[2]
+
+        return combined_gradient
+
+    # --------------------------------------------------------------------------
+    def __ComputeGradientNorms(self, communicator):
+        response_ids = self.__GetIdentifiersRecursively(self.dependency_graph)
+
+        for response_id in response_ids:
+            if communicator.isRequestingGradientOf(response_id):
+                gradient = communicator.getStandardizedGradient(response_id)
+
+                nodal_norms = [ entry[0]**2 + entry[1]**2 + entry[2]**2 for entry in gradient.values() ]
+                max_norm = math.sqrt(max(nodal_norms))
+                self.gradient_max_norms[response_id] = max_norm
+
+    # --------------------------------------------------------------------------
+    def __WriteResultsOfCombinedResponses(self, iteration, communicator):
+        with open(self.response_combination_filename, 'a') as csvfile:
+            writer = csv.writer(csvfile, delimiter=',')
+
+            identifiers = self.__GetIdentifiersRecursively(self.dependency_graph)
+            values = []
+            for response_id in identifiers:
+                values.append(communicator.getValue(response_id))
+
+            row = []
+            row.append("{:>4d}".format(iteration))
+            for identifier, value in zip(identifiers, values):
+                row.append(" {:> .5E}".format(value))
+            for identifier, value in zip(identifiers, values):
+                if communicator.isRequestingGradientOf(identifier):
+                    row.append(" {:> .5E}".format(self.gradient_max_norms[identifier]))
+                else:
+                    row.append("            -")
+
+            writer.writerow(row)
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_internal.py

@@ -0,0 +1,155 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#                   Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import os, pathlib, sys
+
+# Kratos Core and Apps
+import KratosMultiphysics as KM
+
+# Additional imports
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers.analyzer_base import AnalyzerBaseClass
+from KratosMultiphysics.ShapeOptimizationApplication.response_functions import response_function_factory as sho_response_factory
+try:
+    from KratosMultiphysics.StructuralMechanicsApplication import structural_response_function_factory as csm_response_factory
+except ImportError:
+    csm_response_factory = None
+try:
+    from KratosMultiphysics.ConvectionDiffusionApplication.response_functions import convection_diffusion_response_function_factory as convdiff_response_factory
+except ImportError:
+    convdiff_response_factory = None
+try:
+    from KratosMultiphysics.CompressiblePotentialFlowApplication import potential_flow_response_function_factory as potential_flow_response_factory
+except ImportError:
+    potential_flow_response_factory = None
+
+import time as timer
+
+class IterationScope:
+    def __init__(self, response_id, iteration_number, is_evaluated_in_folder):
+        self.is_evaluated_in_folder = is_evaluated_in_folder
+        if (self.is_evaluated_in_folder):
+            self.currentPath = pathlib.Path.cwd()
+            output_path = pathlib.Path("Design_Iterations")
+            response_text = "{:}/{:d}".format(response_id, iteration_number)
+            self.scope = output_path / response_text
+
+    def __enter__(self):
+        if (self.is_evaluated_in_folder):
+            self.scope.mkdir(parents=True, exist_ok=True)
+            sys.path.insert(0, str(self.scope.absolute()))
+            os.chdir(str(self.scope))
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if (self.is_evaluated_in_folder):
+            os.chdir(self.currentPath)
+            sys.path.remove(str(self.scope.absolute()))
+
+
+# ==============================================================================
+class KratosInternalAnalyzer( AnalyzerBaseClass ):
+    # --------------------------------------------------------------------------
+    def __init__( self, specified_responses, model_part_controller ):
+        self.model_part_controller = model_part_controller
+        self.response_functions = self.__CreateResponseFunctions(specified_responses, model_part_controller.GetModel())
+
+    # --------------------------------------------------------------------------
+    def InitializeBeforeOptimizationLoop( self ):
+        for response in self.response_functions.values():
+            response.Initialize()
+
+    # --------------------------------------------------------------------------
+    def AnalyzeDesignAndReportToCommunicator( self, currentDesign, optimizationIteration, communicator ):
+        optimization_model_part = self.model_part_controller.GetOptimizationModelPart()
+
+        time_before_analysis = optimization_model_part.ProcessInfo.GetValue(KM.TIME)
+        step_before_analysis = optimization_model_part.ProcessInfo.GetValue(KM.STEP)
+        delta_time_before_analysis = optimization_model_part.ProcessInfo.GetValue(KM.DELTA_TIME)
+
+        for identifier, response in self.response_functions.items():
+
+            # Reset step/time iterators such that they match the optimization iteration after calling CalculateValue (which internally calls CloneTimeStep)
+            optimization_model_part.ProcessInfo.SetValue(KM.STEP, step_before_analysis-1)
+            optimization_model_part.ProcessInfo.SetValue(KM.TIME, time_before_analysis-1)
+            optimization_model_part.ProcessInfo.SetValue(KM.DELTA_TIME, 0)
+
+            # now we scope in to the directory where response operations are done
+            with IterationScope(identifier, optimizationIteration, response.IsEvaluatedInFolder()):
+                response.UpdateDesign(optimization_model_part, KM.SHAPE_SENSITIVITY)
+
+                response.InitializeSolutionStep()
+
+                # response values
+                if communicator.isRequestingValueOf(identifier):
+                    response.CalculateValue()
+                    communicator.reportValue(identifier, response.GetValue())
+
+                # response gradients
+                if communicator.isRequestingGradientOf(identifier):
+                    response.CalculateGradient()
+                    communicator.reportGradient(identifier, response.GetNodalGradient(KM.SHAPE_SENSITIVITY))
+
+                response.FinalizeSolutionStep()
+
+            # Clear results or modifications on model part
+            optimization_model_part.ProcessInfo.SetValue(KM.STEP, step_before_analysis)
+            optimization_model_part.ProcessInfo.SetValue(KM.TIME, time_before_analysis)
+            optimization_model_part.ProcessInfo.SetValue(KM.DELTA_TIME, delta_time_before_analysis)
+
+            self.model_part_controller.SetMeshToReferenceMesh()
+            self.model_part_controller.SetDeformationVariablesToZero()
+
+    # --------------------------------------------------------------------------
+    def FinalizeAfterOptimizationLoop( self ):
+        for response in self.response_functions.values():
+            response.Finalize()
+
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def __CreateResponseFunctions( specified_responses, model ):
+        response_functions = {}
+
+        sho_response_functions = [
+            "plane_based_packaging",
+            "mesh_based_packaging",
+            "surface_normal_shape_change",
+            "face_angle",
+            "airfoil_angle_of_attack",
+            "airfoil_chord_length",
+            "airfoil_perimeter"
+        ]
+        csm_response_functions = ["strain_energy", "mass", "eigenfrequency", "adjoint_local_stress", "adjoint_max_stress", "adjoint_nodal_displacement", "adjoint_linear_strain_energy", "adjoint_nodal_reaction"]
+        cps_response_functions = ["adjoint_lift_potential_jump", "stochastic_adjoint_lift_potential_jump"]
+        convdiff_response_functions = ["point_temperature"]
+
+        for (response_id, response_settings) in specified_responses:
+            if response_id in response_functions.keys():
+                raise NameError("There are multiple response functions with the following identifier: " + response_id)
+
+            response_type = response_settings["response_type"].GetString()
+
+            if response_type in csm_response_functions:
+                if csm_response_factory is None:
+                    raise RuntimeError("ShapeOpt: {} response function requires StructuralMechanicsApplication.".format(response_type))
+                response_functions[response_id] = csm_response_factory.CreateResponseFunction(response_id, response_settings, model)
+            elif response_type in convdiff_response_functions:
+                if convdiff_response_factory is None:
+                    raise RuntimeError("ShapeOpt: {} response function requires ConvectionDiffusionApplication.".format(response_type))
+                response_functions[response_id] = convdiff_response_factory.CreateResponseFunction(response_id, response_settings, model)
+            elif response_type in cps_response_functions:
+                if potential_flow_response_factory is None:
+                    raise RuntimeError("ShapeOpt: {} response function requires CompressiblePotentialFlowApplication.".format(response_type))
+                response_functions[response_id] = potential_flow_response_factory.CreateResponseFunction(response_id, response_settings, model)
+            elif response_type in sho_response_functions:
+                response_functions[response_id] = sho_response_factory.CreateResponseFunction(response_id, response_settings, model)
+            else:
+                raise NameError("The response function '{}' of type '{}' is not available.".format(response_id, response_type))
+
+        return response_functions