KratosCableNetApplication 10.4.2__2-cp38-cp38-win_amd64.whl

KratosMultiphysics/CableNetApplication/__init__.py

@@ -0,0 +1,9 @@
+
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+import KratosMultiphysics.StructuralMechanicsApplication
+from KratosCableNetApplication import *
+application = KratosCableNetApplication()
+application_name = "KratosCableNetApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/CableNetApplication/__init__.pyi

@@ -0,0 +1,24 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics as Kratos
+import collections.abc
+import typing
+
+class ApplyWeakSlidingProcess(Kratos.Process):
+    def __init__(self, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None:
+        """__init__(self: KratosCableNetApplication.ApplyWeakSlidingProcess, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None"""
+
+class EdgeCableElementProcess(Kratos.Process):
+    def __init__(self, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None:
+        """__init__(self: KratosCableNetApplication.EdgeCableElementProcess, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None"""
+
+class EmpiricalSpringElementProcess(Kratos.Process):
+    def __init__(self, arg0: Kratos.ModelPart, arg1: Kratos.Parameters, arg2: collections.abc.Sequence[typing.SupportsFloat]) -> None:
+        """__init__(self: KratosCableNetApplication.EmpiricalSpringElementProcess, arg0: Kratos.ModelPart, arg1: Kratos.Parameters, arg2: collections.abc.Sequence[typing.SupportsFloat]) -> None"""
+
+class KratosCableNetApplication(Kratos.KratosApplication):
+    def __init__(self) -> None:
+        """__init__(self: KratosCableNetApplication.KratosCableNetApplication) -> None"""
+
+class SlidingEdgeProcess(Kratos.Process):
+    def __init__(self, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None:
+        """__init__(self: KratosCableNetApplication.SlidingEdgeProcess, arg0: Kratos.ModelPart, arg1: Kratos.Parameters) -> None"""

KratosMultiphysics/CableNetApplication/apply_weak_sliding_process.py

@@ -0,0 +1,36 @@
+import KratosMultiphysics as KratosMultiphysics
+import KratosMultiphysics.CableNetApplication as CableNetApplication
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyWeakSlidingProcess(Model, settings["Parameters"])
+
+
+
+class ApplyWeakSlidingProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+        default_settings = KratosMultiphysics.Parameters("""
+        {
+            "model_part_name_slave"           : "example_part_slave",
+            "model_part_name_master"          : "example_part_master",
+            "computing_model_part_name"       : "Structure",
+            "element_id"                      : 1,
+            "property_id"                     : 1,
+            "debug_info"                      : false
+        }
+        """)
+        default_settings.ValidateAndAssignDefaults(settings)
+        self.custom_process = CableNetApplication.ApplyWeakSlidingProcess(Model[settings["computing_model_part_name"].GetString()], settings)
+
+
+    def ExecuteInitialize(self):
+        self.custom_process.ExecuteInitialize()
+
+    def ExecuteInitializeSolutionStep(self):
+        self.custom_process.ExecuteInitializeSolutionStep()
+
+    def ExecuteFinalizeSolutionStep(self):
+        self.custom_process.ExecuteFinalizeSolutionStep()

KratosMultiphysics/CableNetApplication/edge_cable_element_process.py

@@ -0,0 +1,78 @@
+import KratosMultiphysics as KratosMultiphysics
+import KratosMultiphysics.CableNetApplication as CableNetApplication
+
+from KratosMultiphysics import Logger
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return EdgeCableElementProcess(Model, settings["Parameters"])
+
+class custom_node:
+    def __init__(self,start_distance,kratos_node):
+        self.start_distance = start_distance
+        self.kratos_node = kratos_node
+    def return_distance_to_line_start(self):
+        return self.start_distance
+
+def return_node_distance_to_line_start(node):
+    return node.return_distance_to_line_start()
+
+
+
+class EdgeCableElementProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+        default_settings = KratosMultiphysics.Parameters("""
+        {
+            "edge_sub_model_part_name"  : "Structure.example_part",
+            "element_type"              : "cable",
+            "node_id_order"             : [1,2,3],
+            "element_id"                : 1,
+            "property_id"               : 1
+        }
+        """)
+        default_settings.ValidateAndAssignDefaults(settings)
+
+        self.edge_model_part = Model[settings["edge_sub_model_part_name"].GetString()]
+
+        node_list = settings["node_id_order"].GetVector()
+        if len(node_list)==0:
+            node_list = self.CreateCorrectNodeOrder()
+            settings["node_id_order"].SetVector(node_list)
+
+        self.edge_cable_element_process = CableNetApplication.EdgeCableElementProcess(self.edge_model_part, settings)
+
+
+    def ExecuteInitialize(self):
+        self.edge_cable_element_process.ExecuteInitialize()
+        Logger.PrintInfo("Initialized","EdgeCableElementProcess")
+
+    def CreateCorrectNodeOrder(self):
+        ## find start/end nodes and calculate total distance
+        max_distance,end_points = 0, []
+        for node_i in self.edge_model_part.Nodes:
+            for node_j in self.edge_model_part.Nodes:
+                distance_i = (node_i.X0 - node_j.X0)*(node_i.X0 - node_j.X0)
+                distance_i += (node_i.Y0 - node_j.Y0)*(node_i.Y0 - node_j.Y0)
+                distance_i += (node_i.Z0 - node_j.Z0)*(node_i.Z0 - node_j.Z0)
+                distance_i = distance_i**0.5
+
+                if distance_i>max_distance:
+                    max_distance=distance_i
+                    end_points = [node_i,node_j]
+
+        ## create sorted node_list
+        custom_node_list = []
+        for node_i in self.edge_model_part.Nodes:
+            distance_i = (node_i.X0 - end_points[0].X0)*(node_i.X0 - end_points[0].X0)
+            distance_i += (node_i.Y0 - end_points[0].Y0)*(node_i.Y0 - end_points[0].Y0)
+            distance_i += (node_i.Z0 - end_points[0].Z0)*(node_i.Z0 - end_points[0].Z0)
+            distance_i = distance_i**0.5
+            custom_node_i = custom_node(distance_i,node_i)
+            custom_node_list.append(custom_node_i)
+
+        sorted_node_list = sorted(custom_node_list, key=return_node_distance_to_line_start)
+
+        return [node.kratos_node.Id for node in sorted_node_list]

KratosMultiphysics/CableNetApplication/empirical_spring_element_process.py

@@ -0,0 +1,62 @@
+import KratosMultiphysics as KratosMultiphysics
+import KratosMultiphysics.CableNetApplication as CableNetApplication
+
+
+from numpy import polyfit
+
+from KratosMultiphysics import Logger
+
+
+
+#/**
+# * @class EmpiricalSpringElementProcess
+# *
+# * @brief This process creates a spring element w.r.t. to given displacement/load data points
+# *
+# * @author Klaus B Sautter
+# */
+
+
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return EmpiricalSpringElementProcess(Model, settings["Parameters"])
+
+
+
+class EmpiricalSpringElementProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings):
+        KratosMultiphysics.Process.__init__(self)
+        default_settings = KratosMultiphysics.Parameters("""
+        {
+            "model_part_name"           : "example_part",
+            "computing_model_part_name" : "Structure",
+            "node_ids"                  : [1,2],
+            "element_id"                : 1,
+            "property_id"               : 1,
+            "displacement_data"         : [0.0,1.0,2.0,3.0],
+            "force_data"                : [0.0,1.0,2.0,3.0],
+            "polynomial_order"          : 3
+        }
+        """)
+        default_settings.ValidateAndAssignDefaults(settings)
+        self.function_fitted = polyfit(settings["displacement_data"].GetVector(),settings["force_data"].GetVector(),settings["polynomial_order"].GetInt())
+
+
+        # The computing model part
+        self.computing_model_part = Model[settings["computing_model_part_name"].GetString()]
+        self.custom_model_part     = Model[settings["model_part_name"].GetString()]
+
+        self.empirical_spring_element_process = CableNetApplication.EmpiricalSpringElementProcess(self.custom_model_part, settings, self.function_fitted)
+
+
+    def ExecuteInitialize(self):
+        self.empirical_spring_element_process.ExecuteInitialize()
+
+        ## add new element in the computing MP
+        for element_i in self.custom_model_part.Elements:
+            self.computing_model_part.AddElement(element_i, 0)
+        Logger.PrintInfo("Initialized","EmpiricalSpringElementProcess")
+

KratosMultiphysics/CableNetApplication/sliding_edge_process.py

@@ -0,0 +1,43 @@
+import KratosMultiphysics as KratosMultiphysics
+import KratosMultiphysics.CableNetApplication as CableNetApplication
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return SlidingEdgeProcess(Model, settings["Parameters"])
+
+
+
+class SlidingEdgeProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+        default_settings = KratosMultiphysics.Parameters("""
+        {
+            "constraint_name"               : "LinearMasterSlaveConstraint",
+            "master_sub_model_part_name"    : "master_connect",
+            "slave_sub_model_part_name"     : "slave_connect",
+            "computing_model_part"          : "Structure",
+            "variable_names"                : ["DISPLACEMENT_Y","DISPLACEMENT_Z"],
+            "reform_every_step"             : true,
+            "debug_info"                    : true,
+            "angled_initial_line"           : false,
+            "follow_line"                   : false
+        }
+        """)
+        default_settings.ValidateAndAssignDefaults(settings)
+
+        # The computing model part
+        computing_model_part =  Model["Structure"]
+        self.master_model_part = model_part_name.GetSubModelPart(settings["master_sub_model_part_name"].GetString())
+
+        self.sliding_edge_process = CableNetApplication.SlidingEdgeProcess(Model[settings["model_name"].GetString()], settings)
+
+
+
+    def ExecuteInitializeSolutionStep(self):
+        self.sliding_edge_process.ExecuteInitializeSolutionStep()
+
+
+    def ExecuteFinalizeSolutionStep(self):
+        self.sliding_edge_process.ExecuteFinalizeSolutionStep()

kratoscablenetapplication-10.4.2.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: KratosCableNetApplication
+Version: 10.4.2
+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.2
+Description-Content-Type: text/markdown
+
+## Cable Net Application

kratoscablenetapplication-10.4.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+KratosMultiphysics/CableNetApplication/__init__.py,sha256=dNITtuf5xsLSeYo6IhH3MDDuNM3Gour5OSqA_xBXg5o,337
+KratosMultiphysics/CableNetApplication/__init__.pyi,sha256=eoGZmaST6ZsU3Ahbayce5QHltFpjLnZKId-wJN6UVPI,1489
+KratosMultiphysics/CableNetApplication/apply_weak_sliding_process.py,sha256=v6H11w3lz5xdfa_xdFE7VKZ30OxdT6aBRoeclO_3SH0,1506
+KratosMultiphysics/CableNetApplication/edge_cable_element_process.py,sha256=U1cPqH4j7oIExHhFS7B02iS6P9UxWrZrwg9u-5Jd36E,3305
+KratosMultiphysics/CableNetApplication/empirical_spring_element_process.py,sha256=0NsPO-fw92YwVCthCHoMfzUgVeiWwJrs1jUXDt_sCMU,2293
+KratosMultiphysics/CableNetApplication/sliding_edge_process.py,sha256=xe6VeBGv2ZOiJRElVrVCHm_z_kHBAso0tHFUrjOS1ZA,1823
+KratosMultiphysics/.libs/KratosCableNetApplication.pyd,sha256=1R7IsIp15dfVKvxBRTIzyVM4sQsCeb73by5vQWu5y9I,751104
+KratosMultiphysics/.libs/KratosCableNetCore.dll,sha256=NMkOaoeUiEhu1QEwgxFsjSvbvvTvFInLRvmHf4ypmmA,881152
+KratosMultiphysics/.libs/KratosCableNetCore.lib,sha256=MaHN9KJcKOKqhW7bPXKbJRedb_wreEZUqK6bbC9hKsQ,128944
+kratoscablenetapplication-10.4.2.dist-info/METADATA,sha256=guLZjAYwNsmGNj8Yp1rldntdLzvLba_UrW9qFguuq80,697
+kratoscablenetapplication-10.4.2.dist-info/WHEEL,sha256=L6OCO7x2__38eHbiV8z-OpI28zauuQBoqd16JISdNDg,108
+kratoscablenetapplication-10.4.2.dist-info/RECORD,,

kratoscablenetapplication-10.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: cp38-cp38-win_amd64
+Build: 2