KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/utilities/response_utilities.py

@@ -0,0 +1,249 @@
+import re
+from enum import Enum
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.evaluation_response_function import EvaluationResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.response_function import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+class BinaryOperator(str, Enum):
+    POWER    = "^"
+    DIVIDE   = "/"
+    MULTIPLY = "*"
+    ADD      = "+"
+    SUBTRACT = "-"
+
+BinaryOperatorValues = [operator.value for operator in BinaryOperator]
+
+BinaryOperatorValuesMap = dict([(operator.value, operator) for operator in BinaryOperator])
+
+def GetClosingBracketIndex(expression: str) -> int:
+    # this function assumes the starting point is without the opening bracket.
+    # it will give the position of the respective closing bracket
+    index = 0
+    brackets_counter = 1
+    while index < len(expression):
+        brackets_counter += (expression[index] == "(") + (expression[index] == ")") * -1
+        if brackets_counter == 0:
+            return index
+        index += 1
+
+    raise RuntimeError(f"The closing bracket not found for expression ({expression}")
+
+def GetFunction(function_name: str, optimization_problem: OptimizationProblem, *args) -> ResponseFunction:
+    # import functions
+    from KratosMultiphysics.OptimizationApplication.responses.log_response_function import LogResponseFunction
+
+    functions_map: 'dict[str, type[ResponseFunction]]' = {
+        "log": LogResponseFunction
+    }
+    if function_name in functions_map.keys():
+        return functions_map[function_name](*args, optimization_problem)
+    else:
+        raise RuntimeError(f"Undefined \"{function_name}\" function. Followings are supported function names:\n\t" + "\n\t".join(functions_map.keys()))
+
+def EvaluateValue(response_function: ResponseFunction, optimization_problem: OptimizationProblem) -> float:
+    response_data = ComponentDataView("evaluated_responses", optimization_problem).GetBufferedData()
+
+    if response_function.GetImplementedPhysicalKratosVariables():
+        if not response_data.HasValue(f"values/{response_function.GetName()}"):
+            response_data.SetValue(f"values/{response_function.GetName()}", response_function.CalculateValue())
+
+        return response_data.GetValue(f"values/{response_function.GetName()}")
+    else:
+        return response_function.CalculateValue()
+
+def EvaluateGradient(response_function: ResponseFunction, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]', optimization_problem: OptimizationProblem):
+    # first get the tensor adaptors for implemented physical kratos variables
+    resp_physical_variable_combined_tensor_adaptors: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = {}
+    for variable, cta in physical_variable_gradient_map.items():
+        temp_cta = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta, perform_store_data_recursively=False, copy=False)
+        if variable in response_function.GetImplementedPhysicalKratosVariables():
+            # if the response function depends on the variable, then add it to the dictionary for future evaluation.
+            resp_physical_variable_combined_tensor_adaptors[variable] = temp_cta
+        else:
+            # if the response function does not depend on the variable, then assign zeros.
+            temp_cta.data[:] = 0.0
+            temp_cta.StoreData() # store the combined ta values to its sub tensor adaptors
+
+    resp_physical_variable_combined_tensor_adaptors_to_evaluate: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = {}
+    response_data = ComponentDataView("evaluated_responses", optimization_problem).GetUnBufferedData()
+
+    for variable, cta in resp_physical_variable_combined_tensor_adaptors.items():
+        # first check whether the gradients have been already evaluated. if so, take the gradients.
+        if response_data.HasValue(f"gradients/d{response_function.GetName()}_d{variable.Name()}"):
+            # found already evaluated gradient. Use it.
+            cta.SetData(response_data.GetValue(f"gradients/d{response_function.GetName()}_d{variable.Name()}").data)
+            cta.StoreData() # store the combined ta values to its sub tensor adaptors
+        else:
+            # gradients have not yet evaluated. put it to the dictionary for later evaluation
+            resp_physical_variable_combined_tensor_adaptors_to_evaluate[variable] = cta
+
+    if len(resp_physical_variable_combined_tensor_adaptors_to_evaluate) != 0:
+        response_function.CalculateGradient(resp_physical_variable_combined_tensor_adaptors_to_evaluate)
+        for variable, cta in resp_physical_variable_combined_tensor_adaptors_to_evaluate.items():
+            response_data.SetValue(f"gradients/d{response_function.GetName()}_d{variable.Name()}", Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta))
+
+def GetResponseFunction(current_value: str, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    from KratosMultiphysics.OptimizationApplication.responses.literal_value_response_function import LiteralValueResponseFunction
+    if current_value == "":
+        return LiteralValueResponseFunction(0.0)
+    else:
+        try:
+            # first try to get a literal response function
+            return LiteralValueResponseFunction(float(current_value))
+        except:
+            # literal response function fails. Then the current value may hold one of the followings
+            #   1. A leaf response function name
+            #   2. A response expression
+            #   3. A function call
+
+            if re.match(r"(^\w+)$", current_value) is not None:
+                # the match is a leaf response function name
+                return optimization_problem.GetResponse(current_value)
+            elif re.match(r"(^\w+\()", current_value) is not None:
+                # the match is a function call
+                args_starting_index = current_value.index("(")
+                function_name = current_value[:args_starting_index]
+
+                # now need to find the args correctly
+                args_list: 'list[str]' = []
+                index = args_starting_index + 1
+                current_arg = ""
+                while index < len(current_value) - 1:
+                    current_char = current_value[index]
+
+                    if current_char == "(":
+                        closing_bracket_pos = GetClosingBracketIndex(current_value[index+1:])
+                        current_arg += current_value[index:index+closing_bracket_pos+2]
+                        index += closing_bracket_pos + 2
+                        continue
+
+                    if current_char == ",":
+                        args_list.append(current_arg)
+                        current_arg = ""
+                    else:
+                        current_arg += current_char
+
+                    index += 1
+
+                args_list.append(current_arg)
+                return GetFunction(function_name, optimization_problem, *[__EvaluateResponseExpressionImpl(arg, optimization_problem) for arg in args_list])
+            else:
+                # this is a response expression.
+                return __EvaluateResponseExpressionImpl(current_value, optimization_problem)
+
+def GetValuesAndOperators(response_expression: str, optimization_problem: OptimizationProblem) -> 'tuple[list[ResponseFunction], list[str]]':
+    responses: 'list[ResponseFunction]' = []
+    operators: 'list[str]' = []
+
+    index = 0
+    current_word = ""
+    while index < len(response_expression):
+        current_char = response_expression[index]
+
+        if current_char == "(":
+            # found opening bracket
+            closing_bracket_position = GetClosingBracketIndex(response_expression[index + 1:])
+            if current_word != "":
+                current_word = f"{current_word}{response_expression[index:index+closing_bracket_position+2]}"
+            else:
+                current_word = response_expression[index + 1:index+closing_bracket_position + 1]
+            index += closing_bracket_position + 2
+            continue
+
+        # check for binary operator or scientific notation value
+        if current_char in BinaryOperatorValues and not (re.match(r"(^[0-9.]+[e|E])$", current_word) and current_char in ["+", "-"]):
+            responses.append(GetResponseFunction(current_word, optimization_problem))
+            operators.append(current_char)
+            current_word = ""
+            index += 1
+            continue
+
+        current_word += current_char
+        index += 1
+
+    # add the last current_word
+    responses.append(GetResponseFunction(current_word, optimization_problem))
+
+    return responses, operators
+
+def __EvaluateResponseExpressionImpl(response_expression: str, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    from KratosMultiphysics.OptimizationApplication.responses.binary_operator_response_function import BinaryOperatorResponseFunction
+
+    response_expression = response_expression.replace(" ", "")
+    responses, operators = GetValuesAndOperators(response_expression, optimization_problem)
+
+    def __evaluate_operator(list_of_operators: 'list[str]') -> None:
+        operator_index = 0
+        while operator_index < len(operators):
+            if operators[operator_index] in list_of_operators:
+                left_operand  = responses[operator_index]
+                right_operand = responses[operator_index + 1]
+
+                if not optimization_problem.HasResponse(left_operand) and left_operand.GetImplementedPhysicalKratosVariables() != []:
+                    # the left operand is not in the optimization, and it will not be accessible since it will
+                    # be within the BinaryOperatorResponseFunction. Hence adding it to optimization problem
+                    # so that we can put the intermediate values and gradients to the optimization problem.
+                    optimization_problem.AddComponent(left_operand)
+
+                if not optimization_problem.HasResponse(right_operand) and right_operand.GetImplementedPhysicalKratosVariables() != []:
+                    # the right operand is not in the optimization, and it will not be accessible since it will
+                    # be within the BinaryOperatorResponseFunction. Hence adding it to optimization problem
+                    # so that we can put the intermediate values and gradients to the optimization problem.
+                    optimization_problem.AddComponent(right_operand)
+
+                # now check whether the left operand is there in the optimization problem
+                if optimization_problem.HasResponse(left_operand):
+                    left_operand_component_data_view = ComponentDataView(left_operand, optimization_problem)
+                    # if it is in the optimization problem, and no data buffer has been defined, then define one.
+                    if not left_operand_component_data_view.HasDataBuffer():
+                        left_operand_component_data_view.SetDataBuffer(1)
+
+                # now check whether the right operand is there in the optimization problem
+                if optimization_problem.HasResponse(right_operand):
+                    right_operand_component_data_view = ComponentDataView(right_operand, optimization_problem)
+                    # if it is in the optimization problem, and no data buffer has been defined, then define one.
+                    if not right_operand_component_data_view.HasDataBuffer():
+                        right_operand_component_data_view.SetDataBuffer(1)
+
+                resultant_operator = BinaryOperatorResponseFunction(left_operand, right_operand, BinaryOperatorValuesMap[operators[operator_index]], optimization_problem)
+                if not optimization_problem.HasResponse(resultant_operator.GetName()):
+                    # There is no already existing response with the same operation. Then use the new one.
+                    responses[operator_index] = resultant_operator
+                else:
+                    # There is an already existing response with the same operation. Then take it.
+                    responses[operator_index] = optimization_problem.GetResponse(resultant_operator.GetName())
+
+                del responses[operator_index + 1]
+                del operators[operator_index]
+            else:
+                operator_index += 1
+
+    # according to BODMAS
+    __evaluate_operator(["^"])
+    __evaluate_operator(["*", "/"])
+    __evaluate_operator(["+", "-"])
+
+    return responses[0]
+
+def EvaluateResponseExpression(response_expression: str, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    evaluated_response_impl = __EvaluateResponseExpressionImpl(response_expression, optimization_problem)
+    if evaluated_response_impl.GetChildResponses() and  evaluated_response_impl.GetImplementedPhysicalKratosVariables():
+        # if the response has children and has some dependence on the variables, then
+        # we need to use the EvaluationResponseFunction to clear the evaluation data
+        # whenever CalculateValue, CalculateGradient is used.
+        evaluated_response = EvaluationResponseFunction(evaluated_response_impl, optimization_problem)
+        optimization_problem.AddComponent(evaluated_response)
+        return evaluated_response
+    else:
+        # this means the following cases
+        #    1. No children, but has dependence variables -> Leaf responses such as mass.
+        #    2. No children, no dependence variables -> Leaf responses such as LiteralValueResponse.
+        #    3. Has children, no dependence variables -> An expression with only LiteralValueResponses and functions, without any responses such as mass.
+        # in the above cases, there is no need to clear the response evaluation data, hence the original evaluated
+        # response is returned without the EvaluationResponseFunction wrapper.
+        return evaluated_response_impl

KratosMultiphysics/OptimizationApplication/utilities/timer.py

@@ -0,0 +1,45 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# 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/OptimizationApplication/utilities/union_utilities.py

@@ -0,0 +1,6 @@
+from typing import Union
+
+import KratosMultiphysics as Kratos
+
+# used union types for type hinting in python and for automated documentation generation
+SupportedSensitivityFieldVariableTypes = Union[Kratos.DoubleVariable, Kratos.Array1DVariable3]

kratosoptimizationapplication-10.4.4.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.5
+Name: KratosOptimizationApplication
+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
+
+# OptimizationApplication
+
+The Kratos OptimizationApplication is a framework for solving optimization problems in continuum mechanics. It is supposed to handle both gradient-based (adjoint-based) and gradient-free methods. 
+
+## Main Features
+
+* State-of-the-art techniques and algorithms for shape, thickness and material/topology optimization. 
+* Efficient and consistent filtering techniques for parametrization-free shape, thickness and material/topology optimization.       
+* Abstract problem formulation which enables concurrent and nested multilevel-multi-scale optimization problems.    
+* Adaptive gradient-projection technique, developed specially for problems with an arbitrary large number of design variables of different scales.
+* Modular implementation which enables analysis and optimization of multi-physics problems.    
+* Realization and implementation of additive manufacturing constraints, e.g. hangover conditions (support structures), stackability and geometric limitations.   

kratosoptimizationapplication-10.4.4.dist-info/RECORD

@@ -0,0 +1,106 @@
+KratosMultiphysics/OptimizationApplication/optimizations_controller.py,sha256=GJhXuxbar-apmyc2AS27dvtFJHNAgnoeBWubFNtxyJU,12599
+KratosMultiphysics/OptimizationApplication/model_parts_controller.py,sha256=X8g283E8EE9By6E7P5v283c_bEbs5Qba3lvt7Ldq_a0,5262
+KratosMultiphysics/OptimizationApplication/__init__.py,sha256=gAh661XHyKlmRncykK7oAiXnqQiqz3FH1fwzkmUT5OQ,779
+KratosMultiphysics/OptimizationApplication/responses_controller.py,sha256=XQwzBukmAFHBrUVrbqzimeQpLayKRJNa0CiNYx0dHik,22982
+KratosMultiphysics/OptimizationApplication/optimizer.py,sha256=E5ZytMXClU6hYtz6BvlUepf2tNxv25YDXBhkpO8IsKw,3047
+KratosMultiphysics/OptimizationApplication/analyses_controller.py,sha256=cEjXryoRcAQwl1yV84yLsyg4j73oTEwKtD4kcivNDAI,4130
+KratosMultiphysics/OptimizationApplication/controls_controller.py,sha256=6tAwdVHgWBztpvc0UsHieNUHp-OEZ0m8zGusN4SKUrA,12333
+KratosMultiphysics/OptimizationApplication/optimization_analysis.py,sha256=g61VHDXaFiGoMqUZjYD7aXxmhWZIhrZwCmpTnbM-k20,7779
+KratosMultiphysics/OptimizationApplication/execution_policies/stepping_analysis_execution_policy.py,sha256=48tCRwBVEgWPpXr8V1hrSGDHqfD_0gtGuWSguDrl6mw,4103
+KratosMultiphysics/OptimizationApplication/execution_policies/kratos_analysis_execution_policy.py,sha256=4ZiB2f5gFT2FZKKB9QtKjSE_ZjCq-oD_ktcdGBfbQHE,8704
+KratosMultiphysics/OptimizationApplication/execution_policies/independent_analysis_execution_policy.py,sha256=kUdIy4p_QA3nMdlyvcac9nN8pla-oGIy20tgg1MMHpk,4112
+KratosMultiphysics/OptimizationApplication/execution_policies/execution_policy.py,sha256=Yx0cizsjrhyzPO4epxmYK9pk-RoY5FmhEF427zsDwAM,1199
+KratosMultiphysics/OptimizationApplication/execution_policies/execution_policy_decorator.py,sha256=e4ySkOiyqmWt6V4vJqetjJ4vsQJmQon3FwwOa2JGnzw,3279
+KratosMultiphysics/OptimizationApplication/filtering/implicit_filter.py,sha256=Zs4Amcghb17A7s7iABHZmFGm5XqZPj7lt9zCVge2hzA,10897
+KratosMultiphysics/OptimizationApplication/filtering/filter_utils.py,sha256=oCtZd7JWqNV_1uIdkwWl7wNCbNR_qei5tEQ9hDia-FY,3841
+KratosMultiphysics/OptimizationApplication/filtering/helmholtz_solver_base.py,sha256=tSjb4w1gUufSCCVAkerYBdpkYWyZaL5cWP2R9oNsK6s,12404
+KratosMultiphysics/OptimizationApplication/filtering/python_solvers_wrapper_implicit_filters.py,sha256=EikpXp3mMQY9QpGSSKRbTx2xxNyB_m4tYOoBRD_t3Dc,2809
+KratosMultiphysics/OptimizationApplication/filtering/helmholtz_analysis.py,sha256=b2ZJ3g52pkW9E2JDA_JkbjAXTK4rkULL9ZbqWqsYcdo,7624
+KratosMultiphysics/OptimizationApplication/filtering/helmholtz_shape_solver.py,sha256=7mSwooWqFdSTLnYV4wNoMdUqlKbC0Lv4-tIBj-IFZm8,3995
+KratosMultiphysics/OptimizationApplication/filtering/helmholtz_scalar_solver.py,sha256=YvZlonJsSl-TRawWsXvrBUE6lyzp9BEsV9D3vYJ45NM,2326
+KratosMultiphysics/OptimizationApplication/filtering/filter.py,sha256=7huM4Qc04Mf2LeoU5HoXKX95KwftFpGa3Eg_9W1fYfY,7908
+KratosMultiphysics/OptimizationApplication/filtering/explicit_filter.py,sha256=XIUU8e6uETH_utno6qucY5k547x0Z-T80ISnW9pu-WI,7156
+KratosMultiphysics/OptimizationApplication/filtering/helmholtz_vector_solver.py,sha256=3DXT4sHcGgtDPLATQRJre21IEWGW10_j3YZzofUWyuo,2346
+KratosMultiphysics/OptimizationApplication/processes/optimization_problem_hdf5_output_process.py,sha256=J2nbKevM6eL_gxvpr7bKKJvOBqvBF-iYoDempcbc8rc,5150
+KratosMultiphysics/OptimizationApplication/processes/optimization_problem_vtu_output_process.py,sha256=ckiwLyduSpHNAFzLefHZVIBYl33eOoooq0aM4PhOf2w,5540
+KratosMultiphysics/OptimizationApplication/processes/optimization_problem_field_output_process.py,sha256=I0iG25ZBj3n6_ClTFNDbdE3TmT2lmxO1s8DndppzEgA,6499
+KratosMultiphysics/OptimizationApplication/processes/spatial_statistics_computation_process.py,sha256=EjcyUHlVxVLwJWz6ZtPo2KL-TFL6FKJg9JgQE0A32jY,4625
+KratosMultiphysics/OptimizationApplication/processes/optimization_problem_graph_output_process.py,sha256=wWGaHHGpxogOjKybBOtYiSEsOYpz-zMjg3ZfR5JI3tw,8628
+KratosMultiphysics/OptimizationApplication/processes/optimization_problem_ascii_output_process.py,sha256=SeiPTERz2GekC4XbdNSYq40Err4Tma8jsukHTtzbP8c,10788
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_relaxed_gradient_projection.py,sha256=98BwATZT4N9JfHYlDn_aG9f3k5j4tpQSwT8Gw3GlGfM,14754
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_base.py,sha256=iNsOlNWc-W2OMQSnAh1PpdOXNvUymOTEHzdSRMQ-jH0,23776
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm.py,sha256=a4yy8qaa2obtEkM9u4xQwFr27yQUXWcn9sLstg4-J8c,3185
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_objective.py,sha256=nh0u8KmjskJYhKe40ml1iLGCXUeVAHX4O_YaRrUNMHk,7166
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_rgp_constraint.py,sha256=HT6ozzBaS9LtYaYBiZxdAkD7x3iasoZ_VUBKmHJvrnE,12271
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_adam.py,sha256=2jobZGfFO-yng4JLqID2ji0IBEB4anLbGNP45rUffUs,3810
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_NLOPT_objective.py,sha256=xHBwUEuliW9XY56Ziefoeerzr4b7zIT3KtYXjd8hv8M,10254
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_gradient_projection.py,sha256=q0iWyLOFqu2lgXZkZIuEc_pJ_RDqXg-NvUbR_sSznxY,19092
+KratosMultiphysics/OptimizationApplication/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_nesterov_accelarated_gradient.py,sha256=-QWaw5c9oJG1D7cZjBHT39cUlggsVo6SFdCueo5cy-U,3498
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_SciPy_constraint.py,sha256=WpyQnonrKe3gCD8Fp9MSzcdfvDYLG9IfkABam-VZnSY,6410
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_SciPy_objective.py,sha256=5hHPASA6suAspqEhxQGISK1CWXusYOMCsPWRxNoZP2E,7614
+KratosMultiphysics/OptimizationApplication/algorithms/SciPy_algorithms.py,sha256=zggMCiPuIZMbhNZRFaHXkpsv2pzNhyF3Aat-fFXbKiA,7958
+KratosMultiphysics/OptimizationApplication/algorithms/NLOPT_algorithms.py,sha256=AZsEhx_88_-0l1_8XRd3rLidNsfxxaL4XmoGKdne2BM,13735
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_NLOPT_constraint.py,sha256=feKdS_nPEfbBeV35w3H21jii_ds89NURcBXGeu3SUUc,9943
+KratosMultiphysics/OptimizationApplication/algorithms/standardized_constraint.py,sha256=_gF0TRIn-cEeBNmcckEYZktUyY3QRGZjjqm2t3RA-2w,9923
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_steepest_descent.py,sha256=-36WI06vtXyAnpLIdtRRHD119AbNRosLRaQM0aMNFbA,9986
+KratosMultiphysics/OptimizationApplication/algorithms/algorithm_momentum_relaxed_gradient_projection.py,sha256=2tXR5k7caJ2JH15jFcX81wl31Brp6ry88hpRE5M-ayE,3708
+KratosMultiphysics/OptimizationApplication/responses/discrete_value_residual_response_function.py,sha256=aFeBTP4l1YM8rkMDDhqJK_bX8e-j__BhhKm8_7iMFUY,7386
+KratosMultiphysics/OptimizationApplication/responses/additive_manufacturing_responses.py,sha256=h8qED3ZW2wnjqEqembbM3-Y1TbCOyy9hVqr9xl-DWL8,21998
+KratosMultiphysics/OptimizationApplication/responses/log_response_function.py,sha256=Zq3iHObOrFW3ru6l3ksgacv4OfjMI8dJhbIhgAW1oHM,2560
+KratosMultiphysics/OptimizationApplication/responses/combined_response_function.py,sha256=JAG0YghYtPKeF5-WFefs4g8nEj5wc-ISp_lYSV__guA,7419
+KratosMultiphysics/OptimizationApplication/responses/external_response_function.py,sha256=33FbW-aDLL0y-cpFKqLMnGyK_bwi0t9ozyWE3FBWjZk,5025
+KratosMultiphysics/OptimizationApplication/responses/base_response.py,sha256=j6teLfHvSdEO2p467B_WOvM55etTJDZ-wimVZ4Rd3j0,3286
+KratosMultiphysics/OptimizationApplication/responses/analysis_free_response_function_factory.py,sha256=qIgpe-ydBinfepefE-xS2np4uXcZy6BnClXY90xN8OM,807
+KratosMultiphysics/OptimizationApplication/responses/response_routine.py,sha256=NgbX7a2392j03s0QBRZfDuOtAhUSYzg1pFeAiKHTLbs,7796
+KratosMultiphysics/OptimizationApplication/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+KratosMultiphysics/OptimizationApplication/responses/structural_responses.py,sha256=psUWT97axOgjcgI8rfF2fvp2neFKXLvlYHgbYmTaa6w,18372
+KratosMultiphysics/OptimizationApplication/responses/response_function.py,sha256=sr9y4l8P1ukyTDHFkPMbuAEOB1i_39MVQNnM4Kx1ivA,5527
+KratosMultiphysics/OptimizationApplication/responses/linear_strain_energy_response_function.py,sha256=v376yiLdyPSiZXFBgo1Fj0raC2su57xP0iGTGNH6o-o,4102
+KratosMultiphysics/OptimizationApplication/responses/evaluation_response_function.py,sha256=_NzxVGoPKdMqic_zuNveAuuZdFZnvkFSGRWkxkHD7CQ,3592
+KratosMultiphysics/OptimizationApplication/responses/literal_value_response_function.py,sha256=5iI2JNDcoc5erzGP28E-3-loO687xmQv3ALHUNrTj5s,1288
+KratosMultiphysics/OptimizationApplication/responses/geometric_centroid_deviation_response_function.py,sha256=FVc2jRziSw9ndN3NXJ16oXrP6_ob0gvZ3v6Vt_H5Z04,5413
+KratosMultiphysics/OptimizationApplication/responses/analysis_based_response_function_factory.py,sha256=QeRc-L6hQUhe7J8WO50yc2P9q_iVYvQMOrlpHPzGljs,725
+KratosMultiphysics/OptimizationApplication/responses/binary_operator_response_function.py,sha256=xlLirigV9lQfm3ZczHugbfo1n2dDdqaItFN9QhqIMjI,6388
+KratosMultiphysics/OptimizationApplication/responses/mass_response_function.py,sha256=5PXK0d5YF2CKO1PkYCkyz1XN23WRMEqgCcOwUavJwao,3590
+KratosMultiphysics/OptimizationApplication/model_part_controllers/external_response_function_model_part_controller.py,sha256=dpSheyrVTWXZ71Qx3Mq1b8xS3BnpdkACH4_q_7dOMJg,5586
+KratosMultiphysics/OptimizationApplication/model_part_controllers/connectivity_preserving_model_part_controller.py,sha256=eOmDzCW55_bem4pzLd7py5vTSXPvXsRAFpAmkssMnCo,5018
+KratosMultiphysics/OptimizationApplication/model_part_controllers/model_part_controller.py,sha256=9wtXqPKKtP5yrx1cv1lqBmn3j3S18hd0qMDz7YID4bU,355
+KratosMultiphysics/OptimizationApplication/model_part_controllers/mdpa_model_part_controller.py,sha256=b6P_yJRci7P-TJrMM7HYgzCxK4GWGsbcZ-Mha-8MIgY,2190
+KratosMultiphysics/OptimizationApplication/controls/external_response_function_control.py,sha256=M_DD7aUGgZk5Ol0mF6p_Yc7mtaZwOKfH5Ok_6wM1rNI,8568
+KratosMultiphysics/OptimizationApplication/controls/control.py,sha256=tE4-hEMM4-lkP0_YVok4UKVaTykVBuu3OEvbt79Befc,5246
+KratosMultiphysics/OptimizationApplication/controls/master_control.py,sha256=_WiJHxCXwudysXVtJTMMW-WE5vH7PxeY-rUFKuw70lY,11495
+KratosMultiphysics/OptimizationApplication/controls/shape/vertex_morphing_shape_control.py,sha256=2fbasRliGsy1YUz3fdmll7jnAaTJ3L7Mg8KoaZ3fv08,18223
+KratosMultiphysics/OptimizationApplication/controls/thickness/shell_thickness_control.py,sha256=0HZP9MgR753HuilVpkq4V9ejs-dMRymyz4OHE5BHJUY,11056
+KratosMultiphysics/OptimizationApplication/controls/material/material_properties_control.py,sha256=vnYvZwz1XCpR0Br_ACx0M-8slBAhIFIPH-CgAHzTDhg,6848
+KratosMultiphysics/OptimizationApplication/controls/material/simp_control.py,sha256=nILM4_rxz-6pZQ5Q8O6JyHOO7Mg3TLWk-vXqf_rg09w,13016
+KratosMultiphysics/OptimizationApplication/utilities/response_utilities.py,sha256=_WXe-c6-a_tFmcJKdgQSuTBTNRw7ovD5XV-B_QQymgs,14433
+KratosMultiphysics/OptimizationApplication/utilities/optimization_problem_utilities.py,sha256=KuaVJrgt6sYUIEpvFqeobHlfiHoWs_MBUULHdntPsNc,14927
+KratosMultiphysics/OptimizationApplication/utilities/union_utilities.py,sha256=Tp--h4P9qgErPuLtKEFcEWxRtTV_00evsNs3islFJYc,246
+KratosMultiphysics/OptimizationApplication/utilities/optimization_problem.py,sha256=NkeeodKiYuKfJ8jGxdzX2_eJZwtXicDZioqmDfcY0AU,11574
+KratosMultiphysics/OptimizationApplication/utilities/opt_projection.py,sha256=3N19ARVSDPUrM_GCIVu9HL6jHeQXRlXzDcy6oUzu2F4,9189
+KratosMultiphysics/OptimizationApplication/utilities/timer.py,sha256=pqCxshFQUeNhGEktJKYBrLRXylpkEG1QOjESt98SUbo,1724
+KratosMultiphysics/OptimizationApplication/utilities/opt_line_search.py,sha256=7LIUer8Utqybar8a_YvUcfk2ITPsCTOUP8cgiU7eXlk,8243
+KratosMultiphysics/OptimizationApplication/utilities/component_data_view.py,sha256=PBNjYWbs57j14MwjyaQfntidqcagWl0ae50hvFLgv88,3463
+KratosMultiphysics/OptimizationApplication/utilities/logger_utilities.py,sha256=gK-9W-FS02MfEXnHMaQDHEWZYGw5IY7CxtgVPr9_o2s,8588
+KratosMultiphysics/OptimizationApplication/utilities/buffered_dict.py,sha256=gsrLcSeW8vCZnaE-f0lTG-EPcX_2noqcbp_HPfeIOW8,18145
+KratosMultiphysics/OptimizationApplication/utilities/model_part_utilities.py,sha256=mhzAS0WP9_MfuDKoApxK3nrpSEhbOZ1K6_9qSAMxLb8,7835
+KratosMultiphysics/OptimizationApplication/utilities/helper_utilities.py,sha256=HZEO2nLGEe5abeyaM3m0TQg7LfjqpHC9UsCuj2qXRtI,1867
+KratosMultiphysics/OptimizationApplication/convergence_criteria/magnitude_reduction_conv_criterion.py,sha256=GbDiYs8knO8se-ebIojVUMZIRovHjQ60rV5QqDMQb7E,4652
+KratosMultiphysics/OptimizationApplication/convergence_criteria/target_value_conv_criterion.py,sha256=S8PY_4xfB08WSH5fzPnnkPcPn-dj149Bm7AjqJ0BtJE,3420
+KratosMultiphysics/OptimizationApplication/convergence_criteria/patience_conv_criterion.py,sha256=c235T6uXuVND1mI-yAHiN8kMJBtmDPHdyOZynQ40GkM,6108
+KratosMultiphysics/OptimizationApplication/convergence_criteria/avg_abs_improvement_conv_criterion.py,sha256=9GWK5DNelnYSdWftX4cFqPlh7nCYZiEnQpUdflwoqrc,5059
+KratosMultiphysics/OptimizationApplication/convergence_criteria/l2_conv_criterion.py,sha256=2xZZQxsxUR3bfmxMlTALXVnAHkQnlWarY3Ye_XDYOws,4115
+KratosMultiphysics/OptimizationApplication/convergence_criteria/constraint_conv_criterion.py,sha256=hbmZM9DwzKnpTJ3q8hbmPy3Y2mCeUWGQDRrRYbXz6E4,3516
+KratosMultiphysics/OptimizationApplication/convergence_criteria/max_iter_conv_criterion.py,sha256=9dI_Gfd1Ac0rTArrn1jOf0E5YfoXYXBWN3foRaFNxco,2090
+KratosMultiphysics/OptimizationApplication/convergence_criteria/convergence_criterion.py,sha256=V2Tt8qDPG64ZJnxpnHp9y1BZxsCpSO3hm8Yp1r1NNec,686
+KratosMultiphysics/OptimizationApplication/convergence_criteria/combined_conv_criterion.py,sha256=WvD5Mu1Q1jznGJloEav-m3OULD5WO-udI0DD3lDDmf8,4198
+KratosMultiphysics/.libs/libKratosOptimizationCore.dylib,sha256=IDenpH-IsEsWJzHMi1fe_NEdiZFAuFwns0qAxFJtUI8,9615712
+KratosMultiphysics/.libs/KratosOptimizationApplication.so,sha256=wj4zByWAYH4ZgY_fmMGY42FNmkpzYn-cT3CQTPXDFU0,3545296
+kratosoptimizationapplication.dylibs/libstdc++.6.dylib,sha256=UBC8pEzZeJ8SX8NP4S0fmEoPSoD-ATlEkYKn1lE1oao,3403264
+kratosoptimizationapplication.dylibs/libKratosCore.dylib,sha256=Mz0PnN4WSdvlN8yh4PP_8smVlOup8tgcC_gcLKJVYes,63629792
+kratosoptimizationapplication.dylibs/libgcc_s.1.1.dylib,sha256=fpfFgLpcOF0UncBU_FcuHCon2OBULeoTde2MpWjflFk,219232
+kratosoptimizationapplication.dylibs/libgomp.1.dylib,sha256=D51-J5ZMfdwkdGXB-bAeBcBB7SgnynnqnM1gwISndz4,438880
+kratosoptimizationapplication-10.4.4.dist-info/RECORD,,
+kratosoptimizationapplication-10.4.4.dist-info/WHEEL,sha256=QX0UaoWXQIAv8vp5R3do793urekDoJdJRoGCk8nXIBY,115
+kratosoptimizationapplication-10.4.4.dist-info/METADATA,sha256=FaRtLu3Y_yQAa17XqEMVgNQxAWHDN97cs1TUndTSHPk,1677

kratosoptimizationapplication-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
+

kratosoptimizationapplication.dylibs/libKratosCore.dylib

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