KratosShapeOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShapeOptimizationApplication/response_functions/airfoil_2d_responses.py

@@ -0,0 +1,189 @@
+import KratosMultiphysics
+from KratosMultiphysics import Parameters, Logger
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+from KratosMultiphysics.response_functions.response_function_interface import ResponseFunctionInterface
+import math
+
+def DotProduct(A,B):
+    result = 0
+    for i,j in zip(A,B):
+        result += i*j
+    return result
+
+class AngleOfAttackResponseFunction(ResponseFunctionInterface):
+    def __init__(self, response_id, response_settings, model):
+        self.model = model
+        if not response_settings.Has("trailing_edge_model_part")  or not response_settings.Has("leading_edge_model_part"):
+            raise(Exception("Please define a model part with the trailing edge node and a model part with the leading edge node"))
+
+        self.trailing_edge_model_part_name = response_settings["trailing_edge_model_part"].GetString()
+        self.leading_edge_sub_model_part_name = response_settings["leading_edge_model_part"].GetString()
+        self.reference_direction= response_settings["reference_direction"].GetVector() if response_settings.Has("reference_direction") else [1.0,0.0,0.0]
+
+    def Initialize(self):
+        self.te_model_part = self.model[self.trailing_edge_model_part_name]
+        self.le_model_part = self.model[self.leading_edge_sub_model_part_name]
+        self.main_model_part = self.te_model_part.GetRootModelPart()
+
+        for node in self.te_model_part.Nodes:
+            self.te_node = node
+            break
+        for node in self.le_model_part.Nodes:
+            self.le_node = node
+            break
+
+    def CalculateValue(self):
+        self.aoa = self._CalculateAOA(self.te_node.X,self.te_node.Y, self.le_node.X, self.le_node.Y)
+
+    def CalculateGradient(self):
+        x_diff = self.le_node.X - self.te_node.X
+        y_diff = self.le_node.Y - self.te_node.Y
+
+        cshape_sensitivity_0 = x_diff
+        cshape_sensitivity_1 = y_diff
+        cshape_sensitivity_2 = cshape_sensitivity_0**2 + cshape_sensitivity_1**2
+        cshape_sensitivity_3 = 1/cshape_sensitivity_2
+        cshape_sensitivity_4 = cshape_sensitivity_0*self.reference_direction[0] + cshape_sensitivity_1*self.reference_direction[1]
+        cshape_sensitivity_5 = cshape_sensitivity_3*cshape_sensitivity_4
+        cshape_sensitivity_6 = self.reference_direction[0]**2 + self.reference_direction[1]**2
+        cshape_sensitivity_7 = 1/(math.sqrt(cshape_sensitivity_2)*math.sqrt(cshape_sensitivity_6)*math.sqrt(-cshape_sensitivity_3*cshape_sensitivity_4**2/cshape_sensitivity_6 + 1))
+
+        self.te_x_gradient = -cshape_sensitivity_7*(-cshape_sensitivity_0*cshape_sensitivity_5 + self.reference_direction[0])
+        self.te_y_gradient = -cshape_sensitivity_7*(-cshape_sensitivity_1*cshape_sensitivity_5 + self.reference_direction[1])
+        self.le_x_gradient = cshape_sensitivity_7*(-cshape_sensitivity_0*cshape_sensitivity_5 + self.reference_direction[0])
+        self.le_y_gradient = cshape_sensitivity_7*(-cshape_sensitivity_1*cshape_sensitivity_5 + self.reference_direction[1])
+
+    def GetValue(self):
+        return self.aoa
+
+    def GetNodalGradient(self, variable):
+        zero_vector = KratosMultiphysics.Vector(3, 0.0)
+        gradient ={node.Id : zero_vector for node in self.main_model_part.Nodes}
+
+        shape_gradient = KratosMultiphysics.Vector(3, 0.0)
+        shape_gradient[0] = self.te_x_gradient
+        shape_gradient[1] = self.te_y_gradient
+        gradient[self.te_node.Id] = shape_gradient
+
+        shape_gradient = KratosMultiphysics.Vector(3, 0.0)
+        shape_gradient[0] = self.le_x_gradient
+        shape_gradient[1] = self.le_y_gradient
+        gradient[self.le_node.Id] = shape_gradient
+
+        return gradient
+
+    def _CalculateAOA(self, te_x, te_y, le_x, le_y):
+        ref_dir_norm = KratosMultiphysics.Vector(self.reference_direction).norm_2()
+        chord_vector = KratosMultiphysics.Vector(3, 0.0)
+        chord_vector[0] = te_x-le_x
+        chord_vector[1] = te_y-le_y
+        chord_norm = chord_vector.norm_2()
+        aoa = math.acos(DotProduct(self.reference_direction, chord_vector)/(ref_dir_norm*chord_norm))
+
+        return aoa
+
+class ChordLengthResponseFunction(ResponseFunctionInterface):
+
+
+    def __init__(self, response_id, response_settings, model):
+        self.model = model
+
+        if not response_settings.Has("trailing_edge_model_part")  or not response_settings.Has("leading_edge_model_part"):
+            raise(Exception("Please define a model part with the trailing edge node and a model part with the leading edge node"))
+
+        self.trailing_edge_model_part_name = response_settings["trailing_edge_model_part"].GetString()
+        self.leading_edge_sub_model_part_name = response_settings["leading_edge_model_part"].GetString()
+
+    def Initialize(self):
+        self.te_model_part = self.model[self.trailing_edge_model_part_name]
+        self.le_model_part = self.model[self.leading_edge_sub_model_part_name]
+        self.main_model_part = self.te_model_part.GetRootModelPart()
+
+        for node in self.te_model_part.Nodes:
+            self.te_node = node
+            break
+        for node in self.le_model_part.Nodes:
+            self.le_node = node
+            break
+
+    def _ComputeChord(self, te_x, te_y, le_x, le_y):
+        chord = math.sqrt((te_x-le_x)**2+(te_y-le_y)**2)
+
+        return chord
+
+    def CalculateValue(self):
+        self.chord = self._ComputeChord(self.te_node.X,self.te_node.Y, self.le_node.X,self.le_node.Y)
+
+    def CalculateGradient(self):
+        x_diff = self.le_node.X - self.te_node.X
+        y_diff = self.le_node.Y - self.te_node.Y
+
+        self.te_x_gradient = -x_diff/math.sqrt(x_diff**2 + y_diff**2)
+        self.te_y_gradient = -y_diff/math.sqrt(x_diff**2 + y_diff**2)
+        self.le_x_gradient = x_diff/math.sqrt(x_diff**2 + y_diff**2)
+        self.le_y_gradient = y_diff/math.sqrt(x_diff**2 + y_diff**2)
+
+    def GetValue(self):
+        return self.chord
+
+    def GetNodalGradient(self, variable):
+        zero_vector = KratosMultiphysics.Vector(3, 0.0)
+        gradient ={node.Id : zero_vector for node in self.main_model_part.Nodes}
+
+        shape_gradient = KratosMultiphysics.Vector(3, 0.0)
+        shape_gradient[0] = self.te_x_gradient
+        shape_gradient[1] = self.te_y_gradient
+        gradient[self.te_node.Id] = shape_gradient
+
+        shape_gradient = KratosMultiphysics.Vector(3, 0.0)
+        shape_gradient[0] = self.le_x_gradient
+        shape_gradient[1] = self.le_y_gradient
+        gradient[self.le_node.Id] = shape_gradient
+
+        return gradient
+
+
+
+class PerimeterResponseFunction(ResponseFunctionInterface):
+
+    def __init__(self, response_id, response_settings, model):
+        self.model = model
+        self.model_part_name = response_settings["model_part_name"].GetString()
+        self.step_size = response_settings["step_size"].GetDouble() if response_settings.Has("step_size") else 1e-6
+
+    def Initialize(self):
+        self.main_model_part = self.model[self.model_part_name]
+
+    def _ComputePerimeter(self,  model_part):
+        return KSO.GeometryUtilities(model_part).CalculateLength(model_part.Conditions)
+
+    def CalculateValue(self):
+        pass
+
+    def CalculateGradient(self):
+        pass
+
+    def GetValue(self):
+
+        return self._ComputePerimeter(self.main_model_part)
+
+    def GetNodalGradient(self, variable):
+        gradient = {}
+        initial_perimeter =  self._ComputePerimeter(self.main_model_part)
+
+        for node in self.main_model_part.Nodes:
+            shape_gradient = KratosMultiphysics.Vector(3, 0.0)
+
+            node.X += self.step_size
+            current_perimeter =  self._ComputePerimeter(self.main_model_part)
+            shape_gradient[0] = (current_perimeter-initial_perimeter)/self.step_size
+            node.X -= self.step_size
+
+            node.Y += self.step_size
+            current_perimeter =  self._ComputePerimeter(self.main_model_part)
+            shape_gradient[1] = (current_perimeter-initial_perimeter)/self.step_size
+            node.Y -= self.step_size
+
+            gradient[node.Id] = shape_gradient
+
+        return gradient

