KratosShapeOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_sensitivity_heatmap.py

@@ -0,0 +1,235 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Schmölz David, https://github.com/dschmoelz
+#
+# ==============================================================================
+
+# Kratos Core and Apps
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+from KratosMultiphysics.ShapeOptimizationApplication.utilities import custom_math as cm
+# Import additional libraries
+
+# some response are continuously formulated
+continuous_response_gradients = ("plane_based_packaging", "mesh_based_packaging")
+
+# ==============================================================================
+# --------------------------------------------------------------------------
+class SensitivityHeatmapCalculator(object):
+
+    # --------------------------------------------------------------------------
+    def __init__(self, design_surface, objectives, constraints, settings):
+        self.design_surface = design_surface
+        self.objectives = objectives
+        self.constraints = constraints
+
+        if objectives.size() > 1:
+            raise RuntimeError("Sensitivity Heatmap only supports one objective function!")
+
+        self.settings = settings
+        self.norm_type = settings["norm_type"].GetString()
+        if self.norm_type not in ("max", "l2"):
+            raise NameError("""The following norm type is not supported by the
+                            sensitivity heatmap logger (name may be misspelled): """ + self.norm_type)
+
+        self.sensitivity_weighting = settings["sensitivity_weighting"].GetBool()
+        self.map_sensitivities = settings["mapping"].GetBool()
+        self.relaxation_method = settings["relaxation_method"].GetString()
+        if self.relaxation_method not in ("reciprocal", "constant"):
+            raise NameError("""The following relaxation method is not supported by the
+                            sensitivity heatmap logger (name may be misspelled): """ + self.relaxation_method)
+
+        self.design_variable_name = settings["design_variable_name"].GetString()
+        self.design_variable_dimension = settings["design_variable_dimension"].GetInt()
+
+        self.optimization_utilities = KSO.OptimizationUtilities
+
+    # --------------------------------------------------------------------------
+    def ComputeHeatmaps(self, optimization_iteration, mapper):
+
+        # calculate nodal areas for weighting
+        if self.sensitivity_weighting:
+            KSO.GeometryUtilities(self.design_surface).CalculateNodalAreasFromConditions()
+
+        self.__ComputeIndividualHeatmaps(optimization_iteration, mapper)
+        if self.constraints.size() != 0:
+            self.__ComputeAggregatedHeatmap(optimization_iteration, mapper)
+
+    # --------------------------------------------------------------------------
+    def __ComputeIndividualHeatmaps(self, optimization_iteration, mapper):
+
+        objective_gradient_name = f"DF1D{self.design_variable_name}"
+        objective_type = self.objectives[0]["response_settings"]["response_type"]
+        self.__ComputeResponseHeatmap(objective_gradient_name, objective_type, optimization_iteration, mapper)
+
+        if self.constraints.size() != 0:
+            for itr in range(self.constraints.size()):
+                constraint_gradient_name = f"DC{(itr+1)}D{self.design_variable_name}"
+                constraint_type = self.constraints[itr]["response_settings"]["response_type"]
+                self.__ComputeResponseHeatmap(constraint_gradient_name, constraint_type, optimization_iteration, mapper)
+
+    # --------------------------------------------------------------------------
+    def __ComputeAggregatedHeatmap(self, optimization_iteration, mapper):
+
+        # normalize objective gradient
+        objective_gradient_name = f"DF1D{self.design_variable_name}"
+        objective_type = self.objectives[0]["response_settings"]["response_type"]
+        df_dx_normalized = self.__NormalizeResponseGradient(objective_gradient_name, objective_type)
+
+        # normalize constraints
+        dc_dx_normalized = []
+        for itr in range(self.constraints.size()):
+            constraint_gradient_name = f"DC{(itr+1)}D{self.design_variable_name}"
+            constraint_type = self.constraints[itr]["response_settings"]["response_type"]
+            dc_dx_normalized.append(self.__NormalizeResponseGradient(constraint_gradient_name, constraint_type))
+
+        # fill heat map for each node
+        heat = Kratos.Vector(len(self.design_surface.Nodes))
+        for i in range(len(self.design_surface.Nodes)):
+            index = self.design_variable_dimension*i
+            df_dx_i = df_dx_normalized[index:index+self.design_variable_dimension]
+            df_dx_i_norm = cm.Norm2(df_dx_i)
+
+            heat_i = df_dx_i_norm
+            for dc_dx in dc_dx_normalized:
+                dc_dx_i = dc_dx[index:index+self.design_variable_dimension]
+                dc_dx_i_norm = cm.Norm2(dc_dx_i)
+                heat_i = max(heat_i, dc_dx_i_norm)
+
+            heat[i] = heat_i
+
+        if self.norm_type == "max":
+            heat_map_name = "HEATMAP_MAX"
+        elif self.norm_type == "l2":
+            heat_map_name = "HEATMAP_L2"
+
+        # relax heatmap
+        relaxation_coefficient = self.__GetRelaxationCoefficient(optimization_iteration)
+        if optimization_iteration == 1:
+            heat_relaxed = heat
+        else:
+            prev_heat = Kratos.Vector()
+            self.optimization_utilities.AssembleVector(self.design_surface, prev_heat, Kratos.KratosGlobals.GetVariable(heat_map_name))
+            heat_relaxed = Kratos.Vector(len(self.design_surface.Nodes))
+            for i in range(len(self.design_surface.Nodes)):
+                heat_relaxed[i] = relaxation_coefficient * heat[i] + (1 - relaxation_coefficient) * prev_heat[i]
+
+        self.optimization_utilities.AssignVectorToVariable(self.design_surface, heat_relaxed, Kratos.KratosGlobals.GetVariable(heat_map_name))
+
+    # --------------------------------------------------------------------------
+    def __ComputeResponseHeatmap( self, response_gradient_name, response_type, optimization_iteration, mapper):
+
+        response_is_weighted = False
+        if self.sensitivity_weighting and \
+            response_type not in continuous_response_gradients:
+            response_is_weighted = True
+
+        if response_is_weighted:
+            self.__WeightResponseGradient(response_gradient_name)
+            response_gradient_name += "_WEIGHTED"
+        if self.map_sensitivities:
+            # reponse has been already mapped by the optimization algorithm if it is not weighted
+            if response_is_weighted:
+                self.__MapResponseGradient(response_gradient_name, mapper)
+            response_gradient_name += "_MAPPED"
+
+        self.__RelaxResponseHeatmap(response_gradient_name, optimization_iteration)
+
+    # --------------------------------------------------------------------------
+    def __WeightResponseGradient( self, response_gradient_name ):
+
+        nodal_area = Kratos.Vector()
+        self.optimization_utilities.AssembleVector(self.design_surface, nodal_area, Kratos.KratosGlobals.GetVariable("NODAL_AREA"))
+
+        dg_dx = Kratos.Vector()
+        self.optimization_utilities.AssembleVector(self.design_surface, dg_dx, Kratos.KratosGlobals.GetVariable(response_gradient_name))
+
+        # weight response gradients with nodal area
+        dg_dx_weighted = Kratos.Vector(self.design_variable_dimension*len(self.design_surface.Nodes))
+        for i in range(len(self.design_surface.Nodes)):
+            for dim in range(self.design_variable_dimension):
+                index = self.design_variable_dimension * i + dim
+                if nodal_area[i] > 1e-8:
+                    dg_dx_weighted[index] = dg_dx[index] / nodal_area[i]
+                else:
+                    dg_dx_weighted[index] = dg_dx[index]
+
+        response_gradient_weighted_name = f"{response_gradient_name}_WEIGHTED"
+        self.optimization_utilities.AssignVectorToVariable(self.design_surface, dg_dx_weighted,
+                                                           Kratos.KratosGlobals.GetVariable(response_gradient_weighted_name))
+
+    # --------------------------------------------------------------------------
+    def __MapResponseGradient( self, response_gradient_name, mapper ):
+
+        response_gradient_mapped_name = f"{response_gradient_name}_MAPPED"
+        mapper.InverseMap(Kratos.KratosGlobals.GetVariable(response_gradient_name),
+                               Kratos.KratosGlobals.GetVariable(response_gradient_mapped_name))
+
+    # --------------------------------------------------------------------------
+    def __RelaxResponseHeatmap( self, response_gradient_name, optimization_iteration ):
+
+        relaxation_coefficient = self.__GetRelaxationCoefficient(optimization_iteration)
+
+        dg_dx = Kratos.Vector()
+        self.optimization_utilities.AssembleVector(self.design_surface, dg_dx, Kratos.KratosGlobals.GetVariable(response_gradient_name))
+
+        g_name = f"{response_gradient_name[0:4]}"
+        heatmap_dgdx_name = f"HEATMAP_{g_name}{self.design_variable_name}"
+        if optimization_iteration == 1:
+            heat_dfdx_relaxed = dg_dx
+        else:
+            prev_heat_dfdx = Kratos.Vector()
+            self.optimization_utilities.AssembleVector(self.design_surface, prev_heat_dfdx, Kratos.KratosGlobals.GetVariable(heatmap_dgdx_name))
+            heat_dfdx_relaxed = Kratos.Vector(self.design_variable_dimension*len(self.design_surface.Nodes))
+            for i in range(len(self.design_surface.Nodes)):
+                for dim in range(self.design_variable_dimension):
+                    index = self.design_variable_dimension * i + dim
+                    heat_dfdx_relaxed[index] = relaxation_coefficient * dg_dx[index] + (1 - relaxation_coefficient) * prev_heat_dfdx[index]
+
+        self.optimization_utilities.AssignVectorToVariable(self.design_surface, heat_dfdx_relaxed, Kratos.KratosGlobals.GetVariable(heatmap_dgdx_name))
+
+    # --------------------------------------------------------------------------
+    def __NormalizeResponseGradient( self, response_gradient_name, response_type ):
+
+        response_is_weighted = False
+        if self.sensitivity_weighting and \
+            response_type not in continuous_response_gradients:
+            response_is_weighted = True
+
+        if response_is_weighted:
+            response_gradient_name += "_WEIGHTED"
+        if self.map_sensitivities:
+            response_gradient_name += "_MAPPED"
+
+        optimization_utilities = KSO.OptimizationUtilities
+
+        dg_dx = Kratos.Vector()
+        optimization_utilities.AssembleVector(self.design_surface, dg_dx, Kratos.KratosGlobals.GetVariable(response_gradient_name))
+
+        if self.norm_type == "max":
+            dg_dx_norm = cm.NormInf3D(dg_dx)
+        elif self.norm_type == "l2":
+            dg_dx_norm = cm.Norm2(dg_dx)
+        else:
+            raise RuntimeError("Sensitivity Heatmap only supports 'max' or 'l2' norm!")
+
+        if dg_dx_norm != 0.0:
+            dg_dx_normalized = (1/dg_dx_norm) * dg_dx
+        else:
+            dg_dx_normalized = 0 * dg_dx
+
+        return dg_dx_normalized
+
+    # --------------------------------------------------------------------------
+    def __GetRelaxationCoefficient( self, optimization_iteration ):
+
+        if self.relaxation_method == "reciprocal":
+            return 1 / optimization_iteration
+        elif self.relaxation_method == "constant":
+            return self.settings["relaxation_coefficient"].GetDouble()
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_timer.py

