NaxToPy 3.0.0__tar.gz → 3.1.0__tar.gz

{naxtopy-3.0.0/src/NaxToPy.egg-info → naxtopy-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: NaxToPy
-Version: 3.0.0
+Version: 3.1.0
 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
@@ -107,7 +107,7 @@ License: Copyright (c) 2024 Idaero Solutions
         
         The above copyright notice and this permission notice shall be included in all
         copies or substantial portions of the Software.
-Project-URL: Documentation, https://www.idaerosolutions.com/NaxToPyDoc/index.html
+Project-URL: Documentation, https://www.idaerosolutions.com/NaxToDocumentation/NaxToPy/3.1.0/index.html
 Project-URL: LinkedIn, https://www.linkedin.com/company/idaero/
 Keywords: NaxTo,Postprocessing,FEM
 Classifier: Intended Audience :: Science/Research
@@ -124,6 +124,7 @@ Requires-Dist: setuptools>=67.8.0
 Requires-Dist: h5py>=3.12.1
 Dynamic: download-url
 Dynamic: home-page
+Dynamic: license-file
 
 [![Idaero](https://img.shields.io/badge/powered%20by-Idaero%20Solutions-299797)](https://idaerosolutions.com)
 [![PyPi](https://img.shields.io/pypi/v/NaxToPy?color=ffd500)](https://pypi.org/project/NaxToPy/)
@@ -151,10 +152,10 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 ---------------
 
 ⚠️**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 2025.0**. 
+This version is compatible with **NaxTo 2025.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/3.0.0/#history) to find which newer version is compatible with it.
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/3.1.0/#history) to find which newer version is compatible with it.
 
 
 ## Installation
@@ -343,6 +344,20 @@ is redundant. The coordinate system will prevail.
 7. Feat: new method in `N2PModelContent`: `get_elements_filtered()`. It returns a list of `N2PElement` that matches a material, property, part or type-element.
 8. Feat: New checks in the results methods to avoid invalid parameters.
 
+### v.3.1.0
+1. Feat: New optional argument in `load_model()` called **loadconnectors**. True by default.
+2. Feat: New module N2PNeuber to obtain stresses using the Neuber method.
+3. Feat: New module N2PSandwich to calculate sandwich structures failure modes.
+4. Feat: New module N2PCompositeFailure for evaluating structural failure in laminates.
+5. Feat: New module N2PEdgeDelamination  to obtain interlaminar stresses and RF from edge delamination.
+6. Feat: New module N2PCalculatorRFJoints manages the Reserve Factor (RF) calculation process of the joints obtained through the modules N2PGetFasteners and N2PGetLoadFasteners.
+7. Feat: New module N2PUpdateFastener provides methods to update rivet and bolt stiffness and generate a new FEM Input File (.bdf, .fem, .dat, etc.) file with the updated data.
+8. BugFix: Several bugs are fixed in N2PGetFastener and N2PGetLoadFastener modules.
+9. Feat: Extra information in the log when the NaxToPy is running from a executable.
+10. Feat: `N2PLoadModelContent.SetList` is now an encapsulated property.
+11. Refactor: the method `N2PLoadModelContent.get_result_by_LCs_Incr()` is optimized.
+
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

{naxtopy-3.0.0 → naxtopy-3.1.0}/README.md

@@ -24,10 +24,10 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 ---------------
 
 ⚠️**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 2025.0**. 
+This version is compatible with **NaxTo 2025.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/3.0.0/#history) to find which newer version is compatible with it.
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/3.1.0/#history) to find which newer version is compatible with it.
 
 
 ## Installation
@@ -216,6 +216,20 @@ is redundant. The coordinate system will prevail.
 7. Feat: new method in `N2PModelContent`: `get_elements_filtered()`. It returns a list of `N2PElement` that matches a material, property, part or type-element.
 8. Feat: New checks in the results methods to avoid invalid parameters.
 
+### v.3.1.0
+1. Feat: New optional argument in `load_model()` called **loadconnectors**. True by default.
+2. Feat: New module N2PNeuber to obtain stresses using the Neuber method.
+3. Feat: New module N2PSandwich to calculate sandwich structures failure modes.
+4. Feat: New module N2PCompositeFailure for evaluating structural failure in laminates.
+5. Feat: New module N2PEdgeDelamination  to obtain interlaminar stresses and RF from edge delamination.
+6. Feat: New module N2PCalculatorRFJoints manages the Reserve Factor (RF) calculation process of the joints obtained through the modules N2PGetFasteners and N2PGetLoadFasteners.
+7. Feat: New module N2PUpdateFastener provides methods to update rivet and bolt stiffness and generate a new FEM Input File (.bdf, .fem, .dat, etc.) file with the updated data.
+8. BugFix: Several bugs are fixed in N2PGetFastener and N2PGetLoadFastener modules.
+9. Feat: Extra information in the log when the NaxToPy is running from a executable.
+10. Feat: `N2PLoadModelContent.SetList` is now an encapsulated property.
+11. Refactor: the method `N2PLoadModelContent.get_result_by_LCs_Incr()` is optimized.
+
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

{naxtopy-3.0.0 → naxtopy-3.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "NaxToPy"
-version = "3.0.0"
+version = "3.1.0"
 license = {file = "LICENSE"}
 authors = [ { name = "Idaero Solutions", email = "manuel.sanchez@idaerosolutions.com" }, ]
 requires-python = ">=3.9"
@@ -25,7 +25,7 @@ keywords = ["NaxTo",
             "FEM"]
 
 [project.urls]
-"Documentation" = "https://www.idaerosolutions.com/NaxToPyDoc/index.html"
+"Documentation" = "https://www.idaerosolutions.com/NaxToDocumentation/NaxToPy/3.1.0/index.html"
 "LinkedIn" = "https://www.linkedin.com/company/idaero/"
 
 [tool.setuptools]

{naxtopy-3.0.0 → naxtopy-3.1.0}/src/NaxToPy/Core/Classes/N2PAbaqusInputData.py

@@ -1,7 +1,7 @@
 """This module contains classes related with a Abaqus Input File (.inp files). The parent classes are similar but not
-the same as the Nastran Input File. Child classes of N2PKeyword are based on Abaqus Keywords Reference Guide"""
+the same as the Nastran Input File. Child classes of N2PKeyword are based on Abaqus Keywords Reference Guide."""
 from __future__ import annotations  # For compatibility with Python 3.9 or higher
-from typing import Literal
+from typing import Literal, overload
 
 from NaxToPy.Core.Errors.N2PLog import N2PLog
 from NaxToPy.Core.Classes.N2PNastranInputData import N2PInputData
@@ -10,7 +10,8 @@ from NaxToPy.Core.Classes.ABQEntities import *
 
 
 class N2PAbaqusInputData:
-    """Class with the complete data of an Abaqus MEF input file (text file usually with the extension .inp).
+    """
+    Class with the complete data of an Abaqus MEF input file (text file usually with the extension .inp).
     """
 
     __slots__ = (
@@ -48,34 +49,58 @@ class N2PAbaqusInputData:
             {entityelement: N2PEntityElement(entityelement, self.__dictKeywordToN2P, self.__dictEntityToN2P)
              for entityelement in inputfiledata.StructuredInfo.ModelElements})
 
+    # Método para optener los objetos N2PCard del Input File -----------------------------------------------------------
     @property
     def ListBulkDataKeywords(self) -> list[N2PKeyword, ...]:
-        """List with the N2PCard objects of the input FEM file. It has all bulk data cards of the model"""
+        """
+        List with the N2PCard objects of the input FEM file. It has all bulk data cards of the model.
+        """
         return self.__listbulkdatakeywords
+    # ------------------------------------------------------------------------------------------------------------------
 
+    # Método para obtener el diccionaro de IDs a FilePaths -------------------------------------------------------------
     @property
     def DictionaryIDsFiles(self) -> dict:
+        """
+        Dictionary with ID (`int`) as keys and FilePaths (`string`) as values.
+        """
         return dict(self.__inputfiledata.DictionaryIDsFiles)
+    # ------------------------------------------------------------------------------------------------------------------
 
+    # Método para obtener el diccionario de FilePaths a IDs ------------------------------------------------------------
     @property
     def DictionaryFilesIDs(self) -> dict:
+        """
+        Dictionary FilePaths (`string`) as keys and with ID (`int`) as values.
+        """
         return dict(self.__dictionary_files_ids)
+    # ------------------------------------------------------------------------------------------------------------------
 
+    # Método para obtener el tipo de Input File ------------------------------------------------------------------------
     @property
     def TypeOfFile(self) -> str:
+        """
+        Type of Input File.
+        """
         return "ABAQUS"
+    # ------------------------------------------------------------------------------------------------------------------
 
+    # Método para obtener la lista de comentarios en el Input File -----------------------------------------------------
     @property
     def ListComments(self) -> list[N2PInputData, ]:
-        """List with all the comments in the FEM Input File"""
+        """
+        List with all the comments in the FEM Input File.
+        """
         if self.__listcomments:
             return self.__listcomments
         else:
             self.__listcomments = [N2PInputData(i) for i in self.__inputfiledata.StructuredInfo.ModelComments]
             return self.__listcomments
+    # ------------------------------------------------------------------------------------------------------------------
 
     def get_keywords_by_type(self, field: KeyWordType) -> list[N2PKeyword,]:
-        """Method that returns a list with the N2PKeyword objects of the input FEM file asked.
+        """
+        Method that returns a list with the :class:`N2PKeyword` objects of the input FEM file asked. They can be uppercase or lowecase indistinctly.
 
         Args:
             field: str
@@ -85,36 +110,53 @@ class N2PAbaqusInputData:
         """
         if not isinstance(field, str):
             Exception(N2PLog.Critical.C201())
-        elif field not in CONSTRUCTABQDICT:
+        elif field.upper() not in CONSTRUCTABQDICT:
             N2PLog.Error.E205()
             return []
         else:
             return [self.__dictKeywordToN2P[keyword] for keyword in self.__inputfiledata.GetKeywordsByType(field)]
-
-    def get_entity_by_key_and_id(self, entitytype: EntityType, entitityid: int) -> list[N2PEntity, ]:
-        """Method that returns a list with the N2Entities objects of the input FEM file asked. There can be several
-        Entities with the same ID and EntityType as they can belong to different part.
+    
+    @overload
+    def get_entity_by_key_and_id(self, entitytype: EntityType, entitityid: int, part: str) -> N2PEntity: ...
+    @overload
+    def get_entity_by_key_and_id(self, entitytype: EntityType, entitityid: int) -> list[N2PEntity, ]: ...
+    # Actual implementation
+    def get_entity_by_key_and_id(self, entitytype, entitityid, part=None):
+        """
+        Method that returns a list with the :class:`N2PEntities` objects of the input FEM file asked. There can be 
+        several Entities with the same ID and EntityType as they can belong to different part. If the part is given,
+        only a :class:`N2PEntity` will be returned.
 
         Args:
             entitytype: str
             entitityid: int
+            part: str (optional)
 
         Returns:
-            list[N2PKeyword, ]
+            N2PEntity || list[N2PEntity, ]
         """
         if not isinstance(entitytype, str):
             Exception(N2PLog.Critical.C201())
         elif not isinstance(entitityid, int):
             Exception(N2PLog.Critical.C201())
-        elif entitytype not in ["NODE", "ELEMENT"]:
-            N2PLog.Error.E205()
-            return []
-        else:
+        elif part:
+            entity_error = self.__inputfiledata.GetEntitiesByTypeAndId(entitytype, entitityid, part)
+            if entity_error.Item2 == 0:
+                return self.__dictEntityToN2P[entity_error.Item1]
+            elif entity_error.Item2 == -1:
+                N2PLog.Error.E205(entitytype)
+            elif entity_error.Item2 == -2:
+                N2PLog.Error.E241(part)
+            elif entity_error.Item2 == -3:
+                N2PLog.Error.E242(part, entitityid)
+            return None
+        else: 
             return [self.__dictEntityToN2P[entitytype]
                     for entitytype in self.__inputfiledata.GetEntitiesByTypeAndId(entitytype, entitityid)]
 
     def rebuild_file(self, folder: str) -> None:
-        """Method that writes the solver input file with the same file structure that was read in the folder is specified
+        """
+        Method that writes the solver input file with the same file structure that was read in the folder is specified.
 
         Args:
             folder: str -> Path of the folder where the file or files will be writen

{naxtopy-3.0.0 → naxtopy-3.1.0}/src/NaxToPy/Core/Classes/N2PComponent.py

@@ -21,13 +21,9 @@ from NaxToPy.Core.Classes.N2PNode import N2PNode
 # Clase Component de Python
 # -----------------------------------------------------------------------
 class N2PComponent:
-    '''Class which contains the information associated to a component of a N2PResult instance.
-
-    Attributes:
-        Name: str.
-        Sections: list[N2PSection].
-        IsTransformable: bool.
-    '''
+    """
+    Class which contains the information associated to a component of a  :class:`N2PResult` instance.
+    """
 
     __slots__ = (
         "_name",
@@ -35,10 +31,10 @@ class N2PComponent:
         "_result_father",
     )
 
-    # Constructor de N2PComponent
-    # -----------------------------------------------------------------
+    # Constructor de N2PComponent --------------------------------------------------------------------------------------
     def __init__(self, name, sections, result_father):
-        """ Python Component Constructor
+        """ 
+        Python Component Constructor.
 
             Args:
                 name: str -> name of the component
@@ -49,26 +45,31 @@ class N2PComponent:
         self._sections = [N2PSection(sections[i].Name,
                                         sections[i].Number) for i in range(0, len(sections))]
         self._result_father = result_father
-    # ---------------------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para Obtener el Nombre de la Componente
-    # ----------------------------------------------
+    # Metodo para obtener el Nombre de la Componente -------------------------------------------------------------------
     @property
     def Name(self) -> str:
+        """
+        Name of the component.
+        """
         return(str(self._name))
-    # ---------------------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para Obtener una lista con las secciones de la componente ----------------------------
+    # Metodo para obtener una lista con las secciones de la componente -------------------------------------------------
     @property
     def Sections(self) -> list[N2PSection, ...]:
-        """ Returns a list of N2PSection objects with all the sections contained in the component
+        """ 
+        Returns a list of N2PSection objects with all the sections contained in the component.
         """
         return(self._sections)
-    # ---------------------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
 
+    # Método para comprobar si el resultado es transformable en otro sistema de coordenadas ----------------------------
     @property
     def IsTransformable(self) -> bool:
-        """Property that keeps if the component of a result is transformable in other coordinate system.
+        """
+        Property that keeps if the component of a result is transformable in other coordinate system.
         """
         # 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
@@ -77,23 +78,27 @@ class N2PComponent:
         result = self._result_father.Name
         component = self.Name
         return bool(N2TensorTransformation.IsResultSupported(solver, result, component))
+    # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para llamar a la funcion de NaxToModel que devueleve el array de resultados-----------------------------
+    # Metodo para llamar a la funcion de NaxToModel que devueleve el array de resultados--------------------------------
     def get_result_array(self, sections=None, aveSections=-1, cornerData=False, aveNodes=-1, variation=100,
                          realPolar=0, coordsys: int = -1000,
                          v1: tuple = (1, 0, 0), v2: tuple = (0, 1, 0)) -> tuple[list, str]:
-        """Deprecated method. Please, use get_result_list instead for asking the results as a list. If a numpy array is
-        preferred, use get_result_ndarray"""
+        """
+        Deprecated method. Please, use get_result_list instead for asking the results as a list. If a numpy array is
+        preferred, use get_result_ndarray.
+        """
         return self.get_result_list(sections, aveSections, cornerData, aveNodes, variation,
                                     realPolar, coordsys, v1, v2)
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para llamar a la funcion de NaxToModel que devueleve el array de resultados como lista------------------
+    # Metodo para llamar a la funcion de NaxToModel que devueleve el array de resultados como lista --------------------
     def get_result_list(self, sections=None, aveSections=-1, cornerData=False, aveNodes=-1, variation=100,
                          realPolar=0, coordsys: int = -1000,
                          v1: Union[tuple, np.ndarray] = (1,0,0), v2: Union[tuple, np.ndarray] = (0,1,0)) -> tuple[list, str]:
-        """ Returns a tuple with the list of floats with the result array asked and a str with the position of the
-        results
+        """ 
+        Returns a tuple with the list of floats with the result array asked and a str with the position of the
+        results.
 
         Args:
         
@@ -180,13 +185,14 @@ class N2PComponent:
             return(-1, 'NO RESULTS')
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para llamar a la funcion de NaxToModel que devuelve el array de resultados como array de numpy----------
+    # Metodo para llamar a la funcion de NaxToModel que devuelve el array de resultados como array de numpy ------------
     def get_result_ndarray(self, sections=None, aveSections=-1, cornerData=False, aveNodes=-1, variation=100,
                          realPolar=0, coordsys: int = -1000,
                          v1: Union[tuple, np.ndarray ] = (1,0,0), v2: Union[tuple, np.ndarray ] = (0,1,0),
                          filter_list: list = None) -> tuple[np.array, str]:
-        """ Returns a tuple with the numpy array of floats with the result array asked and a str with the position of
-        the results
+        """ 
+        Returns a tuple with the numpy array of floats with the result array asked and a str with the position of
+        the results.
 
         Args:
 
@@ -275,7 +281,7 @@ class N2PComponent:
         return (self._filter_array(np.array(results[0], np.float64), filter_list, where, None, cornerData), where)
     # ------------------------------------------------------------------------------------------------------------------
 
-    # # Metodo que devulve un dataframe con los resulados tras llamar a la funcion de NaxToModel--
+    # # Metodo que devulve un dataframe con los resulados tras llamar a la funcion de NaxToModel------------------------
     # def get_result_dataframe(self, sections=None, aveSections=-1, cornerData=False, aveNodes=-1,
     #                          variation=100, realPolar=0, coordsys: int = -1000,
     #                          v1: tuple = (1,0,0), v2: tuple = (0,1,0)) -> DataFrame:
@@ -397,7 +403,7 @@ class N2PComponent:
     #         df = df.rename_axis(indexname, axis='index')
     #
     #     return df
-    # # ------------------------------------------------------------------------------------------------------------------
+    # # ----------------------------------------------------------------------------------------------------------------
 
     # Método que devuelve un diccionario con la tupla (LC, Incr) como clave y una lista de resultados como valor -------
     def _get_result_by_LCs_Incr(self, list_lc_incr: list[tuple["N2PLoadCase", "N2PIncrement"],...], components = None,
@@ -447,25 +453,20 @@ class N2PComponent:
                     ii_map = None
 
                 if not components[0]:
-                    py_dict_aux = {
+                    py_dict.update({
                         (int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")), int(key.split(":")[1][2:])) :
                         self._filter_array(np.array(value, np.float64), filter_list, None, ii_map, cornerData)
                         for key, value in dict(cs_dict[0]).items()
-                    }
+                    })
                 else:
-                    py_dict_aux = {
+                    py_dict.update({
                         (int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")), int(key.split(":")[1][2:]), component) :
                         self._filter_array(np.array(value, np.float64), filter_list, None, ii_map, cornerData)
                         for key, value in dict(cs_dict[0]).items()
-                    }
+                    })
                 
                 del cs_dict
-                self._result_father._loadCase_father._modelFather.clear_results_memory()
-                py_dict.update(py_dict_aux)
-
-                # Clear memomry
-                py_dict_aux.clear() 
-                gc.collect()
+                # endfor
 
             if first_shoot:
                 _, _, final_memory = _get_memory_usage()
@@ -477,11 +478,15 @@ class N2PComponent:
                 first_shoot = False
             else:
                 i += n_opt
+
+            # Limpiamos memoria antes de pasar al siguiente bloque de casos de carga
+            self._result_father._loadCase_father._modelFather.clear_results_memory()
+            # endwhile
         
         return py_dict
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo que crea la formula que necesita la funcion de NaxToModel ----------------------------------------------
+    # Metodo que crea la formula que necesita la funcion de NaxToModel -------------------------------------------------
     def _create_formula(self, list_lc_incr: list[tuple["N2PLoadCase", "N2PIncrement"],...]) -> str:
 
         if isinstance(list_lc_incr, tuple):
@@ -532,8 +537,12 @@ class N2PComponent:
                 raise Exception(msg)
 
         elif not self.IsTransformable and (coordsys != -1000 or (v1 != (1, 0, 0) or v2 != (0, 1, 0))):
-            msg = N2PLog.Error.E219()
-            raise Exception(msg)
+            if component:
+                comp = component
+            else:
+                comp = str(self.Name)
+            N2PLog.Warning.W210(comp)
+            resultsParameters = N2ParamInputResults.structResults(0)
 
         else:
             # Initializer if it is no transformable
@@ -622,7 +631,8 @@ class N2PComponent:
         return resultsParameters
     # ------------------------------------------------------------------------------------------------------------------
 
-    def _filter_array(self, array: np.ndarray, filter_list: list[Union[N2PElement, N2PNode]], where=None, ii_map=None, cornerData=False) -> np.ndarray:
+    def _filter_array(self, array: np.ndarray, filter_list: list[Union[N2PElement, N2PNode]], 
+                      where=None, ii_map=None, cornerData=False) -> np.ndarray:
 
         if not filter_list:
             return array
@@ -655,7 +665,8 @@ class N2PComponent:
 
 
 def _get_axis(v1: Union[tuple, np.ndarray], v2: Union[tuple, np.ndarray]) -> np.ndarray:
-    """Function that returns the components of the three vectors of a rectangular coordinate system
+    """
+    Function that returns the components of the three vectors of a rectangular coordinate system.
 
     Args:
         v1: tuple|ndarray
@@ -676,7 +687,9 @@ def _get_axis(v1: Union[tuple, np.ndarray], v2: Union[tuple, np.ndarray]) -> np.
     return np.vstack((v1, y, z))
 
 def _get_memory_usage() -> tuple[float, float, float]:
-    """Returns total_memory, available_memory, used_memory in MB"""
+    """
+    Returns total_memory, available_memory, used_memory in MB.
+    """
 
     class MEMORYSTATUSEX(ctypes.Structure):
         _fields_ = [

{naxtopy-3.0.0 → naxtopy-3.1.0}/src/NaxToPy/Core/Classes/N2PConnector.py

@@ -2,17 +2,8 @@ from NaxToPy.Core.Classes.N2PNode import N2PNode
 
 
 class N2PConnector:
-    """Class of Connectors for NaxToPy. In the module, elements and connectors are separate classes
-
-    Attributes:
-        ID: int.
-        PartID: str.
-        TypeConnector: str.
-        FreeNodes: list[N2PNode].
-        SlaveNodes: list[N2PNode].
-        Grids: list[N2PNode].
-        InternalID: int.
-        RefGrid: N2PNode.
+    """
+    Class of Connectors for NaxToPy. In the module, elements and connectors are separate classes.
     """
 
     __slots__ = (
@@ -21,7 +12,9 @@ class N2PConnector:
     )
 
     def __init__(self, info, model_father):
-        """Python Connector constructor"""
+        """
+        Python Connector constructor
+        """
         self.__info = info
         self.__model = model_father
 
@@ -30,24 +23,36 @@ class N2PConnector:
     # Metodo para obtener el ID conector -------------------------------------------------------------------------------
     @property
     def ID(self) -> int:
+        """
+        ID of the connector.
+        """
         return(int(self.__info.ID))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el ID de la parte del conector ---------------------------------------------------------------
     @property
     def PartID(self) -> str:
+        """
+        Part ID of the connector.
+        """
         return(self.__model._N2PModelContent__partIDtoStr.get(self.__info.Part, -1))
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para obtener el tipo de conector conector -----------------------------------------------------------------
+    # Metodo para obtener el tipo de conector --------------------------------------------------------------------------
     @property
     def TypeConnector(self) -> str:
+        """
+        Connector type.
+        """
         return str(self.__info.tipo)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener los nodos (N2PNode) libres/independientes conector -------------------------------------------
     @property
     def FreeNodes(self) -> list[N2PNode]:
+        """
+        Free Nodes of the connector.
+        """
         # 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.
@@ -59,6 +64,9 @@ class N2PConnector:
     # Metodo para obtener los nodos (N2PNode) esclavos/dependientes del conector ---------------------------------------
     @property
     def SlaveNodes(self) -> list[N2PNode]:
+        """
+        Slaves Nodes of the connector.
+        """
         listaobjetos = [list(self.__model._N2PModelContent__node_dict)[node]
                         for node in list(self.__info.pointsDep)]
         return listaobjetos
@@ -67,6 +75,9 @@ class N2PConnector:
     # Metodo para obtener los nodos (N2PNode) del conector en caso de ser del tipo MPC o RSPLINE -----------------------
     @property
     def GridIDs(self) -> list[N2PNode]:
+        """
+        Nodes (:class:`N2PNode`) of the connector in case it is of type MPC or RSPLINE.
+        """
         listaobjetos = [ list(self.__model._N2PModelContent__node_dict)[node]
                         for node in list(self.__info.gridIDs) ]
         return listaobjetos
@@ -75,12 +86,18 @@ class N2PConnector:
     # Metodo para obtener el id interno (o VTK) del conector -----------------------------------------------------------
     @property
     def InternalID(self) -> int:
+        """
+        Internal ID of the connector.
+        """
         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:
+        """
+        Reference node ID in case the connector is of type RBE3 or COUPLING.
+        """
         return list(self.__model._N2PModelContent__node_dict)[int(self.__info.refGrid)]
     # ------------------------------------------------------------------------------------------------------------------