KratosMultiphysics/ShapeOptimizationApplication/response_functions/face_angle.py

@@ -0,0 +1,140 @@
+# importing the Kratos Library
+import KratosMultiphysics as KM
+from KratosMultiphysics import Parameters, Logger
+from KratosMultiphysics.response_functions.response_function_interface import ResponseFunctionInterface
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+
+import time as timer
+
+
+def _AddConditionsFromParent(parent, child):
+    node_ids = set([node.Id for node in child.Nodes])
+    conditions = []
+    for condition in parent.Conditions:
+        all_nodes_found = True
+        for node in condition.GetNodes():
+            if node.Id not in node_ids:
+                all_nodes_found = False
+                break
+        if all_nodes_found:
+            conditions.append(condition.Id)
+    child.AddConditions(conditions)
+
+# ==============================================================================
+class FaceAngleResponseFunction(ResponseFunctionInterface):
+    """
+    Face angle response function.
+    It aggregates the deviation of the face angles of all surface conditions using sqrt(sum(g_i)),
+    where g_i are the condition wise violations - feasible conditions do not contribute
+
+    It requires surface conditions in the modelpart, since they are used to compute the face orientation.
+    Ideally the design surface model part is used.
+
+    Attributes
+    ----------
+    model_part : Model part object of the response function
+    response_function_utility: Cpp utilities object doing the actual computation of response value and gradient.
+    """
+
+    def __init__(self, identifier, response_settings, model):
+        self.identifier = identifier
+
+        response_settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.response_settings = response_settings
+        self.model = model
+        self.model_part_needs_to_be_imported = False
+
+        self.value = None
+
+        self._model_part_name = response_settings["model_part_name"].GetString()
+        input_type = response_settings["model_import_settings"]["input_type"].GetString()
+        if input_type == "mdpa":
+            self.model_part = self.model.CreateModelPart(self._model_part_name, 2)
+            domain_size = response_settings["domain_size"].GetInt()
+            if domain_size not in [3]:
+                raise Exception("FaceAngleResponseFunction: Invalid 'domain_size': {}".format(domain_size))
+            self.model_part.ProcessInfo.SetValue(KM.DOMAIN_SIZE, domain_size)
+            self.model_part_needs_to_be_imported = True
+        elif input_type == "use_input_model_part":
+            self.model_part = None  # will be retrieved in Initialize()
+        else:
+            raise Exception("Other model part input options are not yet implemented.")
+
+        self.response_function_utility = None  # will be created in Initialize()
+
+        self.model.GetModelPart(self._model_part_name.split(".")[0]).AddNodalSolutionStepVariable(KM.SHAPE_SENSITIVITY)
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = KM.Parameters("""{
+            "response_type"         : "UNKNOWN_TYPE",
+            "model_part_name"       : "UNKNOWN_NAME",
+            "only"                  : "",
+            "domain_size"           : 3,
+            "model_import_settings" : {
+                "input_type"        : "use_input_model_part",
+                "input_filename"    : "UNKNOWN_NAME"
+            },
+            "main_direction": [0.0, 0.0, 1.0],
+            "min_angle": 0.0,
+            "gradient_mode": "finite_differencing",
+            "step_size": 1e-6,
+            "consider_only_initially_feasible": false
+        }""")
+        return this_defaults
+
+    def Initialize(self):
+        if self.response_settings["model_import_settings"]["input_type"].GetString() == "mdpa":
+            file_name = self.response_settings["model_import_settings"]["input_filename"].GetString()
+            model_part_io = KM.ModelPartIO(file_name)
+            model_part_io.ReadModelPart(self.model_part)
+        else:
+            self.model_part = self.model.GetModelPart(self._model_part_name)
+
+        only = self.response_settings["only"].GetString()
+        if only != "":
+            only_part = self.model.GetModelPart(only)
+            if only_part.NumberOfConditions() == 0:
+                _AddConditionsFromParent(self.model_part, only_part)
+                Logger.PrintWarning("FaceAngleResponse", "Automatically added {} conditions to model_part '{}'.".format(only_part.NumberOfConditions(), only_part.Name))
+        else:
+            only_part = self.model_part
+
+        if only_part.NumberOfConditions() == 0:
+            raise RuntimeError("The model_part '{}' does not have any surface conditions!".format(only_part.Name))
+
+        self.response_function_utility = KSO.FaceAngleResponseFunctionUtility(only_part, self.response_settings)
+
+        self.response_function_utility.Initialize()
+
+    def UpdateDesign(self, updated_model_part, variable):
+        self.value = None
+
+    def CalculateValue(self):
+        Logger.PrintInfo("FaceAngleResponse", "Starting calculation of response value:", self.identifier)
+
+        startTime = timer.time()
+        self.value = self.response_function_utility.CalculateValue()
+        Logger.PrintInfo("FaceAngleResponse", "Time needed for calculating the response value = ",round(timer.time() - startTime,2),"s")
+
+    def CalculateGradient(self):
+        Logger.PrintInfo("FaceAngleResponse", "Starting gradient calculation for response", self.identifier)
+
+        for node in self.model_part.Nodes:
+            node.SetSolutionStepValue(KM.SHAPE_SENSITIVITY, [0.0, 0.0, 0.0])
+
+        startTime = timer.time()
+        self.response_function_utility.CalculateGradient()
+        Logger.PrintInfo("FaceAngleResponse", "Time needed for calculating gradients",round(timer.time() - startTime,2),"s")
+
+    def GetValue(self):
+        return self.value
+
+    def GetNodalGradient(self, variable):
+        if variable != KM.SHAPE_SENSITIVITY:
+            raise RuntimeError("GetNodalGradient: No gradient for {}!".format(variable.Name))
+        gradient = {}
+        for node in self.model_part.Nodes:
+            gradient[node.Id] = node.GetSolutionStepValue(variable)
+        return gradient

