NaxToPy 2.1.2__tar.gz → 2.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 2.1.2
+Version: 2.2.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
@@ -118,7 +118,7 @@ Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythonnet>=3.0.1
+Requires-Dist: pythonnet>=3.0.3
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: setuptools>=67.8.0
 
@@ -134,20 +134,19 @@ Requires-Dist: setuptools>=67.8.0
 # NaxToPy
 
 **NaxToPy** is the [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US)
-library designed for Python, which allows reading and manipulating FEM
-analysis results files from the most common tools: Nastran (.op2, .xdb, .h5), Abaqus (odb), Optistruct
-(.h3d, .op2) and Ansys (.rst); and stores them in a user-friendly Python structure. Additionally, it
-can read input files from Nastran (.bdf, .fem) and change their contents.
+library designed for Python, allowing users to read and manipulate FEM analysis
+results files from the most common tools: Nastran (op2, xdb, h5), Abaqus (odb), Optistruct (h3d, op2),
+and Ansys (rst). It stores these results in a user-friendly Python structure. Additionally, it can
+read input files from Nastran (bdf/dat), Optistruct (fem) and Abaqus(inp) and modify their contents.
 
-It could be easily combined with other Python packages as Matplotlib or Pandas. This provides access
-to the full coding power of Python to interpret and process the results, without the need to install
-any additional software other than having NaxTo already installed (see the _Download_ and _Homepage_
-links on the left).
+It can easily be combined with other Python packages, such as Matplotlib or Pandas, providing access
+to Python's full coding power for interpreting and processing results without the need to install
+additional software beyond NaxTo (see the Download and Homepage links on the left).
 
 **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.2**. It is compatible with all the steps of this version (2024.2.0, 2024.2.1, 2024.2.2, 2024.2.3, etc.).
+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. 
 
 ## Installation
@@ -290,6 +289,15 @@ when they are asked and not all at once.
 3. The function import_results_from_files() checks if the file exist. If not, it prints an error
 but the execution doesn't crash.
 
+### v.2.2.0
+1. Feat: New module for fastener analysis: N2PGetFasteners.
+2. Feat: New module for fastener analysis: N2PGetLoadFasteners. Calculates forces in joints and bypass forces.
+3. Bug fix: When a NaxToPy executable file is used on a machine where NaxTo is installed, the libraries are selected accordingly.
+4. Feat: Hidden imports are now allowed in n2ptoexe.
+5. Bug fix: Fixed the rotation of the FORCES tensor. Now the QX and QY components (transverse shears) are calculated correctly.
+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.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -308,7 +316,9 @@ NaxToPy only use three dependeces:
 - **Ansys:** .rst, .rth(beta)
 
 ### Input files:
-- **Nastran** (bdf)
+- **Nastran** (.bdf)
+- **Optistruct** (.fem)
+- **Abaqus** (.inp)
 
 ## Initialize your model
 

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

@@ -10,20 +10,19 @@
 # NaxToPy
 
 **NaxToPy** is the [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US)
-library designed for Python, which allows reading and manipulating FEM
-analysis results files from the most common tools: Nastran (.op2, .xdb, .h5), Abaqus (odb), Optistruct
-(.h3d, .op2) and Ansys (.rst); and stores them in a user-friendly Python structure. Additionally, it
-can read input files from Nastran (.bdf, .fem) and change their contents.
+library designed for Python, allowing users to read and manipulate FEM analysis
+results files from the most common tools: Nastran (op2, xdb, h5), Abaqus (odb), Optistruct (h3d, op2),
+and Ansys (rst). It stores these results in a user-friendly Python structure. Additionally, it can
+read input files from Nastran (bdf/dat), Optistruct (fem) and Abaqus(inp) and modify their contents.
 
