NaxToPy 2.2.0__tar.gz → 2.2.1__tar.gz

{naxtopy-2.2.0/src/NaxToPy.egg-info → naxtopy-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 2.2.0
+Version: 2.2.1
 Summary: Package for postprocessing FEM results in Python
 Home-page: https://www.idaerosolutions.com/Home/NaxToPy
 Download-URL: https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US
@@ -145,9 +145,14 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 
 **NaxToPy** is a powerful tool for FEM analysis post-processing!
 
-**CAUTION:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
-This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0).
-Check in _Programs and Features_ the NaxTo version that is installed. 
+---------------
+
+⚠️**Warning:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
+This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0, 2024.3.1).
+Check in _Programs and Features_ the NaxTo version that is installed.
+
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/2.2.0/#history) to find which newer version is compatible with it.
+
 
 ## Installation
 
@@ -298,6 +303,16 @@ but the execution doesn't crash.
 6. Refactor: The dictionary and list for Cards have been replaced with a lazy dictionary and a lazy list, improving execution efficiency.
 7. Refactor: Reading the mesh from binary files is now executed in parallel by default, as this approach is more memory-safe.
 
+### v.2.2.1
+1. BugFix: The method set_increment() is fixed.
+2. BugFix: Several bugfix (not in the result accuracy) are fixed in modules N2PGetFastener and N2PGetLoadsFastener. Several optimizations are included.
+3. Feat: Now the method get_load_case() admits a list of int and a list of string and return a list of N2PLoadCase.
+4. Refactor: N2P classes use __slots__ for security and optimization.
+5. Refactor: Complete refactor of the module that loads the NaxTo libraries.
+6. BugFix: in parallel mesh load with a small mesh and lot of results.
+7. BugFix: in sequential mesh load in op2.
+
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

{naxtopy-2.2.0 → naxtopy-2.2.1}/README.md

@@ -21,9 +21,14 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 
 **NaxToPy** is a powerful tool for FEM analysis post-processing!
 
-**CAUTION:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
-This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0).
-Check in _Programs and Features_ the NaxTo version that is installed. 
+---------------
+
+⚠️**Warning:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
+This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0, 2024.3.1).
+Check in _Programs and Features_ the NaxTo version that is installed.
+
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/2.2.0/#history) to find which newer version is compatible with it.
+
 
 ## Installation
 
@@ -174,6 +179,16 @@ but the execution doesn't crash.
 6. Refactor: The dictionary and list for Cards have been replaced with a lazy dictionary and a lazy list, improving execution efficiency.
 7. Refactor: Reading the mesh from binary files is now executed in parallel by default, as this approach is more memory-safe.
 
+### v.2.2.1
+1. BugFix: The method set_increment() is fixed.
+2. BugFix: Several bugfix (not in the result accuracy) are fixed in modules N2PGetFastener and N2PGetLoadsFastener. Several optimizations are included.
+3. Feat: Now the method get_load_case() admits a list of int and a list of string and return a list of N2PLoadCase.
+4. Refactor: N2P classes use __slots__ for security and optimization.
+5. Refactor: Complete refactor of the module that loads the NaxTo libraries.
+6. BugFix: in parallel mesh load with a small mesh and lot of results.
+7. BugFix: in sequential mesh load in op2.
+
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