KratosMultiphysics/ShapeOptimizationApplication/response_functions/mesh_based_packaging.py

@@ -0,0 +1,70 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+from .packaging_response_base import PackagingResponseBase
+from ..custom_ios.wrl_io import WrlIO
+
+class MeshBasedPackaging(PackagingResponseBase):
+    """
+    A class for mesh packaging response function. The mesh should contain surface conditions only.
+    By default the normals of the conditions indicate the feasible side of the mesh (see setting 'feasible_in_normal_direction')
+    """
+
+    def __init__(self, identifier, response_settings, model):
+        super().__init__(identifier, response_settings, model)
+
+        self.packaging_model_part = None
+        self.packaging_model_part_needs_to_be_imported = False
+
+        packaging_model_part_name = response_settings["packaging_model_part_name"].GetString()
+        self.packaging_input_type = response_settings["packaging_model_import_settings"]["input_type"].GetString()
+        if self.packaging_input_type in ["mdpa", "vrml", "wrl"]:
+            self.packaging_model_part = self.model.CreateModelPart(packaging_model_part_name)
+            domain_size = response_settings["packaging_domain_size"].GetInt()
+            if domain_size not in [2, 3]:
+                raise Exception("PlaneBasedPackaging: Invalid 'domain_size': {}".format(domain_size))
+            self.packaging_model_part.ProcessInfo.SetValue(KM.DOMAIN_SIZE, domain_size)
+        elif self.packaging_input_type == "use_input_model_part":
+            self.packaging_model_part = self.model.GetModelPart(packaging_model_part_name)
+        else:
+            raise Exception("Other model part input options are not yet implemented.")
+
+        self.packaging_model_part.AddNodalSolutionStepVariable(KM.NORMAL)
+        self.packaging_model_part.AddNodalSolutionStepVariable(KSO.NORMALIZED_SURFACE_NORMAL)
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = KM.Parameters("""{
+            "packaging_model_part_name"       : "UNKNOWN_NAME",
+            "packaging_domain_size"           : 3,
+            "packaging_model_import_settings" : {
+                "input_type"     : "mdpa",
+                "input_filename" : "UNKNOWN_NAME"
+            }
+        }""")
+        this_defaults.AddMissingParameters(super().GetDefaultParameters())
+        return this_defaults
+
+    def Initialize(self):
+        super().Initialize()
+
+        if self.packaging_input_type == "mdpa":
+            model_part_io = KM.ModelPartIO(self.response_settings["packaging_model_import_settings"]["input_filename"].GetString())
+            model_part_io.ReadModelPart(self.packaging_model_part)
+        elif self.packaging_input_type in ["vrml", "wrl"]:
+            model_part_io = WrlIO(self.response_settings["packaging_model_import_settings"]["input_filename"].GetString())
+            model_part_io.ReadModelPart(self.packaging_model_part)
+
+    def _CalculateDistances(self):
+        geometry_tools = KSO.GeometryUtilities(self.model_part)
+
+        self.signed_distances, self.directions = geometry_tools.ComputeDistancesToBoundingModelPart(self.packaging_model_part)