-It could be easily combined with other Python packages as Matplotlib or Pandas. This provides access
-to the full coding power of Python to interpret and process the results, without the need to install
-any additional software other than having NaxTo already installed (see the _Download_ and _Homepage_
-links on the left).
+It can easily be combined with other Python packages, such as Matplotlib or Pandas, providing access
+to Python's full coding power for interpreting and processing results without the need to install
+additional software beyond NaxTo (see the Download and Homepage links on the left).
 
 **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.2**. It is compatible with all the steps of this version (2024.2.0, 2024.2.1, 2024.2.2, 2024.2.3, etc.).
+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. 
 
 ## Installation
@@ -166,6 +165,15 @@ when they are asked and not all at once.
 3. The function import_results_from_files() checks if the file exist. If not, it prints an error
 but the execution doesn't crash.
 
+### v.2.2.0
+1. Feat: New module for fastener analysis: N2PGetFasteners.
+2. Feat: New module for fastener analysis: N2PGetLoadFasteners. Calculates forces in joints and bypass forces.
+3. Bug fix: When a NaxToPy executable file is used on a machine where NaxTo is installed, the libraries are selected accordingly.
+4. Feat: Hidden imports are now allowed in n2ptoexe.
+5. Bug fix: Fixed the rotation of the FORCES tensor. Now the QX and QY components (transverse shears) are calculated correctly.
+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.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -184,7 +192,9 @@ NaxToPy only use three dependeces:
 - **Ansys:** .rst, .rth(beta)
 
 ### Input files:
-- **Nastran** (bdf)
+- **Nastran** (.bdf)
+- **Optistruct** (.fem)
+- **Abaqus** (.inp)
 
 ## Initialize your model
 

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

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "NaxToPy"
-version = "2.1.2"
+version = "2.2.0"
 license = {file = "LICENSE"}
 authors = [ { name = "Idaero Solutions", email = "manuel.sanchez@idaerosolutions.com" }, ]
 requires-python = ">=3.9"