{naxtopy-2.2.0 → naxtopy-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "NaxToPy"
-version = "2.2.0"
+version = "2.2.1"
 license = {file = "LICENSE"}
 authors = [ { name = "Idaero Solutions", email = "manuel.sanchez@idaerosolutions.com" }, ]
 requires-python = ">=3.9"

{naxtopy-2.2.0 → naxtopy-2.2.1}/setup.py

@@ -7,7 +7,9 @@ setup(
     packages = find_packages(where="src"),
     package_dir = {"": "src"},
     include_package_data=True,
-    data_files=[("NaxToPy", ["src/NaxToPy/NaxToPy.ico", "src/NaxToPy/user_functions.txt"])],
+    package_data={
+        "NaxToPy": ["NaxToPy.ico", "user_functions.txt"]
+    },
     url="https://www.idaerosolutions.com/Home/NaxToPy",
     download_url="https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US"
 )

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PAbaqusInputData.py

@@ -13,6 +13,15 @@ class N2PAbaqusInputData:
     """Class with the complete data of an Abaqus MEF input file (text file usually with the extension .inp).
     """
 
+    __slots__ = (
+        "__inputfiledata",
+        "__listcomments",
+        "__dictionary_files_ids",
+        "__listbulkdatakeywords",
+        "__dictKeywordToN2P",
+        "__dictEntityToN2P", 
+    )
+
     def __init__(self, inputfiledata):
         self.__inputfiledata = inputfiledata
         self.__listcomments = []

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PComponent.py

@@ -21,6 +21,12 @@ class N2PComponent:
         IsTransformable: bool.
     '''
 
+    __slots__ = (
+        "_name",
+        "_sections",
+        "_result_father",
+    )
+
     # Constructor de N2PComponent
     # -----------------------------------------------------------------
     def __init__(self, name, sections, result_father):
@@ -31,17 +37,17 @@ class N2PComponent:
                 sections: list[N2Sections] -> list with instances of N2Sections
                 result_father: N2PResult
         """
-        self.__name__ = name
-        self.__sections__ = [N2PSection(sections[i].Name,
+        self._name = name
+        self._sections = [N2PSection(sections[i].Name,
                                         sections[i].Number) for i in range(0, len(sections))]
-        self.__result_father__ = result_father
+        self._result_father = result_father
     # ---------------------------------------------------------------------------------------------
 
     # Metodo para Obtener el Nombre de la Componente
     # ----------------------------------------------
     @property
     def Name(self) -> str:
-        return(str(self.__name__))
+        return(str(self._name))
     # ---------------------------------------------------------------------------------------------
 
     # Metodo para Obtener una lista con las secciones de la componente ----------------------------
@@ -49,7 +55,7 @@ class N2PComponent:
     def Sections(self) -> list[N2PSection, ...]:
         """ Returns a list of N2PSection objects with all the sections contained in the component
         """
-        return(self.__sections__)
+        return(self._sections)
     # ---------------------------------------------------------------------------------------------
 
     @property
@@ -59,8 +65,8 @@ class N2PComponent:
         # No se guarda como atributo privado durante la instanciacion de un objeto porque algunas variables
         # aun no se han construido. Por eso el metodo de la propiedad es la que busca los argumentos y llama
         # al metodo dentro de Vizzer classes.
-        solver = self.__result_father__.__loadCase_father__.__solver__
-        result = self.__result_father__.Name
+        solver = self._result_father._loadCase_father._N2PLoadCase__solver
+        result = self._result_father.Name
         component = self.Name
         return bool(N2TensorTransformation.IsResultSupported(solver, result, component))
 
@@ -153,7 +159,7 @@ class N2PComponent:
         resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
         results = list(
-            self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel.CalculateArrayLastResult(
+            self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
                 resultsParameters, 0))
 
         if results[1] == 1:
@@ -241,7 +247,7 @@ class N2PComponent:
                                                             realPolar, coordsys, v1, v2)
 
         results = \
-            self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel.CalculateArrayLastResult(
+            self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
             resultsParameters, 0)
 
         if results[1] == 1:
@@ -324,13 +330,13 @@ class N2PComponent:
     #     if resultlist[0] == -1:
     #         N2PLog.Error.E208()
     #         return DataFrame()
-    #     if len(self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__StrPartToID) == 1:
+    #     if len(self.__result_father__._loadCase_father._modelFather._N2PModelContent__StrPartToID) == 1:
     #         noparts = True
     #     else:
     #         noparts = False
     #
     #     if resultlist[1] == "NODES":
-    #         nodos = self.__result_father__.__loadCase_father__.__modelFather__.get_nodes()
+    #         nodos = self.__result_father__._loadCase_father._modelFather.get_nodes()
     #         if noparts:
     #             ids = [nodo.ID for nodo in nodos]
     #             indexname = ["Grid"]
@@ -339,8 +345,8 @@ class N2PComponent:
     #             indexname = ["Part", "Grid"]
     #         del nodos
     #     elif resultlist[1] == "ELEMENTS":
-    #         elements = self.__result_father__.__loadCase_father__.__modelFather__.get_elements()
-    #         connectors = self.__result_father__.__loadCase_father__.__modelFather__.get_connectors()
+    #         elements = self.__result_father__._loadCase_father._modelFather.get_elements()
+    #         connectors = self.__result_father__._loadCase_father._modelFather.get_connectors()
     #         if noparts:
     #             # La lista de connectores puede contener N2PConnector o lista de N2PConector. Esto es porque
     #             # los MPC puden tener ids iguales en Nastran. Por eso en la comprension de la lista de conectores
@@ -355,7 +361,7 @@ class N2PComponent:
     #             indexname = ["Part", "Element"]
     #         del elements, connectors
     #     elif resultlist[1] == "ELEMENT NODAL":
-    #         ids = list(self.__result_father__.__loadCase_father__.__modelFather__._elementnodal().values())
+    #         ids = list(self.__result_father__._loadCase_father._modelFather._elementnodal().values())
     #         indexname = ["Part", "Grid", "Element"]
     #
     #     # Se revisa que la lista de malla y la lista de resultados sean del mismo tamaño
@@ -393,7 +399,7 @@ class N2PComponent:
         resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
 
-        cs_dict = self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel.CalculateArrayLastResult(
+        cs_dict = self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
                 formula, resultsParameters, 0)
 
         py_dict = {(int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")),
@@ -412,8 +418,8 @@ class N2PComponent:
         if isinstance(list_lc_incr, tuple):
             list_lc_incr = [list_lc_incr]
 
-        N2PLoadCase = type(self.__result_father__.__loadCase_father__)
-        N2PIncrement = type(self.__result_father__.__loadCase_father__.Increments[0])
+        N2PLoadCase = type(self._result_father._loadCase_father)
+        N2PIncrement = type(self._result_father._loadCase_father.Increments[0])
 
         if isinstance(list_lc_incr[0][0], N2PLoadCase) and isinstance(list_lc_incr[0][1], N2PIncrement):
             return ",".join(f"<LC{lc[0].ID}:FR{lc[1].ID}>" for lc in list_lc_incr)
@@ -479,16 +485,16 @@ class N2PComponent:
         resultsParameters.IdsEntities = ''
 
         # Active Increment
-        resultsParameters.IncrementID = str(self.__result_father__.__loadCase_father__.__activeIncrement__)
+        resultsParameters.IncrementID = str(self._result_father._loadCase_father._activeIncrement)
 
         # Load Case Selected
-        resultsParameters.LoadCaseID = str(self.__result_father__.__loadCase_father__.ID)
+        resultsParameters.LoadCaseID = str(self._result_father._loadCase_father.ID)
 
         # Parts Selected (So Far 'ALL')
         resultsParameters.Part = 'all'
 
         # Results Selected
-        resultsParameters.Result = str(self.__result_father__.Name)
+        resultsParameters.Result = str(self._result_father.Name)
 
         resultsParameters.Sets = ''
         resultsParameters.TypeElement = ''
@@ -497,7 +503,7 @@ class N2PComponent:
         sectionParam = ''
 
         if sections is None:
-            for section in self.__sections__:
+            for section in self._sections:
                 sectionParam += str(section.Name) + '#'
         else:
             if not isinstance(sections, list):

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PConnector.py

@@ -15,29 +15,34 @@ class N2PConnector:
         RefGrid: N2PNode.
     """
 
+    __slots__ = (
+        "__info",
+        "__model"
+    )
+
     def __init__(self, info, model_father):
         """Python Connector constructor"""
-        self.__info__ = info
-        self.__model__ = model_father
+        self.__info = info
+        self.__model = model_father
 
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el ID conector -------------------------------------------------------------------------------
     @property
     def ID(self) -> int:
-        return(int(self.__info__.ID))
+        return(int(self.__info.ID))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el ID de la parte del conector ---------------------------------------------------------------
     @property
     def PartID(self) -> str:
-        return(self.__model__._N2PModelContent__partIDtoStr.get(self.__info__.Part, -1))
+        return(self.__model._N2PModelContent__partIDtoStr.get(self.__info.Part, -1))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el tipo de conector conector -----------------------------------------------------------------
     @property
     def TypeConnector(self) -> str:
-        return str(self.__info__.tipo)
+        return str(self.__info.tipo)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los nodos (N2PNode) libres/independientes conector -------------------------------------------
@@ -46,37 +51,37 @@ class N2PConnector:
         # Devuelve el ID interno (el de VTK) de los nodos, no el solver. Entro con ese id en el diccionario de VTK a
         # Solver(ID, partID). Con la tupla entro en el diccionario de nodos para sacar el objeto N2PNode.
         # Todo dentro de una comprension de lista.
-        listaobjetos = [ list(self.__model__._N2PModelContent__node_dict)[node]
-                        for node in list(self.__info__.pointsIndep) ]
+        listaobjetos = [ list(self.__model._N2PModelContent__node_dict)[node]
+                        for node in list(self.__info.pointsIndep) ]
         return listaobjetos
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los nodos (N2PNode) esclavos/dependientes del conector ---------------------------------------
     @property
     def SlaveNodes(self) -> list[N2PNode]:
-        listaobjetos = [list(self.__model__._N2PModelContent__node_dict)[node]
-                        for node in list(self.__info__.pointsDep)]
+        listaobjetos = [list(self.__model._N2PModelContent__node_dict)[node]
+                        for node in list(self.__info.pointsDep)]
         return listaobjetos
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los nodos (N2PNode) del conector en caso de ser del tipo MPC o RSPLINE -----------------------
     @property
     def GridIDs(self) -> list[N2PNode]:
-        listaobjetos = [ list(self.__model__._N2PModelContent__node_dict)[node]
-                        for node in list(self.__info__.gridIDs) ]
+        listaobjetos = [ list(self.__model._N2PModelContent__node_dict)[node]
+                        for node in list(self.__info.gridIDs) ]
         return listaobjetos
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el id interno (o VTK) del conector -----------------------------------------------------------
     @property
     def InternalID(self) -> int:
-        return (int(self.__info__.VTKindice))
+        return (int(self.__info.VTKindice))
     # ------------------------------------------------------------------------------------------------------------------
     
     # Metodo para obtener el id del nodo de referencia en caso de que el conector sea RBE3 o COUPLING
     @property
     def RefGrid(self) -> N2PNode:
-        return list(self.__model__._N2PModelContent__node_dict)[int(self.__info__.refGrid)]
+        return list(self.__model._N2PModelContent__node_dict)[int(self.__info.refGrid)]
     # ------------------------------------------------------------------------------------------------------------------
 
     # Special Method for Object Representation -------------------------------------------------------------------------

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PCoord.py

@@ -15,11 +15,16 @@ class N2PCoord(object):
         Zaxis: tuple.
     """
 
+    __slots__ = (
+        "__info",
+        "__model"
+    )
+
     def __init__(self, info, model_father):
         """Constructor of the class N2PCoord"""
 
         self.__info = info
-        self.__model__ = model_father
+        self.__model = model_father
 
     # Metodos para obtener los atributos de la clase N2PCoord
 

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PElement.py

@@ -21,74 +21,79 @@ class N2PElement:
         ElemSystem: list[float].
     """
 
+    __slots__ = (
+        "__info",
+        "__model"
+    )
+
     def __init__(self, info, model_father):
         """Python Element constructor"""
 
-        self.__info__ = info
-        self.__model__ = model_father
+        self.__info = info
+        self.__model = model_father
 
     # Metodo para obtener  del elemento --------------------------------------------------------------------------------
     @property
     def InternalID(self) -> int:
-        return(int(self.__info__.VTKindice))
+        return(int(self.__info.VTKindice))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el id del elemento ---------------------------------------------------------------------------
     @property
     def ID(self) -> int:
-        return(int(self.__info__.ID))
+        return(int(self.__info.ID))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener  del elemento --------------------------------------------------------------------------------
     @property
     def PartID(self) -> str:
-        return(self.__model__._N2PModelContent__partIDtoStr.get(self.__info__.partID, -1))
+        return(self.__model._N2PModelContent__partIDtoStr.get(self.__info.partID, -1))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener  del elemento --------------------------------------------------------------------------------
     @property
     def TypeElement(self) -> str:
-        return(self.__model__._N2PModelContent__elementTypeIDtoStr.get(self.__info__.typeElementSolver, -1))
+        return(self.__model._N2PModelContent__elementTypeIDtoStr.get(self.__info.typeElementSolver, -1))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener  del elemento --------------------------------------------------------------------------------
     @property
     def Prop(self) -> int:
-        return(int(self.__info__.prop))
+        return(int(self.__info.prop))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el material del elemento ---------------------------------------------------------------------
     @property
     def InternalElemType(self) -> int:
-        return(int(self.__info__.typeElementVTK))
+        return(int(self.__info.typeElementVTK))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener nNodes del elemento --------------------------------------------------------------------------
     @property
     def NumNodes(self) -> int:
-        return(int(self.__info__.nNodes))
+        return(int(self.__info.nNodes))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los nodos del elemento como N2PNode ----------------------------------------------------------
     @property
     def Nodes(self) -> tuple[N2PNode]:
-        aux = list(self.__info__.nodeList)
+        aux = list(self.__info.nodeList)
         retornar = tuple()
         for nodo in aux:
-            retornar += (self.__model__._N2PModelContent__node_dict.get((nodo, self.__info__.partID), -1) ,)
+            retornar += (self.__model._N2PModelContent__node_dict.get((nodo, self.__info.partID), -1) ,)
         return(retornar)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los ids de los nodos del elemento ------------------------------------------------------------
     @property
     def NodesIds(self) -> tuple:
-        return(tuple(self.__info__.nodeList))
+        return(tuple(self.__info.nodeList))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el angulo material del elemento --------------------------------------------------------------
     @property
     def AngleMat(self) -> float:
-        return(float(self.__info__.angleMaterial))
+        return(float(self.__info.angleMaterial))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para el sistema de coordenadas elemento -------------------------------------------------------------------
@@ -98,7 +103,7 @@ class N2PElement:
         Returns an array with the position of the three vectors that define the element system of the element:
         [x1, x2, x3, y1, y2, y3, z1, z2, z3]
         """
-        systems = self.__model__._elements_coord_sys()
+        systems = self.__model._elements_coord_sys()
         return [systems[self.InternalID, i] for i in range(9)]
     # ------------------------------------------------------------------------------------------------------------------
 
@@ -109,7 +114,7 @@ class N2PElement:
         Returns list with the position of the three vectors that define the material system of the element:
         [x1, x2, x3, y1, y2, y3, z1, z2, z3]
         """
-        mastsys = N2ElementsCoordinateSystems.GetElementMaterialSystem(self.__model__._N2PModelContent__vzmodel,
+        mastsys = N2ElementsCoordinateSystems.GetElementMaterialSystem(self.__model._N2PModelContent__vzmodel,
                                                                        self.InternalID)
         if mastsys is not None:
             return list(mastsys)
@@ -123,7 +128,7 @@ class N2PElement:
         """
         Returns list with the centroid of the element: [x, y, z]
         """
-        all_centroids = self.__model__._N2PModelContent__vzmodel.ElementCentroids
+        all_centroids = self.__model._N2PModelContent__vzmodel.ElementCentroids
         iid = self.InternalID
         return [all_centroids[iid, i] for i in range(3)]
     # ------------------------------------------------------------------------------------------------------------------
@@ -137,7 +142,7 @@ class N2PElement:
 
         If no user systems for elements are defined yet, it returns None.
         """
-        user_system_array = self.__model__._N2PModelContent__vzmodel.ElementUserCoordinateSystems
+        user_system_array = self.__model._N2PModelContent__vzmodel.ElementUserCoordinateSystems
         if not user_system_array:
             return None
         return [user_system_array[self.InternalID, i] for i in range(9)]

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PFreeBody.py

@@ -28,9 +28,19 @@ class N2PFreeBody(object):
         Moment: tuple[float].
     """
 
-    __forces = tuple()
-    __moments = tuple()
-    __fbdresult = None
+    __slots__ = (
+        "__name",
+        "__loadcase",
+        "__increment",
+        "__nodelist",
+        "__elementlist",
+        "__coordsys",
+        "__model",
+        "__outpoint",
+        "__fbdresult",
+        "__centroid"
+    )
+    
 
     def __init__(self, name: str, loadcase: N2PLoadCase, increment: N2PIncrement, nodelist: list[N2PNode], elementlist: list[N2PElement],
                  modelfather, coordsys: N2PCoord = None, outpoint: tuple[float] = None):
@@ -54,6 +64,7 @@ class N2PFreeBody(object):
         self.__coordsys = coordsys
         self.__model = modelfather
         self.__outpoint = outpoint
+        self.__fbdresult = None
 
 
         if outpoint is not None:

{naxtopy-2.2.0 → naxtopy-2.2.1}/src/NaxToPy/Core/Classes/N2PIncrement.py

@@ -2,51 +2,55 @@
 class N2PIncrement:
     """Class which contains the information associated to an increment/frame of a N2PLoadCase instance."""
 
+    __slots__ = (
+        "__info"
+    )
+
     # Constructor de N2PIncrement --------------------------------------------------------------------------------------
     def __init__(self, info):
-        self.__info__ = info
+        self.__info = info
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el nombre del incremento ---------------------------------------------------------------------
     @property
     def Name(self) -> str:
         """Name of the Increment"""
-        return(str(self.__info__.Name))
+        return(str(self.__info.Name))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el valor del autovalor real ------------------------------------------------------------------
     @property
     def RealEigenvalue(self) -> float:
         """Real Eigenvalue of the increment"""
-        return(float(self.__info__.EigReal))
+        return(float(self.__info.EigReal))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el valor del autovalor imaginario ------------------------------------------------------------
     @property
     def ImaginaryEigenvalue(self) -> float:
         """Imaginary Eigenvalue of the increment"""
-        return(float(self.__info__.EigImg))
+        return(float(self.__info.EigImg))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el ID del incremento en el caso de carga -----------------------------------------------------
     @property
     def ID(self) -> int:
         """Solver ID of the Increment"""
-        return(int(self.__info__.ID))
+        return(int(self.__info.ID))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el valor del incremento ----------------------------------------------------------------------
     @property
     def Time(self) -> float:
         ''' Returns the value of the increment/frame'''
-        return(float(self.__info__.Time))
+        return(float(self.__info.Time))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el tipo de Solucion --- ----------------------------------------------------------------------
     @property
     def Solution(self) -> str:
         """Returns the value of the Solution name of the Increment"""
-        return(str(self.__info__.Solution))
+        return(str(self.__info.Solution))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Special Method for Object Representation -------------------------------------------------------------------------