KratosMultiphysics/ShapeOptimizationApplication/response_functions/packaging_response_base.py

@@ -0,0 +1,156 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import time as timer
+import KratosMultiphysics as KM
+from KratosMultiphysics import Logger
+from KratosMultiphysics.response_functions.response_function_interface import ResponseFunctionInterface
+
+class PackagingResponseBase(ResponseFunctionInterface):
+    """
+    A base class for packaging response functions that agglomerate the nodal violations
+    into a single response function.
+    The agglomeration happens by summing up the square of each nodal violation.
+    Nodes that are feasible do NOT contribute to the response value/gradient.
+    This is why a prediction of the violation using the gradients is not possible,
+    only correction of violations (e.g. from the last step) will happen.
+
+    Derived classes need to implement the calculation of the nodal violations
+
+    Important settings:
+    feasible_in_normal_direction : boolean flag that indicates if the normal of bounding instance
+        points to the feasible side. True by default
+    """
+
+    def __init__(self, identifier, response_settings, model):
+        self.identifier = identifier
+
+        response_settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.response_settings = response_settings
+        self.model = model
+
+        self._model_part_name = response_settings["model_part_name"].GetString()
+        input_type = response_settings["model_import_settings"]["input_type"].GetString()
+        if input_type == "mdpa":
+            self.model_part = self.model.CreateModelPart(self._model_part_name)
+            domain_size = response_settings["domain_size"].GetInt()
+            if domain_size not in [2, 3]:
+                raise Exception("PackagingResponseBase: Invalid 'domain_size': {}".format(domain_size))
+            self.model_part.ProcessInfo.SetValue(KM.DOMAIN_SIZE, domain_size)
+        elif input_type == "use_input_model_part":
+            self.model_part = None  # will be retrieved in Initialize()
+        else:
+            raise Exception("PackagingResponseBase: '{}' model part input type not implemented.".format(input_type))
+
+        self.signed_distances = None
+        self.directions = None
+
+        self.value = None
+
+        self.gradient = {}
+
+        self.feasible_in_normal_direction = self.response_settings["feasible_in_normal_direction"].GetBool()
+        self.exponent = 2
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = KM.Parameters("""{
+            "response_type"         : "UNKNOWN_TYPE",
+            "model_part_name"       : "UNKNOWN_NAME",
+            "domain_size"           : 3,
+            "model_import_settings" : {
+                "input_type"        : "use_input_model_part",
+                "input_filename"    : "UNKNOWN_NAME"
+            },
+            "feasible_in_normal_direction" : true
+        }""")
+        return this_defaults
+
+    def Initialize(self):
+        if self.response_settings["model_import_settings"]["input_type"].GetString() == "mdpa":
+            file_name = self.response_settings["model_import_settings"]["input_filename"].GetString()
+            model_part_io = KM.ModelPartIO(file_name)
+            model_part_io.ReadModelPart(self.model_part)
+        else:
+            self.model_part = self.model.GetModelPart(self._model_part_name)
+
+    def InitializeSolutionStep(self):
+        self.value = None
+        self.signed_distances = None
+        self.directions = None
+        self.gradient = {}
+
+    def CalculateValue(self):
+        Logger.PrintInfo("\n> Starting primal analysis for response", self.identifier)
+
+        startTime = timer.time()
+
+        if not self.directions or not self.signed_distances:
+            self._CalculateDistances()
+
+        value = 0.0
+        for i in range(len(self.signed_distances)):
+            value += self._CalculateNodalValue(self.signed_distances[i])
+
+        self.value = value
+
+        Logger.PrintInfo("> Time needed for calculating the response value = ", round(timer.time() - startTime,2), "s")
+
+    def CalculateGradient(self):
+        Logger.PrintInfo("\n> Starting gradient calculation for response", self.identifier)
+
+        startTime = timer.time()
+
+        if not self.directions or not self.signed_distances:
+            self._CalculateDistances()
+
+        for i, node in enumerate(self.model_part.Nodes):
+            gradient = self._CalculateNodalGradient(self.signed_distances[i], self.directions[i*3:i*3+3])
+            self.gradient[node.Id] = gradient
+
+        Logger.PrintInfo("> Time needed for calculating gradients = ", round(timer.time() - startTime,2), "s")
+
+    def GetValue(self):
+        return self.value
+
+    def GetNodalGradient(self, variable):
+        if not self.gradient:
+            raise RuntimeError("Gradient was not calculated")
+        if variable != KM.SHAPE_SENSITIVITY:
+            raise RuntimeError("GetNodalGradient: No gradient for {}!".format(variable.Name))
+        return self.gradient
+
+    def _CalculateDistances(self):
+        raise NotImplementedError("_CalculateDistances needs to be implemented by the derived class!")
+
+    def _CalculateNodalValue(self, signed_distance):
+        if not self._HasContribution(signed_distance):
+            return 0.0
+        return pow(signed_distance, self.exponent)
+
+    def _CalculateNodalGradient(self, signed_distance, direction):
+        if not self._HasContribution(signed_distance):
+            return [0.0, 0.0, 0.0]
+
+        factor = self.exponent * pow(signed_distance, self.exponent-1)
+        gradient = [
+            direction[0] * factor,
+            direction[1] * factor,
+            direction[2] * factor
+        ]
+        return gradient
+
+    def _HasContribution(self, signed_distance):
+        if not self.feasible_in_normal_direction and signed_distance > 0:
+            return True
+        elif self.feasible_in_normal_direction and signed_distance < 0:
+            return True
+        return False