-dependencies = ["pythonnet>=3.0.1",
+dependencies = ["pythonnet>=3.0.3",
                 "numpy>=1.22.0",
                 "setuptools>=67.8.0",
                 ]

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQEntities/N2PEntity.py

@@ -0,0 +1,28 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PEntity:
+    """Class created to add information under a Keyword. There is not a similar concept in Abaqus. It is used to define
+    nodes, elements and shells."""
+
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        self.__info = info
+        self.__dictKeywordToN2P = dictKeywordToN2P
+        self.__dictEntityToN2P = dictEntityToN2P
+
+    @property
+    def KeywordParent(self) -> N2PKeyword:
+        """Keyword the entity belongs to. It always belongs to a keyword"""
+        return self.__dictKeywordToN2P[self.__info.KeywordParent]
+
+    @property
+    def KeywordIndex(self) -> int:
+        """Identification number of the Keyword ot belongs"""
+        return self.__info.KeywordIndex
+
+    @property
+    def Part(self) -> str:
+        """The part of an entity is always the part of the KeywordParent"""
+        return self.KeywordParent.Part

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQEntities/N2PEntityElement.py

@@ -0,0 +1,19 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQEntities.N2PEntity import N2PEntity
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityNode import N2PEntityNode
+
+
+class N2PEntityElement(N2PEntity):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def ID(self) -> int:
+        """Element identification number"""
+        return self._N2PEntity__info.ID
+
+    @property
+    def NodeArray(self) -> list[N2PEntityNode, ]:
+        """Element identification number"""
+        return [self._N2PEntity__dictEntityToN2P[node] for node in self._N2PEntity__info.NodeArray]

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQEntities/N2PEntityNode.py

@@ -0,0 +1,46 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQEntities.N2PEntity import N2PEntity
+
+
+class N2PEntityNode(N2PEntity):
+
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+        
+    @property
+    def ID(self) -> int:
+        """Node identification number"""
+        return self._N2PEntity__info.ID
+
+    @property
+    def X1(self) -> float:
+        """First coordinate"""
+        return self._N2PEntity__info.ID
+
+    @property
+    def X2(self) -> float:
+        """Second coordinate"""
+        return self._N2PEntity__info.ID
+
+    @property
+    def X3(self) -> float:
+        """Third coordinate"""
+        return self._N2PEntity__info.ID
+
+    @property
+    def DirectionCosine1(self) -> float:
+        """First direction cosine of the normal at the node (Optional)"""
+        return self._N2PEntity__info.DirectionCosine1
+
+    @property
+    def DirectionCosine2(self) -> float:
+        """ Second direction cosine of the normal at the node (Optional)
+        For nodes entered a cylindrical or spherical system, this entry is an angle given in degrees."""
+        return self._N2PEntity__info.DirectionCosine2
+
+    @property
+    def DirectionCosine3(self) -> float:
+        """ Third direction cosine of the normal at the node (Optional)
+        For nodes entered a spherical system, this entry is an angle given in degrees."""
+        return self._N2PEntity__info.DirectionCosine3

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQEntities/N2PEntityShell.py

@@ -0,0 +1,34 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQEntities.N2PEntity import N2PEntity
+
+
+class N2PEntityShell(N2PEntity):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Name(self) -> str:
+        """Name of the layer"""
+        return self._N2PEntity__info.Name
+
+    @property
+    def Thickness(self) -> float:
+        """Shell thickness"""
+        return self._N2PEntity__info.Thickness
+
+    @property
+    def IntegrationPoints(self) -> int:
+        """Number of integration points to be used through the shell section. Default: five for Simpson's rule and 3 for Gauss quadrature """
+        return self._N2PEntity__info.IntegrationPoints
+
+    @property
+    def Material(self) -> N2PKeyword:
+        """Node identification number"""
+        return self._N2PEntity__dictKeywordToN2P[self._N2PEntity__info.Material]
+
+    @property
+    def Orientation(self) -> N2PKeyword:
+        """Node identification number"""
+        return self._N2PEntity__dictKeywordToN2P.get(self._N2PEntity__info.Orientation)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQEntities/__init__.py

@@ -0,0 +1,4 @@
+from NaxToPy.Core.Classes.ABQEntities.N2PEntity import N2PEntity
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityNode import N2PEntityNode
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityElement import N2PEntityElement
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityShell import N2PEntityShell

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeyword.py

@@ -0,0 +1,43 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.N2PNastranInputData import N2PInputData
+
+
+class N2PKeyword(N2PInputData):
+
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info)
+        self.__info = info
+        self.__dictKeywordToN2P = dictKeywordToN2P
+        self.__dictEntityToN2P = dictEntityToN2P
+
+    @property
+    def SuperKeyword(self) -> N2PKeyword:
+        """Keyword that this one depends on"""
+        return self._N2PKeyword__dictKeywordToN2P.get(self._N2PKeyword__info.SuperKeyword)
+
+    @property
+    def SubKeywords(self) -> list[N2PKeyword, ]:
+        """Keywords that depend on this one"""
+        if self._N2PKeyword__info.SubKeywords:
+            return [self._N2PKeyword__dictKeywordToN2P.get(keyword) for keyword in self._N2PKeyword__info.SubKeywords]
+        else:
+            return []
+
+    @property
+    def Part(self) -> str:
+        """Part of the keyword"""
+        return self.__info.Part
+
+    @property
+    def KeywordType(self) -> str:
+        return self.__info.KeywordType.ToString()
+
+    @property
+    def KeywordCode(self) -> str:
+        """Keyword code: the first field read from a keyword"""
+        return self.__info.KeywordCode
+
+    @property
+    def Parameters(self) -> dict:
+        return dict(self.__info.Parameters)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordBEAMSECTION.py

