KratosSystemIdentificationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/SystemIdentificationApplication/utilities/data_utils.py

@@ -0,0 +1,67 @@
+import typing
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+
+SupportedVariableUnionType = typing.Union[
+                                    Kratos.BoolVariable,
+                                    Kratos.IntegerVariable,
+                                    Kratos.DoubleVariable,
+                                    Kratos.StringVariable,
+                                    Kratos.Array1DVariable3,
+                                    Kratos.Array1DVariable4,
+                                    Kratos.Array1DVariable6,
+                                    Kratos.Array1DVariable9,
+                                    Kratos.VectorVariable
+                                ]
+
+SupportedValueUnionType = typing.Union[
+                                    bool,
+                                    int,
+                                    float,
+                                    str,
+                                    Kratos.Array3,
+                                    Kratos.Array4,
+                                    Kratos.Array6,
+                                    Kratos.Array9,
+                                    Kratos.Vector
+                                ]
+
+
+def GetNameToCSVString(name: str, kratos_value: SupportedValueUnionType) -> str:
+    if type(kratos_value) in [bool, int, float, str]:
+        return name
+    elif type(kratos_value) in [Kratos.Array3, Kratos.Array4, Kratos.Array6, Kratos.Array9, Kratos.Vector]:
+        return ",".join([f"{name}_{i}" for i in range(kratos_value.Size())])
+    else:
+        raise RuntimeError(f"Unsupported kratos_value type = {type(kratos_value)} with name = {name} and kratos_value = {kratos_value}.")
+
+def GetKratosValueToPythonValueConverter(kratos_value: SupportedValueUnionType) -> 'typing.Callable[[SupportedValueUnionType], typing.Union[bool, int, float, str, list[float]]]':
+    if type(kratos_value) in [bool, int, float, str]:
+        return lambda x: x
+    elif type(kratos_value) in [Kratos.Array3, Kratos.Array4, Kratos.Array6, Kratos.Array9, Kratos.Vector]:
+        return lambda x: [v for v in x]
+    else:
+        raise RuntimeError(f"Unsupported kratos_value type = {type(kratos_value)} with kratos_value = {kratos_value}.")
+
+def GetKratosValueToCSVStringConverter(kratos_value: SupportedValueUnionType) -> 'typing.Callable[[SupportedValueUnionType], str]':
+    if type(kratos_value) in [bool, int, float, str]:
+        return lambda x: str(x)
+    elif type(kratos_value) in [Kratos.Array3, Kratos.Array4, Kratos.Array6, Kratos.Array9, Kratos.Vector]:
+        return lambda x: ",".join([str(v) for v in x])
+    else:
+        raise RuntimeError(f"Unsupported kratos_value type = {type(kratos_value)} with kratos_value = {kratos_value}.")
+
+def GetParameterToKratosValuesConverter(params: Kratos.Parameters) -> 'typing.Callable[[Kratos.Parameters], SupportedValueUnionType]':
+    if params.IsVector():
+        return lambda x: x.GetVector()
+    elif params.IsBool():
+        return lambda x: x.GetBool()
+    elif params.IsInt():
+        return lambda x: x.GetInt()
+    elif params.IsDouble():
+        return lambda x: x.GetDouble()
+    elif params.IsString():
+        return lambda x: x.GetString()
+    else:
+        raise RuntimeError(f"Unsupported parameters type = {params}.")

KratosMultiphysics/SystemIdentificationApplication/utilities/sensor_utils.py