KratosMultiphysics/ShapeOptimizationApplication/response_functions/plane_based_packaging.py

@@ -0,0 +1,61 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import KratosMultiphysics as KM
+from .packaging_response_base import PackagingResponseBase
+from KratosMultiphysics.ShapeOptimizationApplication.utilities import custom_math as cm
+
+class PlaneBasedPackaging(PackagingResponseBase):
+    """
+    A class that defines the response function for plane-based packaging. The plane is defined by an origin point and a normal vector.
+    By default the normal of the plane indicates the feasible side of the plane (see setting 'feasible_in_normal_direction')
+    """
+
+    def __init__(self, identifier, response_settings, model):
+
+        super().__init__(identifier, response_settings, model)
+
+        self.plane_origin = []
+        for i in range(0,3):
+            self.plane_origin.append(self.response_settings["plane_origin"][i].GetDouble())
+
+        self.plane_normal = []
+        for i in range(0,3):
+            self.plane_normal.append(self.response_settings["plane_normal"][i].GetDouble())
+
+        self.plane_normal = cm.ScalarVectorProduct(1.0/cm.Norm2(self.plane_normal), self.plane_normal)
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = KM.Parameters("""{
+            "plane_origin"          : [0.0, 0.0, 0.0],
+            "plane_normal"          : [0.0, 0.0, 1.0]
+        }""")
+        this_defaults.AddMissingParameters(super().GetDefaultParameters())
+        return this_defaults
+
+    def _DistanceVectorToPlane(self, node):
+        plane_to_point = [
+            node.X - self.plane_origin[0],
+            node.Y - self.plane_origin[1],
+            node.Z - self.plane_origin[2]
+        ]
+
+        distance = cm.Dot(plane_to_point, self.plane_normal)
+
+        return distance, self.plane_normal
+
+    def _CalculateDistances(self):
+        self.signed_distances = []
+        self.directions = []
+        for node in self.model_part.Nodes:
+            distance, direction = self._DistanceVectorToPlane(node)
+            self.signed_distances.append(distance)
+            self.directions.extend(direction)