@@ -0,0 +1,30 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeywordELSET import N2PKeywordELSET 
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQEntities.N2PEntity import N2PEntity
+
+
+class N2PKeywordBEAMSECTION(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Elset(self) -> N2PKeywordELSET:
+        """Set to which the property is applied"""
+        return self._N2PKeyword__dictKeywordToN2P[self._N2PKeyword_N2PKeyword__info.Elset]
+
+    @property
+    def Material(self) -> str:
+        """Material of the elements of the set"""
+        return self._N2PKeyword_N2PKeyword__info.Material
+
+    @property
+    def Name(self) -> str:
+        """Name given to the section"""
+        return self._N2PKeyword__info.Name
+
+    @property
+    def Section(self) -> N2PEntity:
+        """Description"""
+        return self._N2PKeyword__dictEntityToN2P[self._N2PKeyword__info.Section]

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordCOUPLING.py

@@ -0,0 +1,40 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityNode import N2PEntityNode
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeywordSURFACE import N2PKeywordSURFACE
+
+
+class N2PKeywordCOUPLING(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def RefNode(self) -> N2PEntityNode:
+        """Reference node of the coupling"""
+        return self._N2PKeyword__info.RefNode
+
+    @property
+    def Surface(self) -> N2PKeywordSURFACE:
+        """Surface defining the constrained nodes"""
+        return self._N2PKeyword__dictKeywordToN2P[self._N2PKeyword__info.Surface]
+
+    @property
+    def ConstrainedSpareNodes(self) -> list[N2PEntityNode, ]:
+        """Nodes defined in the coupling outside the surface"""
+        return list(self._N2PKeyword__info.ConstrainedSpareNodes)
+
+    @property
+    def ConstrainedNodes(self) -> list[N2PEntityNode, ]:
+        """All the nodes defined in the coupling"""
+        return list(self._N2PKeyword__info.ConstrainedNodes)
+
+    @property
+    def Name(self) -> str:
+        """Name of the Coupling"""
+        return self._N2PKeyword__info.Name
+
+    @property
+    def FreedomDegrees(self) -> list[str]:
+        """List with the degrees of freedom"""
+        return self._N2PKeyword__info.FreedomDegrees

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordDENSITY.py

@@ -0,0 +1,23 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordDENSITY(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Density(self) -> float:
+        """Mass density [ML^-3]"""
+        return self._N2PKeyword__info.Density
+
+    @property
+    def Temperature(self) -> float:
+        """Temperature (optional)"""
+        return self._N2PKeyword__info.Temperature
+
+    @property
+    def FieldVariables(self) -> list[float]:
+        """Field variables (optional)"""
+        return list(self._N2PKeyword__info.FieldVariables)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordDISTRIBUTING.py

@@ -0,0 +1,24 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordDISTRIBUTING(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def FreedomDegrees(self) -> list:
+        """Degrees of freedom of the constraint.
+
+        Format: 123456 for degrees 1-6 constrained; 134 for degrees 1, 3 and 4...
+        """
+        return list(self._N2PKeyword__info.FreedomDegrees)
+
+    @property
+    def WeightingMethod(self) -> str:
+        """Coupling method used to couple the displacement and rotation of the reference node to the average motion of
+        the surface nodes within the influence radius.
+
+        Default: UNIFORM (1.0)"""
+        return self._N2PKeyword__info.WeightingMethod

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordDISTRIBUTINGCOUPLING.py

@@ -0,0 +1,17 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordDISTRIBUTINGCOUPLING(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    # The method overrides the parent class method.
+    @property
+    def WeightingMethod(self) -> str:
+        """Coupling method used to couple the displacement and rotation of the reference node to the average motion of
+        the surface nodes within the influence radius.
+
+        Default: UNIFORM (1.0)"""
+        return self._N2PKeyword__info.WeightingMethod

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordELASTIC.py

@@ -0,0 +1,18 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordELASTIC(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def ElasticType(self) -> str:
+        """Material type for elasticity (isotropic, orthotropic...)"""
+        return self._N2PKeyword__info.ElasticType
+
+    @property
+    def ElasticComponents(self) -> dict[str, float]:
+        """Components of the tensor"""
+        return dict(self._N2PKeyword__info.ElasticComponents)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordELEMENT.py

@@ -0,0 +1,20 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeywordELSET import N2PKeywordELSET
+
+
+class N2PKeywordELEMENT(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+        # When an ELEMENT keyword is used, an ELSET with all that elements is generated if a Name is used
+    @property
+    def ElementList(self) -> list:
+        """List of elements within the keyword"""
+        return [self._N2PKeyword__dictEntityToN2P[element] for element in self._N2PKeyword__info.ElementList]
+
+    @property
+    def ElementType(self) -> str:
+        """String with the type of the element"""
+        return self._N2PKeyword__info.ElementType

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordELSET.py

@@ -0,0 +1,29 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityElement import N2PEntityElement
+
+
+class N2PKeywordELSET(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Name(self) -> str:
+        """Set Name"""
+        return self._N2PKeyword__info.ELSET
+
+    @property
+    def Instance(self) -> str:
+        """If the set is defined under an instance, it shows the name of the instance. It is None otherwise."""
+        return self._N2PKeyword__info.INSTANCE
+
+    @property
+    def Generate(self) -> bool:
+        """Parameter generate (defines the data structure)"""
+        return self._N2PKeyword__info.GENERATE
+
+    @property
+    def ElementList(self) -> list[N2PEntityElement]:
+        """List of elements of the set"""
+        return [self._N2PKeyword__dictEntityToN2P.get(element) for element in self._N2PKeyword__info.ElementList]

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordENDINSTANCE.py

@@ -0,0 +1,9 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordENDINSTANCE(N2PKeyword):
+    """Keyword tha defines the end of an instance"""
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordENDPART.py

@@ -0,0 +1,9 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordENDPART(N2PKeyword):
+    """Keyword tha defines the end of a part"""
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordINSTANCE.py

@@ -0,0 +1,27 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+import numpy as np
+
+from NaxToPy.Core._AuxFunc._NetToPython import _nettonumpy
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordINSTANCE(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Name(self) -> str:
+        """Name of the instance"""
+        return self._N2PKeyword__info.Name
+
+    @property
+    def TranslationComponents(self) -> np.ndarray:
+        """x, y, z values of the translation of the instance"""
+        return _nettonumpy(self._N2PKeyword__info.TranslationComponents)
+
+    @property
+    def RotationComponents(self) -> np.ndarray:
+        """x1, y1, z1 components of the first node that defines the rotation axis;
+        x2, y2, z2 components of the second node that defines the rotation axis;
+        Angle of rotation"""
+        return _nettonumpy(self._N2PKeyword__info.RotationComponents)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordKINEMATIC.py

@@ -0,0 +1,15 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordKINEMATIC(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def FreedomDegrees(self) -> list[str, ]:
+        """Degrees of freedom of the constraint.
+
+        Format: 123456 for degrees 1-6 constrained; 134 for degrees 1, 3 and 4..."""
+        return list(self._N2PKeyword__info.FreedomDegrees)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordKINEMATICCOUPLING.py

@@ -0,0 +1,8 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordKINEMATICCOUPLING(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordMATERIAL.py

@@ -0,0 +1,13 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+
+
+class N2PKeywordMATERIAL(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def Name(self) -> str:
+        """Material Name"""
+        return self._N2PKeyword__info.Name

naxtopy-2.2.0/src/NaxToPy/Core/Classes/ABQKeywords/N2PKeywordNODE.py

@@ -0,0 +1,14 @@
+from __future__ import annotations  # For compatibility with Python 3.9 or higher
+
+from NaxToPy.Core.Classes.ABQKeywords.N2PKeyword import N2PKeyword
+from NaxToPy.Core.Classes.ABQEntities.N2PEntityNode import N2PEntityNode
+
+
+class N2PKeywordNODE(N2PKeyword):
+    def __init__(self, info, dictKeywordToN2P, dictEntityToN2P):
+        super().__init__(info, dictKeywordToN2P, dictEntityToN2P)
+
+    @property
+    def NodeList(self) -> list[N2PEntityNode]:
+        """List of nodes within the keyword"""
+        return [self._N2PKeyword__dictEntityToN2P[node] for node in self._N2PKeyword__info.NodeList]