@@ -0,0 +1,196 @@
+import typing
+from pathlib import Path
+import math, numpy
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+from KratosMultiphysics.SystemIdentificationApplication.utilities.data_utils import SupportedValueUnionType
+from KratosMultiphysics.SystemIdentificationApplication.utilities.data_utils import SupportedVariableUnionType
+from KratosMultiphysics.SystemIdentificationApplication.utilities.data_utils import GetParameterToKratosValuesConverter
+from KratosMultiphysics.SystemIdentificationApplication.utilities.data_utils import GetKratosValueToCSVStringConverter
+from KratosMultiphysics.SystemIdentificationApplication.utilities.data_utils import GetNameToCSVString
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+def CreateSensors(sensor_model_part: Kratos.ModelPart, domain_model_part: Kratos.ModelPart, list_of_parameters: 'list[Kratos.Parameters]') -> 'list[KratosSI.Sensors.Sensor]':
+    """Create list of sensors from given parameters.
+
+    This creates a list of sensors from given list of parameters. Each parameter
+    corresponds to one settings set for one sensor.
+
+    Args:
+        sensor_model_part (Kratos.ModelPart): Model part to which the sensors will be stored.
+        domain_model_part (Kratos.ModelPart): Model part on which the sensors will be located.
+        list_of_parameters (list[Kratos.Parameters]): List of parameters.
+
+    Returns:
+        list[KratosSI.Sensors.Sensor]: List of sensors generated.
+    """
+    if sensor_model_part.NumberOfNodes() != 0:
+        raise RuntimeError(f"The sensor model part \"{sensor_model_part.FullName()}\" is not empty.")
+
+    dict_of_sensor_types: 'dict[str, typing.Type[KratosSI.Sensors.Sensor]]' = {}
+    for sensor_type_name in dir(KratosSI.Sensors):
+        sensor_type = getattr(KratosSI.Sensors, sensor_type_name)
+        try:
+            if issubclass(sensor_type, KratosSI.Sensors.Sensor) and hasattr(sensor_type, "Create"):
+                dict_of_sensor_types[Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(sensor_type_name)] = sensor_type
+        except:
+            pass
+
+    list_of_sensors: 'list[KratosSI.Sensors.Sensor]' = []
+    for parameters in list_of_parameters:
+        if not parameters.Has("type"):
+            raise RuntimeError(f"The sensor parameters does not contain \"type\".")
+        sensor_type_name = parameters["type"].GetString()
+
+        if not sensor_type_name in dict_of_sensor_types.keys():
+            raise RuntimeError(f"Unsupported sensor type = \"{sensor_type_name}\" requested. Followings are supported:\n\t" + "\n\t".join(dict_of_sensor_types.keys()))
+
+        sensor: KratosSI.Sensors.Sensor = dict_of_sensor_types[sensor_type_name].Create(domain_model_part, sensor_model_part, len(list_of_sensors) + 1, parameters)
+        list_of_sensors.append(sensor)
+
+    return list_of_sensors
+
+def PrintSensorListToCSV(output_file_name: Path, list_of_sensors: 'list[KratosSI.Sensors.Sensor]', list_of_sensor_properties: 'list[str]') -> None:
+    """Writes data in the list_of_sensors to CSV file.
+
+    This method writes data from all the list_of_sensors to the CSV file. The columns of the
+    CSV is determined by list_of_sensor_properties.
+
+    Args:
+        output_file_name (Path): CSV file name (including the .csv extension).
+        list_of_sensors (list[Sensor]): List of sensors.
+        list_of_sensor_properties (list[str]): List of columns to write.
+    """
+    number_of_sensor_views = len(list_of_sensors)
+
+    # do nothing if number of clusters is zero
+    if number_of_sensor_views == 0:
+        return
+
+    # create output path
+    output_file_name.parent.mkdir(exist_ok=True, parents=True)
+
+    with open(str(output_file_name), "w") as file_output:
+        # print the headers
+        first_sensor = list_of_sensors[0]
+
+        # write the csv id
+        file_output.write("index")
+
+        # store converters to CSV in dicts
+        params_value_dict: 'dict[str, typing.Callable[[Kratos.Parameters], str]]' = {}
+        params_str_dict: 'dict[str, typing.Callable[[SupportedValueUnionType], str]]' = {}
+        data_value_dict: 'dict[SupportedVariableUnionType, typing.Callable[[SupportedValueUnionType], str]]' = {}
+
+        dummy_params = first_sensor.GetSensorParameters()
+        list_of_params_keys: 'list[str]' = []
+        list_of_data_keys: 'list[SupportedVariableUnionType]' = []
+        param_property_headers = ""
+        value_property_headers = ""
+        for sensor_property in list_of_sensor_properties:
+            if dummy_params.Has(sensor_property):
+                list_of_params_keys.append(sensor_property)
+                value_func = GetParameterToKratosValuesConverter(dummy_params[sensor_property])
+                value = value_func(dummy_params[sensor_property])
+                params_value_dict[sensor_property] = value_func
+                params_str_dict[sensor_property] = GetKratosValueToCSVStringConverter(value)
+                param_property_headers += f",{GetNameToCSVString(sensor_property, value)}"
+            else:
+                var = Kratos.KratosGlobals.GetVariable(sensor_property)
+                if first_sensor.Has(var):
+                    list_of_data_keys.append(var)
+                    value = first_sensor.GetValue(var)
+                    data_value_dict[var] = GetKratosValueToCSVStringConverter(value)
+                    value_property_headers += f",{GetNameToCSVString(sensor_property, value)}"
+                else:
+                    raise RuntimeError(f"Sensor property = \"{sensor_property}\" not found in either sensor parameters nor in data value container. [ Sensor = {first_sensor} ].")
+
+        file_output.write(f"{param_property_headers}{value_property_headers}\n")
+
+        for i, sensor in enumerate(list_of_sensors):
+            # write the id
+            file_output.write(f"{i+1}")
+
+            # first write the values from sensor params
+            sensor_params = sensor.GetSensorParameters()
+            for sensor_property in list_of_params_keys:
+                file_output.write(f",{params_str_dict[sensor_property](params_value_dict[sensor_property](sensor_params[sensor_property]))}")
+
+            # now write the data values from sensor
+            for var in list_of_data_keys:
+                file_output.write(f",{data_value_dict[var](sensor.GetValue(var))}")
+
+            file_output.write("\n")
+
+def AddSensorVariableData(sensor: KratosSI.Sensors.Sensor, variable_data: Kratos.Parameters) -> None:
+    """Adds sensor variable data.
+
+    Args:
+        sensor (KratosSI.Sensors.Sensor): Sensor to add data.
+        variable_data (Kratos.Parameters): Parameters containing variable data.
+    """
+    for var_name, var_value in variable_data.items():
+        var = Kratos.KratosGlobals.GetVariable(var_name)
+        value_func =  GetParameterToKratosValuesConverter(var_value)
+        sensor.GetNode().SetValue(var, value_func(var_value))
+
+def SetSensors(sensor_group_data: ComponentDataView, list_of_sensors: 'list[KratosSI.Sensors.Sensor]') -> None:
+    for sensor in list_of_sensors:
+        sensor_group_data.GetUnBufferedData().SetValue(f"list_of_sensors/{sensor.GetName()}/sensor", sensor)
+
+def GetSensors(sensor_group_data: ComponentDataView) -> 'list[KratosSI.Sensors.Sensor]':
+    list_of_sensors: 'list[KratosSI.Sensors.Sensor]' = []
+    for _, sensor_data in sensor_group_data.GetUnBufferedData().GetValue("list_of_sensors").GetSubItems().items():
+        list_of_sensors.append(sensor_data.GetValue("sensor"))
+    return list_of_sensors
+
+def GetMaskStatusControllers(sensor_group_data: ComponentDataView, sensor_mask_name: str) -> 'list[typing.Any]':
+    if sensor_group_data.GetUnBufferedData().HasValue(f"mask_status_controllers/{sensor_mask_name}"):
+        return sensor_group_data.GetUnBufferedData().GetValue(f"mask_status_controllers/{sensor_mask_name}")
+    else:
+        return []
+
+def AddMaskStatusController(sensor_group_data: ComponentDataView, sensor_mask_name: str, mask_status_controller: typing.Any) -> None:
+    if not hasattr(mask_status_controller, "Update"):
+        raise RuntimeError(f"The mask status controller {mask_status_controller} does not have an Update method.")
+
+    if not sensor_group_data.GetUnBufferedData().HasValue(f"mask_status_controllers/{sensor_mask_name}"):
+        sensor_group_data.GetUnBufferedData()[f"mask_status_controllers/{sensor_mask_name}"] = []
+
+    sensor_group_data.GetUnBufferedData()[f"mask_status_controllers/{sensor_mask_name}"].append(mask_status_controller)
+
+def SetSensorNormalizationFactor(list_of_sensors: 'list[KratosSI.Sensors.Sensor]', sensor_normalization_settings: Kratos.Parameters) -> None:
+    sensor_normalization_type = sensor_normalization_settings["type"].GetString()
+
+    measured_values = numpy.array([sensor.GetNode().GetValue(KratosSI.SENSOR_MEASURED_VALUE) for sensor in list_of_sensors], dtype=numpy.float64)
+
+    def local_maximum_measured_value(x: numpy.ndarray, parameters: Kratos.Parameters) -> numpy.ndarray:
+        if not parameters.Has("epsilon"):
+            raise RuntimeError(f"""The sensor normalization settings for type \"local_maximum_measured_value\"
+                                must have an \"epsilon\" value.""")
+        if parameters["epsilon"].GetDouble() < 0.0:
+            raise RuntimeError(f"""The sensor normalization settings for type \"local_maximum_measured_value\"
+                                must have a non-negative \"epsilon\" value.""")
+        epsilon = parameters["epsilon"].GetDouble()
+        max_measured_value = numpy.max(numpy.abs(x))
+        return numpy.maximum(numpy.abs(x), epsilon * max_measured_value)
+
+    normalization_dict = {
+        ""                            : lambda x, _: numpy.ones(x.shape, dtype=numpy.float64),
+        "none"                        : lambda x, _: numpy.ones(x.shape, dtype=numpy.float64),
+        "maximum_measured_value"      : lambda x, _: numpy.max(numpy.abs(x)) * numpy.ones(x.shape, dtype=numpy.float64),
+        "average_measured_value"      : lambda x, _: numpy.average(numpy.abs(x)) * numpy.ones(x.shape, dtype=numpy.float64),
+        "local_measured_value"        : lambda x, _: numpy.abs(x),
+        "local_maximum_measured_value": local_maximum_measured_value
+    }
+
+    if sensor_normalization_type not in normalization_dict:
+        raise RuntimeError(f"Unsupported sensor normalization type \"{sensor_normalization_type}\". Supported types are:\n\t" + "\n\t".join(normalization_dict.keys()))
+
+    normalization_factors = normalization_dict[sensor_normalization_type](measured_values, sensor_normalization_settings)
+    for i, sensor in enumerate(list_of_sensors):
+        if math.isclose(normalization_factors[i], 0.0, abs_tol=1e-16):
+            raise RuntimeError(f"The normalization factor for sensor \"{sensor.GetName()}\" is approximately zero ({normalization_factors[i]}). Cannot normalize.")
+        sensor.GetNode().SetValue(KratosSI.SENSOR_NORMALIZATION_FACTOR, normalization_factors[i])