@@ -0,0 +1,47 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#                   Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+
+# Import additional libraries
+import time
+
+# ==============================================================================
+class Timer:
+    # --------------------------------------------------------------------------
+    def __init__( self ):
+        self.Precision = 3
+        self.StartGlobalTime = None
+        self.StartLapTime = None
+        self.LapTime = None
+    # --------------------------------------------------------------------------
+    def StartTimer( self ):
+        self.StartGlobalTime = time.time()
+        self.StartLapTime = time.time()
+
+    # --------------------------------------------------------------------------
+    def GetLapTime( self ):
+        LapTime = time.time() - self.StartLapTime
+        return round( LapTime, self.Precision )
+
+    # --------------------------------------------------------------------------
+    def StartNewLap( self ):
+        self.StartLapTime = time.time()
+
+    #---------------------------------------------------------------------------
+    def GetTotalTime( self ):
+        totalTime = time.time() - self.StartGlobalTime
+        return round( totalTime, self.Precision )
+
+    # --------------------------------------------------------------------------
+    def GetTimeStamp( self ):
+        return time.ctime()
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_variable_utilities.py

@@ -0,0 +1,54 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+def WriteDictionaryDataOnNodalVariable(data, model_part, nodal_variable):
+    for node_id, tmp_gradient in data.items():
+        model_part.Nodes[node_id].SetSolutionStepValue(nodal_variable, 0, tmp_gradient)
+
+# ------------------------------------------------------------------------------
+def ReadNodalVariableToList(model_part, nodal_variable, dimension=3):
+    variable_values_list = [0.0]*model_part.NumberOfNodes()*dimension
+
+    for itr, node in enumerate(model_part.Nodes):
+        tmp_values = node.GetSolutionStepValue(nodal_variable)
+
+        if dimension == 1:
+            variable_values_list[itr] = tmp_values
+        else:
+            for i in range(dimension):
+                variable_values_list[dimension*itr+i] = tmp_values[i]
+
+    return variable_values_list
+
+# --------------------------------------------------------------------------
+def WriteListToNodalVariable(input_list, model_part, nodal_variable, dimension=3):
+    if len(input_list) != model_part.NumberOfNodes()*dimension:
+        raise RuntimeError("custom_variable_utility::WriteListToNodalVariable: Wrong size of input_list!")
+
+    k = 0
+    for node in model_part.Nodes:
+        if dimension == 1:
+            tmp_values = input_list[k]
+        else:
+            tmp_values = input_list[k:k+dimension]
+        node.SetSolutionStepValue(nodal_variable, tmp_values)
+        k = k+dimension
+
+# --------------------------------------------------------------------------
+def WriteNodeCoordinatesToList(model_part):
+    variable_values_list = [0.0]*model_part.NumberOfNodes()*3
+
+    for itr, node in enumerate(model_part.Nodes):
+        variable_values_list[3*itr+0] = node.X
+        variable_values_list[3*itr+1] = node.Y
+        variable_values_list[3*itr+2] = node.Z
+
+    return variable_values_list
+
+# ==============================================================================