KratosMultiphysics/ShapeOptimizationApplication/response_functions/response_function_factory.py

@@ -0,0 +1,40 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+from . import plane_based_packaging
+from . import mesh_based_packaging
+from . import surface_normal_shape_change
+from . import face_angle
+from . import airfoil_2d_responses
+from . import total_volume
+
+def CreateResponseFunction(response_id, response_settings, model):
+    response_type = response_settings["response_type"].GetString()
+
+    if response_type == "plane_based_packaging":
+        return plane_based_packaging.PlaneBasedPackaging(response_id, response_settings, model)
+    elif response_type == "mesh_based_packaging":
+        return mesh_based_packaging.MeshBasedPackaging(response_id, response_settings, model)
+    elif response_type == "surface_normal_shape_change":
+        return surface_normal_shape_change.SurfaceNormalShapeChange(response_id, response_settings, model)
+    elif response_type == "face_angle":
+        return face_angle.FaceAngleResponseFunction(response_id, response_settings, model)
+    elif response_type == "airfoil_angle_of_attack":
+        return airfoil_2d_responses.AngleOfAttackResponseFunction(response_id, response_settings, model)
+    elif response_type == "airfoil_chord_length":
+        return airfoil_2d_responses.ChordLengthResponseFunction(response_id, response_settings, model)
+    elif response_type == "airfoil_perimeter":
+        return airfoil_2d_responses.PerimeterResponseFunction(response_id, response_settings, model)
+    elif response_type == "total_volume":
+        return total_volume.TotalVolume(response_id, response_settings, model)
+    else:
+        raise NameError("The type of the following response function is not specified: "+ response_id +
+                        ".\nAvailable types are: 'plane_based_packaging', 'mesh_based_packaging', 'face_angle', " +
+                        "'airfoil_angle_of_attack', 'airfoil_chord_length', 'airfoil_perimeter.")