KratosMultiphysics/SystemIdentificationApplication/utilities/tensor_adaptor_utils.py

@@ -0,0 +1,63 @@
+import typing
+from enum import Enum
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+
+class PropertiesDataLocation(Enum):
+    ElementProperties = 100
+    ConditionProperties = 200
+
+class TensorAdaptorDataLocation(Kratos.Globals.DataLocation):
+    ElementProperties = PropertiesDataLocation.ElementProperties,
+    ConditionProperties = PropertiesDataLocation.ConditionProperties
+
+def GetTensorAdaptor(model_part: Kratos.ModelPart, data_location: TensorAdaptorDataLocation, variable: typing.Any) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+    if data_location == TensorAdaptorDataLocation.NodeHistorical:
+        ta = Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(model_part.Nodes, variable)
+    elif data_location == TensorAdaptorDataLocation.NodeNonHistorical:
+        ta = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Nodes, variable)
+    elif data_location == TensorAdaptorDataLocation.Condition:
+        ta = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Conditions, variable)
+    elif data_location == TensorAdaptorDataLocation.Element:
+        ta = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Elements, variable)
+    elif data_location == TensorAdaptorDataLocation.ConditionProperties:
+        ta = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Conditions, variable)
+    elif data_location == TensorAdaptorDataLocation.ElementProperties:
+        ta = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Elements, variable)
+    else:
+        raise RuntimeError(f"Unsupported {data_location}.")
+
+    ta.CollectData()
+    return ta
+
+class TensorAdaptorBoundingManager:
+    def __init__(self, bounds: 'list[float]') -> None:
+        """
+        This class is used to bound values of an tensor adaptor to specified interval.
+            If a value in an tensor adaptor is above the max value of bounds, then it will have a value larger than 1.0
+            if a value in an tensor adaptor is below the min value of bounds, then it will have a value smaller than 0.0
+            Values in an tensor adaptor will be linearly interpolated and mapped from interval [min(bounds), max(bounds)]
+            to [0, 1].
+
+        Args:
+            bounds (list[float]): Bounds of the given tensor adaptor values.
+
+        Raises:
+            RuntimeError: If bounds does not contain two values.
+        """
+        if len(bounds) != 2:
+            raise RuntimeError(f"The bounds should be of size 2. [bounds = {bounds}]")
+        self.bounds = sorted(bounds)
+
+    def GetBoundGap(self) -> float:
+        return self.bounds[1] - self.bounds[0]
+
+    def GetBoundedTensorAdaptor(self, unbounded_tensor_adaptor: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        result = unbounded_tensor_adaptor.Clone()
+        result.data[:] = (result.data[:] - self.bounds[0]) / self.GetBoundGap()
+        return result
+
+    def GetUnboundedTensorAdaptor(self, bounded_tensor_adaptor: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        result = bounded_tensor_adaptor.Clone()
+        result.data[:] = (result.data[:] * self.GetBoundGap() + self.bounds[0])
+        return result

kratossystemidentificationapplication-10.4.4.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.5
+Name: KratosSystemIdentificationApplication
+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

kratossystemidentificationapplication-10.4.4.dist-info/RECORD

@@ -0,0 +1,27 @@
+KratosMultiphysics/SystemIdentificationApplication/python_registry_lists.py,sha256=JdbRUeLb0ChurxYgeZzWSFyEK5_aYre1I_doPu-908E,199
+KratosMultiphysics/SystemIdentificationApplication/__init__.py,sha256=YQN6PirfZXlOipE9lNXVFs0op-fUVRHbPse2zEQWeR4,745
+KratosMultiphysics/SystemIdentificationApplication/sensor_generator_analysis.py,sha256=m6W836uU7f0xAgR4wXj5DRBG5wdhdKdol90Y5O03KUs,6648
+KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/response_sensitivity_interface.py,sha256=DeE_gvQb6xgClUhB7G5_JNqbbdTOlsZFbYR9pcCJfOA,1237
+KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/response_sensitivity_analysis.py,sha256=YURa3anPD97X34AyNnEfE93HS-CND3Cvf7keulARe3A,2041
+KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/system_identification_static_analysis.py,sha256=6Wu335UM6fs5xW5P_at4JcoVg9uu2QiGd35DZHwUGM8,2697
+KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/sensor_sensitivity_adjoint_static_solver.py,sha256=gEYSOEaYxQ_skGJ9j-y_2Fzn94-BCx0WtgM9HR6w5bM,2843
+KratosMultiphysics/SystemIdentificationApplication/processes/sensor_output_process.py,sha256=2eoijTmEUIyG4OSzm5DyR2oiuSpJLldcVEjXO5n1o5A,4202
+KratosMultiphysics/SystemIdentificationApplication/responses/temperature_detection_response.py,sha256=fHRWaGsQbWb_-XeLg7naEbf3W6K0AuufCxPNxLl3i3U,1384
+KratosMultiphysics/SystemIdentificationApplication/responses/damage_detection_response.py,sha256=yg_01Ib_hK9wThRFQX7L_jc3R-sb9GxvgBXKM6mV4kY,11240
+KratosMultiphysics/SystemIdentificationApplication/responses/pressure_detection_response.py,sha256=d2lCFGs6o-s-6x4Gag4lfRZgc7qoOTQQPe-PUI9jBP0,1366
+KratosMultiphysics/SystemIdentificationApplication/controls/material_properties_control.py,sha256=UWl5eI3yPTsD0paxgjNPSB6EfOY2brY6kzHB6WbXGSo,13765
+KratosMultiphysics/SystemIdentificationApplication/controls/data_values_control.py,sha256=6JQJcsES2Dp-Wp4AVYM_NqMwGN8UdDlu3v70cbTPpSs,12905
+KratosMultiphysics/SystemIdentificationApplication/utilities/tensor_adaptor_utils.py,sha256=wJ1qkTj-kDHCxb-dReMvCaDYSTWZF9APvz0g8hSl_cg,3270
+KratosMultiphysics/SystemIdentificationApplication/utilities/data_utils.py,sha256=5ZNRz-wUGjZ5OGaAxVBKb1bdLPOa9omUbLBwSXha7tg,3312
+KratosMultiphysics/SystemIdentificationApplication/utilities/sensor_utils.py,sha256=y_idR9FNPfeL6YKzwA0JqU68N_GOaFi9DO4VpBNFxUc,11085
+KratosMultiphysics/SystemIdentificationApplication/convergence_criteria/sensor_error.py,sha256=biIaJNGHrpti8ZYk1itI9BwZyAbYXpO59aZfQ4p6-d4,4854
+KratosMultiphysics/SystemIdentificationApplication/sensor_io/sensor_model_part_controller.py,sha256=vE33Xbq2zOKY1efn52JM3lSBXFsWxx-rNfSTB8QCfEI,3213
+KratosMultiphysics/.libs/KratosSystemIdentificationApplication.so,sha256=zK2G6oUhMu_hB4bBJdaYAaVt2GbAh-RNOFMEls_M7Ms,1227584
+KratosMultiphysics/.libs/libKratosSystemIdentificationCore.dylib,sha256=t8t-6kBSoz7FHJK0nE-SdNGhmveKcADOMmzCQ49bSjI,2651536
+kratossystemidentificationapplication.dylibs/libstdc++.6.dylib,sha256=msZqYToEz3DYpyb3gdNdl4HfDSVAn_HG_87McBJUV0A,3403264
+kratossystemidentificationapplication.dylibs/libKratosCore.dylib,sha256=BqtBk3bY9895iHDNKyyOWhQedbevJjAmi8gJuekJu2Y,63629792
+kratossystemidentificationapplication.dylibs/libgcc_s.1.1.dylib,sha256=igEme-s72bdU4f5YCEh8V5w5Dx9Mzs2l5IXlm8EM-_c,219232
+kratossystemidentificationapplication.dylibs/libgomp.1.dylib,sha256=HOZIqBxyjYyy-zPnzJsGXiXbsA0wrzhKEz5RuKvx4tM,438880
+kratossystemidentificationapplication-10.4.4.dist-info/RECORD,,
+kratossystemidentificationapplication-10.4.4.dist-info/WHEEL,sha256=QX0UaoWXQIAv8vp5R3do793urekDoJdJRoGCk8nXIBY,115
+kratossystemidentificationapplication-10.4.4.dist-info/METADATA,sha256=8DpNB7SIduTjMqKcJgEQt_zv1Cpp5ynSh2CEcouduro,644

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

kratossystemidentificationapplication.dylibs/libKratosCore.dylib

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