kratosshapeoptimizationapplication-10.4.4.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: KratosShapeOptimizationApplication
+Version: 10.4.4
+Summary:         KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
+Author-email: Kratos Team <kratos@listas.cimne.upc.edu>
+License: BSD-4-Clause
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Requires-Dist: kratosmultiphysics==10.4.4
+Description-Content-Type: text/markdown
+
+# ShapeOptimizationApplication
+
+The Kratos ShapeOptimizationApplication contains an implementation of the Vertex Morphing method for node-based shape optimization.
+
+It can be used in combination with the Adjoint Sensitivity Analysis capabilities of the Kratos StructuralMechanicsApplication and ConvectionDiffusionApplication.
+Additionally it offers an interface to use external response functions via custom python code.
+
+
+## Examples
+
+A few application examples can be found [here](https://github.com/KratosMultiphysics/Examples/tree/master/shape_optimization)
+
+
+### References
+
+- Bletzinger, K.-U. A consistent frame for sensitivity filtering and the vertex assigned morphing of optimal shape. Struct Multidisc Optim 49, 873–895 (2014). https://doi.org/10.1007/s00158-013-1031-5
+- Bletzinger, K.-U. (2017). Shape Optimization. In Encyclopedia of Computational Mechanics Second Edition (eds E. Stein, R. Borst and T.J.R. Hughes). https://doi.org/10.1002/9781119176817.ecm2109
+

kratosshapeoptimizationapplication-10.4.4.dist-info/RECORD

@@ -0,0 +1,69 @@
+kratosshapeoptimizationapplication-10.4.4.dist-info/RECORD,,
+kratosshapeoptimizationapplication-10.4.4.dist-info/WHEEL,sha256=QX0UaoWXQIAv8vp5R3do793urekDoJdJRoGCk8nXIBY,115
+kratosshapeoptimizationapplication-10.4.4.dist-info/METADATA,sha256=jx423yyqWHk18LzRHbxDcHMvvtw0pY12B3ZoHKmP8xg,1663
+KratosMultiphysics/.libs/libKratosShapeOptimizationCore.dylib,sha256=txhN5_COSYCgS8vtqqhItjZBObIf19JuG4AAO6Xg6Hs,4755424
+KratosMultiphysics/.libs/KratosShapeOptimizationApplication.so,sha256=0lqzYU-jDzuqqTsCc8G0wiITOw1cIFqlcD9m8zrFAHI,1951360
+KratosMultiphysics/ShapeOptimizationApplication/TemplateMainKratosShapeOptimization.py,sha256=AfN_XDKyrCs5o9QVoeBBDrvSLIhMVrlt9C5zXHUDMMI,1343
+KratosMultiphysics/ShapeOptimizationApplication/communicator_factory.py,sha256=YvM5Q_psPUe9KR0UgnS-XSOwS48RBgb3LQdD9Mgc6SE,13498
+KratosMultiphysics/ShapeOptimizationApplication/mapper_factory.py,sha256=C2EVo5Zov9PO7ANfxoimtkAsOpyPxEGy-fVQVL9HuNw,5476
+KratosMultiphysics/ShapeOptimizationApplication/__init__.py,sha256=1P0_CzQiDhtVBO3QcOPUOb02FSIRfPMHcIh6nR0wyn8,811
+KratosMultiphysics/ShapeOptimizationApplication/model_part_controller_factory.py,sha256=ZP_y4SZ-s0-5WxGGZzHyXj7LYg6frAUl5NxHTREWKFk,9727
+KratosMultiphysics/ShapeOptimizationApplication/optimizer_factory.py,sha256=U3VHdu1CFE6-VEYXOlmtBhMqSePRFqVjg-qOW93-i4o,13333
+KratosMultiphysics/ShapeOptimizationApplication/mapping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/mapping/in_plane_vertex_morphing_mapper.py,sha256=fU18L0CCsAsD7gNEIBYsWZOW3dH9LTMvu0iU5smOhYk,6901
+KratosMultiphysics/ShapeOptimizationApplication/mapping/sliding_vertex_morphing_mapper.py,sha256=W8kxcqb6bS0ogU79Lrr2G2EkaauQxKuou7RqSaCMeZA,18652
+KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_base.py,sha256=3lANIAwI22R0WUMZwRAlOYRdaNnC35THTQDloZ09GZQ,1316
+KratosMultiphysics/ShapeOptimizationApplication/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_factory.py,sha256=LeHftBaQkFB72tHS4R--OYWSWcjiPQ8oTcKrj3eLUDM,15259
+KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_internal.py,sha256=co0MVNw7Gopdh_sG1QaNht6ccMQh927_1_CtOxOUSmA,8283
+KratosMultiphysics/ShapeOptimizationApplication/analyzers/analyzer_empty.py,sha256=llKIFS6yS0wjwFPngDU5iAAg9z-ysH7zgC2Zqv_gyEs,856
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_shape_fraction_optimization.py,sha256=Iqz9LUCyKCrb_eMI5Vb9u4-1ye-jSNFPLh6oOUyyYoA,5161
+KratosMultiphysics/ShapeOptimizationApplication/loggers/design_logger_base.py,sha256=2r_kDALwjPkxClOZzP5wA9-C_79Og9oMIhG4rFBFy0I,1423
+KratosMultiphysics/ShapeOptimizationApplication/loggers/design_logger_unv.py,sha256=rV4TSp8awUTHy5uCFvQujfR-9vIZI-oyTQZe0QzHW_g,3603
+KratosMultiphysics/ShapeOptimizationApplication/loggers/design_logger_gid.py,sha256=UlABuCjfV3fNo6luedL1xAbAHKi9OfQ7UZWKlOxtfp4,5466
+KratosMultiphysics/ShapeOptimizationApplication/loggers/design_logger_vtk.py,sha256=Q3oztFf6wp0CssJRMyyeBHzVagbKrPjZi1RJKBkHFxk,4488
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_steepest_descent.py,sha256=DkKLvcX9Y0jETdptCv1p_J3aKvnr70FWLfPAVGdqEco,3445
+KratosMultiphysics/ShapeOptimizationApplication/loggers/sensitivity_heatmap_logger.py,sha256=W9bXwk2iLzfAPc9Z_5HzLrGVjVmPnSzDnLgv5XJzAdY,4893
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_penalized_projection.py,sha256=FlFMxlwHNU2teYva23XxkBw3l2E39Y0G_YF2ofKVnQw,4353
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_trust_region.py,sha256=7sWCeWLt6QswCalSuoGAyVsghXVn6u2KiZftDHb60Po,5835
+KratosMultiphysics/ShapeOptimizationApplication/loggers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/loggers/data_logger_factory.py,sha256=BGaBqpgyIbv4TXNFmHaaBZSjCGvAZfcM9sOt4-02NVs,11563
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_base.py,sha256=UAgNb2hbnDVswkBl_89lezdWG_EeOa4Jva4AglWrOfU,6205
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_gradient_projection.py,sha256=weeqZr-VpMcVlbeeHzVsjO6q4MzQAFV694cKMWxDWHw,4418
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_relaxed_gradient_projection.py,sha256=HZMrZgxwSm0RlmlucC_ycErObco7YE7_CYhXvViFBhs,6523
+KratosMultiphysics/ShapeOptimizationApplication/loggers/value_logger_bead_optimization.py,sha256=jJcfjvKAiEXKlztD4mAvONFzA97YC4qhDjcq3MQKob4,4791
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_relaxed_gradient_projection.py,sha256=fOD-WxxIE6CUgeX-OoJ3aGbJ0HGOA3m4LAF5RL21Vko,30146
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_base.py,sha256=_ob_wfceg7ERX5qy82wf2KA5SzCZbKOHZByzZJdzsy4,1694
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_factory.py,sha256=YcckC9lvfgdo0qBNATS3Kvc2DGTAEdCa-QVYMKujcxg,3473
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_trust_region.py,sha256=cuE8QrG7HNUJgPAe3krqAzM6DajMDZQTVaqlfJw0nhA,31404
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_gradient_projection.py,sha256=wY4yJc66vJNC7nVvIY6AIhWR17vk1z4fH6LaM51guxg,16325
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_penalized_projection.py,sha256=6irbx7BlkzegKD_MW3FlMJthQNgCdQC0PHeyPhdGbPU,11809
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_shape_fraction_optimization.py,sha256=azOH5HfwmZYTzLDtcW4k0CoXOefIm-6-xO5wmk1J4KU,29713
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_bead_optimization.py,sha256=-itmON5GPfO-4OveYzBviQvpgiidgMP_J2P63v20ZnE,21979
+KratosMultiphysics/ShapeOptimizationApplication/algorithms/algorithm_steepest_descent.py,sha256=pMmxcGn8oMlLhq0Id6yltdWkzNiTR4gEkPItAs1ZvAs,13163
+KratosMultiphysics/ShapeOptimizationApplication/mesh_controllers/mesh_controller_base.py,sha256=l0sAcDyRpLXzJlbGG7uYCu3IzNBjta9OLi1mFcxuUNg,994
+KratosMultiphysics/ShapeOptimizationApplication/mesh_controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/mesh_controllers/mesh_controller_basic_updating.py,sha256=Fv7Bf0waVdXxDBezHdEAwCCmAl4U7reaB1A67B8BEGY,1609
+KratosMultiphysics/ShapeOptimizationApplication/mesh_controllers/mesh_controller_with_solver.py,sha256=9t7Ch4nGinngGnUEpky7ytHj_R4rtcusNqfmNAsVwk0,12262
+KratosMultiphysics/ShapeOptimizationApplication/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_variable_utilities.py,sha256=zgXXHFnFGxRqV4JYDDZsg1ACObeuZjnerwCA_uFlysU,2247
+KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_timer.py,sha256=_B5VyHa-NYHNAy2GlkC3D7AONkrQlxiPwL9Cov-Bydc,1807
+KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_math.py,sha256=bTn0lCPIL43G3kbRl8LR63L-FagytxIxKQEjtNZontE,14277
+KratosMultiphysics/ShapeOptimizationApplication/utilities/custom_sensitivity_heatmap.py,sha256=WS7Zwp_RceelYMgsTkKxV5R6chFgk7tpx8_sUOMZ0Vg,11819
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/plane_based_packaging.py,sha256=CyeCBx6EcWStVKWxQHKB7rP4PpCsaS84PsGfiGvufPs,2364
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/surface_normal_shape_change.py,sha256=Y9jr2KTGebjrF0s_xjhb56L0xwUH9uHIt9pZyq5kVy4,5308
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/packaging_response_base.py,sha256=8TOtPgJUa2JRfGzj_Fiv84d9boZT3rcgEVaIIAotudY,6244
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/airfoil_2d_responses.py,sha256=QOZBh24p3oYdkiAw3ODl2rvJdpdkUO_ts1Nqs2x-gdg,8085
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/mesh_based_packaging.py,sha256=b81rbJsbdyTkYeOM3cy_o_15YfJPUiGiL5k7IzIK4m8,3464
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/response_function_factory.py,sha256=fwGhvmGbNAqFKchUEMGckyWNyvXGya4_dtdnmqaNlkg,2202
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/face_angle.py,sha256=P3w9KTZNsxSMoFPFxeCBt3n76T7q183yYTgZ0JliW98,6177
+KratosMultiphysics/ShapeOptimizationApplication/response_functions/total_volume.py,sha256=rYqbghaDCAQZMg_JvINRNjet1HpJy-33VbWhEbLyfuc,2030
+KratosMultiphysics/ShapeOptimizationApplication/custom_ios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/ShapeOptimizationApplication/custom_ios/wrl_io.py,sha256=Ap1UN-c2cmZ77MheXk9a-luQhaJP5xjZQb4RvxYuT_k,2924
+KratosMultiphysics/ShapeOptimizationApplication/custom_ios/wrl_reader.py,sha256=ZH8I2bCv1PtWnKBrgYsf_aRQcDYp5SISfT28K3IyN4s,3596
+kratosshapeoptimizationapplication.dylibs/libstdc++.6.dylib,sha256=lDZLIq4u6sqHdlyjTrjv8K_7Fx_3RQXY-2mxFRTDCOo,3403264
+kratosshapeoptimizationapplication.dylibs/libKratosCore.dylib,sha256=hGkjDVH4S_5Txr7smcg_iHAPoexX50PoTHg96ihqphM,63629792
+kratosshapeoptimizationapplication.dylibs/libgcc_s.1.1.dylib,sha256=D3xFlDs2JSc4DNp_v6MhwALp3uhoFXbEGmCA2x6nyvE,219232
+kratosshapeoptimizationapplication.dylibs/libgomp.1.dylib,sha256=KI92xW3zsH_6Ki1IUmgpSZ7OYuVmGjvJpGPtMGtd2BM,438880

kratosshapeoptimizationapplication-10.4.4.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any
+Generator: delocate 0.13.0
+

kratosshapeoptimizationapplication.dylibs/libKratosCore.dylib

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: kratosshapeoptimizationapplication.dylibs/libKratosCore.dylib
+size: 63629792 bytes
+sha256: 8469230d51f84bfe53c6beec99c83f88700fa1ec57e743e84c783dea286aa613