NaxToPy 2.1.0__tar.gz → 2.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 2.1.0
+Version: 2.1.2
 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
@@ -147,7 +147,7 @@ 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, etc.).
+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.).
 Check in _Programs and Features_ the NaxTo version that is installed. 
 
 ## Installation
@@ -275,6 +275,21 @@ It uses an object instaed of an int.
 3. Formula check in new_derived_loadcase(), new_enevelope_loadcase() and new_derived_component().
 4. New optional arguments if n2ptoexe() to add extra libaries, packages or files.
 
+### v.2.1.1
+1. Two new methods in N2PModelContent: load_user_coord_sys_from_csv() and set_user_coord_sys().
+Also, there is a new property for N2PElement and N2PNode: UserSystemArray. This update allow the
+user to define a different coordinate system for each element or node. To ask for the results
+in this system, the optional argument `coordsys` must be equal to `-20`.
+2. Bug fix: The checking for component and section in new_report() has been fixed. If a comma
+appeared in the component or section name, the method failed.
+
+### v.2.1.2
+1. Internal change for speeding up the read of NastranInputFiles. Now the Nastran Cards are loaded
+when they are asked and not all at once.
+2. Improvement in error handling and log writing.
+3. The function import_results_from_files() checks if the file exist. If not, it prints an error
+but the execution doesn't crash.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

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

@@ -23,7 +23,7 @@ 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, etc.).
+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.).
 Check in _Programs and Features_ the NaxTo version that is installed. 
 
 ## Installation
@@ -151,6 +151,21 @@ It uses an object instaed of an int.
 3. Formula check in new_derived_loadcase(), new_enevelope_loadcase() and new_derived_component().
 4. New optional arguments if n2ptoexe() to add extra libaries, packages or files.
 
+### v.2.1.1
+1. Two new methods in N2PModelContent: load_user_coord_sys_from_csv() and set_user_coord_sys().
+Also, there is a new property for N2PElement and N2PNode: UserSystemArray. This update allow the
+user to define a different coordinate system for each element or node. To ask for the results
+in this system, the optional argument `coordsys` must be equal to `-20`.
+2. Bug fix: The checking for component and section in new_report() has been fixed. If a comma
+appeared in the component or section name, the method failed.
+
+### v.2.1.2
+1. Internal change for speeding up the read of NastranInputFiles. Now the Nastran Cards are loaded
+when they are asked and not all at once.
+2. Improvement in error handling and log writing.
+3. The function import_results_from_files() checks if the file exist. If not, it prints an error
+but the execution doesn't crash.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

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

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

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PComponent.py

@@ -122,6 +122,7 @@ class N2PComponent:
                 0   : Global,
                 -1  : Material Coordinate System,
                 -10 : User defined,
+                -20 : Element/Node User Defined,
                 >0  : Solver ID of the Predefined Coordinate System.
 
             v1: tuple -> Optional.
@@ -214,6 +215,7 @@ class N2PComponent:
                 0   : Global,
                 -1  : Material Coordinate System,
                 -10 : User defined,
+                -20 : Element/Node User Defined,
                 >0  : Solver ID of the Predefined Coordinate System.
 
             v1: tuple -> Optional.
@@ -226,6 +228,12 @@ class N2PComponent:
 
         Returns:
             results: tuple(np.array, str)
+
+        Examples
+            >>> # N2PComponent is a N2PLoadCase.get_results("DISPLACEMENTS").get_component("X")
+            >>> displ_X_array, where = N2PComponent.get_result_ndarray(aveSections=-3, coordsys=-1)
+            >>> # N2PComponent is a N2PLoadCase.get_results("STRESSES").get_component("XX")
+            >>> stress_array, where = N2PComponent.get_result_ndarray(v1=(-1, 0, 0), v2=(0, -1, 0))
         """
         resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
@@ -235,14 +243,14 @@ class N2PComponent:
             resultsParameters, 0)
 
         if results[1] == 1:
-            return(np.array(results[0], np.float64),'NODES')
+            return (np.array(results[0], np.float64),'NODES')
         elif results[1] == 2:
-            return(np.array(results[0], np.float64), 'ELEMENTS')
+            return (np.array(results[0], np.float64), 'ELEMENTS')
         elif results[1] == 3:
-            return(np.array(results[0], np.float64), 'ELEMENT NODAL')
+            return (np.array(results[0], np.float64), 'ELEMENT NODAL')
         else:
             N2PLog.Error.E206(self.Name)
-            return(-1, 'NO RESULTS')
+            return (-1, 'NO RESULTS')
     # ------------------------------------------------------------------------------------------------------------------
 
     # # Metodo que devulve un dataframe con los resulados tras llamar a la funcion de NaxToModel--
@@ -287,6 +295,7 @@ class N2PComponent:
     #             0   : Global,
     #             -1  : Material Coordinate System,
     #             -10 : User defined,
+    #             -20 : Element/Node User Defined,
     #             >0  : Solver ID of the Predefined Coordinate System.
     #
     #         v1: tuple
@@ -442,6 +451,10 @@ class N2PComponent:
                 resultsParameters = N2ParamInputResults.structResults(0)
                 resultsParameters.coordSys = coordsys
 
+            elif coordsys == -20:
+                resultsParameters = N2ParamInputResults.structResults(0)
+                resultsParameters.coordSys = coordsys
+
             else:
                 N2PLog.Error.E220()
                 return (-1, 'NO RESULTS')

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PElement.py

@@ -128,6 +128,21 @@ class N2PElement:
         return [all_centroids[iid, i] for i in range(3)]
     # ------------------------------------------------------------------------------------------------------------------
 
+    # Metodo para el sistema de usuario del elemento -------------------------------------------------------------------
+    @property
+    def UserSystemArray(self) -> list[float, ...]:
+        """
+        Returns list with the position of the three vectors that define the user system of the element:
+        [x1, x2, x3, y1, y2, y3, z1, z2, z3]
+
+        If no user systems for elements are defined yet, it returns None.
+        """
+        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)]
+    # ------------------------------------------------------------------------------------------------------------------
+
     # Special Method for Object Representation -------------------------------------------------------------------------
     def __repr__(self):
         return f"N2PElement({self.ID}, \'{self.PartID}\')"

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PFreeBody.py

@@ -81,11 +81,11 @@ class N2PFreeBody(object):
         else:
             n2fbdsection.OpenFile = self.__model._N2PModelContent__vzmodel
 
-        # Se añaden los nodos usando su id de solver. La parte es la misma para todo y se define antes
+        # Se añaden los nodos usando su id de solver. La parte es la misma para todo_ y se define antes
         for node in self.__nodelist:
             n2fbdsection.NodesId.Add(node.ID)
 
-        # Se añaden los elementos usando su id de solver. La parte es la misma para todo y se define antes
+        # Se añaden los elementos usando su id de solver. La parte es la misma para todo_ y se define antes
         for element in self.__elementlist:
             n2fbdsection.ElementsId.Add(element.ID)
 

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PLoadCase.py

@@ -6,9 +6,9 @@ from typing import Union
 
 # Clase Load Case de Python --------------------------------------------------------------------------------------------
 class N2PLoadCase:
-    '''Class which contains the information associated to a load case instance of N2PLoadCase object
+    """Class which contains the information associated to a load case instance of N2PLoadCase object
 
-    Attrubutes:
+    Attributes:
         ID: int.
         Name: str.
         TypeSolution: str.
@@ -19,8 +19,8 @@ class N2PLoadCase:
         TypeLC: int.
         IsComplex: bool.
         InternalID: int.
+    """
 
-    '''
 
     __increments_by_name__ = dict()
     __increments_by_id__ = dict()
@@ -71,13 +71,13 @@ class N2PLoadCase:
     # Metodo para obtener el numero de identificacion interno del caso de carga ----------------------------------------
     @property
     def ID(self) -> int:
-        return(int(self.__id__))
+        return int(self.__id__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo oara obtener el numero de identificacion original del caso de carga ---------------------------------------
     @property
     def OriginalID(self) -> int:
-        return(int(self.__idoriginal__))
+        return int(self.__idoriginal__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el numero de incrementos dentro del caso de carga --------------------------------------------
@@ -99,7 +99,7 @@ class N2PLoadCase:
     @property
     def IsComplex(self) -> bool:
         """Returns a boolean indicating whether the load case is associated to a complex solution"""
-        return(bool(self.__iscomplex__))
+        return bool(self.__iscomplex__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el tipo de caso de Carga ---------------------------------------------------------------------
@@ -108,13 +108,13 @@ class N2PLoadCase:
         ''' Returns the type of Load Case. RAW -> the load case is extracted from the original file. IMPORTED -> the
         load case has been imported.
         '''
-        return(str(self.__lctype__))
+        return str(self.__lctype__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el nombre del caso de carga ------------------------------------------------------------------
     @property
     def Name(self) -> str:
-        return(str(self.__namelc__))
+        return str(self.__namelc__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el incremento activo. Influye en la funcion de llamada a get_result_array
@@ -129,11 +129,11 @@ class N2PLoadCase:
     # Metodo para establecer el incremento activo. Influye en la funcion de llamada a get_result_array
     @ActiveIncrement.setter
     def ActiveIncrement(self, id: Union[int, str]) -> None:
-        ''' DEPRECATED PROPERTY. Use ActiveN2PIncrement instead. Sets the active increment of the load case. By defult is the last one.
+        """DEPRECATED PROPERTY. Use ActiveN2PIncrement instead. Sets the active increment of the load case. By defult is the last one.
 
         Args:
             id: int | str -> ID or Name of the N2PIncrement
-        '''
+        """
         activincrement = self.get_increments(id).ID
 
         if activincrement is not None:
@@ -141,6 +141,7 @@ class N2PLoadCase:
             N2PLog.Info.I202(id)
         else:
             N2PLog.Error.E207(id)
+        N2PLog.Warning.W206()
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el incremento activo. Influye en la funcion de llamada a get_result_array
@@ -170,13 +171,13 @@ class N2PLoadCase:
     # Metodo para obtener el tipo de solucion del modelo ---------------------------------------------------------------
     @property
     def TypeSolution(self) -> str:
-        return(str(self.__solutiontype__))
+        return str(self.__solutiontype__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el solver del caso de carga ------------------------------------------------------------------
     @property
     def Solver(self) -> str:
-        return(str(self.__solver__))
+        return str(self.__solver__)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Propiedad que devuelve la ruta del fichero desde donde se importo el caso de carga -------------------------------
@@ -230,14 +231,19 @@ class N2PLoadCase:
 
     # Metodo para obtener los incrementos disponibles en el caso de carga ----------------------------------------------
     def get_result(self, name: str) -> N2PResult:
-        ''' Returns the N2PResult object with the Name of the Result
+        """Returns the N2PResult object with the Name of the Result. The name of the results is different depoending on
+        the solver.
 
         Args:
             name: str
 
         Returns:
             result: N2PResult
-        '''
+
+        Examples:
+            >>> displ = N2PLoadCase.get_result("DISPLACEMENT")  # If nastran
+            >>> displ = N2PLoadCase.get_result("U")  # If Abaqus
+        """
 
         # Chequear valor de Name
         if isinstance(name, str):

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PNode.py

@@ -148,6 +148,21 @@ class N2PNode:
         return [celllist[cell_iid] for cell_iid in cs_list]
     # ---------------------------------------------------------------------------------------------
 
+    # Metodo para el sistema de usuario del nodo -----------------------------------------------------------------------
+    @property
+    def UserSystemArray(self) -> list[float, ...]:
+        """
+        Returns list with the position of the three vectors that define the user system of the node:
+        [x1, x2, x3, y1, y2, y3, z1, z2, z3]
+
+        If no user systems for nodes are defined yet, it returns None.
+        """
+        user_system_array = self.__model__._N2PModelContent__vzmodel.NodeUserCoordinateSystems
+        if not user_system_array:
+            return None
+        return [user_system_array[self.InternalID, i] for i in range(9)]
+    # ------------------------------------------------------------------------------------------------------------------
+
     # Special Method for Object Representation -------------------------------------------------------------------------
     def __repr__(self):
         return f"N2PNode({self.ID}, \'{self.PartID}\')"

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PProperty.py

@@ -52,8 +52,6 @@ class N2PProperty(ABC):
     def PropertyType(self) -> str:
         return self.__info__.PropertyType.ToString()
 
-
-
     # Special Method for Object Representation -------------------------------------------------------------------------
     def __repr__(self):
         if self.__model__.Solver == "Abaqus":
@@ -128,56 +126,55 @@ class N2PComp(N2PProperty):
 
     @property
     def EqQMatrix(self) -> list:
-       """
-       Returns the lamina stiffness matrix (Q-Bar)
-       """
-        
-       q11_t = 0
-       q12_t = 0
-       q22_t = 0
-       q16_t = 0
-       q26_t = 0
-       q66_t = 0
-
-       t_thick = sum(self.Thickness) #! is self.Thickness a numpy array?
-
-       for i in range(self.NumPiles):
-           c = math.cos(math.radians(self.Theta[i]))
-           s = math.sin(math.radians(self.Theta[i]))
-
-           thick = self.Thickness[i]
-           rel_thick = thick/t_thick
-
-           mat = self.__model__._N2PModelContent__material_dict[self.MatID[i]]
-
-           s11 = 1 / mat.YoungX
-           s22 = 1 / mat.YoungY
-           s12 = (-1) * mat.PoissonXY / mat.YoungX
-           s66 = 1 / mat.ShearXY if mat.ShearXY != 0.0 else mat.YoungX/(2*(1+mat.PoissonXY))
-
-           # Calculate the terms of the reduced stiffness matrix Q in the laminae coordinate system
-           q11 = s22 / (s11 * s22 - s12 ** 2)
-           q12 = (-1) * s12 / (s11 * s22 - s12 ** 2)
-           q22 = s11 / (s11 * s22 - s12 ** 2)
-           q66 = 1 / s66
-
-           # Calculate the terms of the reduced stiffness matrix Q' in the laminate coordinate system
-           q11_t += (q11 * c ** 4 + 2 * (q12 + 2 * q66) * s ** 2 * c ** 2 + q22 * s ** 4) * rel_thick #! why multiply by the thickness
-           q12_t += ((q11 + q22 - 4 * q66) * s ** 2 * c ** 2 + q12 * (s ** 4 + c ** 4)) * rel_thick
-           q22_t += (q11 * s ** 4 + 2 * (q12 + 2 * q66) * s ** 2 * c ** 2 + q22 * c ** 4) * rel_thick
-           q16_t += ((q11 - q12 - 2 * q66) * s * c ** 3 + (q12 - q22 + 2 * q66) * s ** 3 * c) * rel_thick
-           q26_t += ((q11 - q12 - 2 * q66) * s ** 3 * c + (q12 - q22 + 2 * q66) * s * c ** 3) * rel_thick
-           q66_t += ((q11 + q22 - 2 * q12 - 2 * q66) * s ** 2 * c ** 2 + q66 * (s ** 4 + c ** 4)) * rel_thick
-
-       Q = [[q11_t, q12_t, q16_t],
+        """
+        Returns the lamina stiffness matrix (Q-Bar)
+        """
+
+        q11_t = 0
+        q12_t = 0
+        q22_t = 0
+        q16_t = 0
+        q26_t = 0
+        q66_t = 0
+
+        t_thick = sum(self.Thickness) #! is self.Thickness a numpy array?
+
+        for i in range(self.NumPiles):
+            c = math.cos(math.radians(self.Theta[i]))
+            s = math.sin(math.radians(self.Theta[i]))
+
+            thick = self.Thickness[i]
+            rel_thick = thick/t_thick
+
+            mat = self.__model__._N2PModelContent__material_dict[self.MatID[i]]
+
+            s11 = 1 / mat.YoungX
+            s22 = 1 / mat.YoungY
+            s12 = (-1) * mat.PoissonXY / mat.YoungX
+            s66 = 1 / mat.ShearXY if mat.ShearXY != 0.0 else mat.YoungX/(2*(1+mat.PoissonXY))
+
+            # Calculate the terms of the reduced stiffness matrix Q in the laminae coordinate system
+            q11 = s22 / (s11 * s22 - s12 ** 2)
+            q12 = (-1) * s12 / (s11 * s22 - s12 ** 2)
+            q22 = s11 / (s11 * s22 - s12 ** 2)
+            q66 = 1 / s66
+
+            # Calculate the terms of the reduced stiffness matrix Q' in the laminate coordinate system
+            q11_t += (q11 * c ** 4 + 2 * (q12 + 2 * q66) * s ** 2 * c ** 2 + q22 * s ** 4) * rel_thick #! why multiply by the thickness
+            q12_t += ((q11 + q22 - 4 * q66) * s ** 2 * c ** 2 + q12 * (s ** 4 + c ** 4)) * rel_thick
+            q22_t += (q11 * s ** 4 + 2 * (q12 + 2 * q66) * s ** 2 * c ** 2 + q22 * c ** 4) * rel_thick
+            q16_t += ((q11 - q12 - 2 * q66) * s * c ** 3 + (q12 - q22 + 2 * q66) * s ** 3 * c) * rel_thick
+            q26_t += ((q11 - q12 - 2 * q66) * s ** 3 * c + (q12 - q22 + 2 * q66) * s * c ** 3) * rel_thick
+            q66_t += ((q11 + q22 - 2 * q12 - 2 * q66) * s ** 2 * c ** 2 + q66 * (s ** 4 + c ** 4)) * rel_thick
+
+        Q = [[q11_t, q12_t, q16_t],
             [q12_t, q22_t, q26_t],
             [q16_t, q26_t, q66_t]]
 
-       return Q
+        return Q
 # ----------------------------------------------------------------------------------------------------------------------
-
     
-    def QMatrix(self,i) -> np.ndarray:
+    def QMatrix(self, i) -> np.ndarray:
         """
         Returns the lamina stiffness matrix (Q-Bar) as a numpy 2D array
         | σx |       |  ε  |
@@ -215,8 +212,9 @@ class N2PComp(N2PProperty):
 
         try:
             T_inv = np.linalg.inv(T)
-        except:
-            print("ERROR: npQmatrix>>Inversion of rotation matrix failed.") # should not happen                       
+        except Exception as e:
+            msg = N2PLog.Error.E315()
+            raise Exception(msg)
 
         # From Jones pg50-51: [sigma] = [T]**(-1)*[Q]*[T]**(-1) [eps] = [Q_bar]*[eps]
 
@@ -235,37 +233,38 @@ class N2PComp(N2PProperty):
 
         # Nótese que las unidades de las matrices de rigidez ABD deben ser consistentes: A [N/m], B [N] y D [N·m].
 
-        A = np.zeros([3,3],float)
-        B = np.zeros([3,3],float)
-        D = np.zeros([3,3],float)
+        A = np.zeros([3, 3], float)
+        B = np.zeros([3, 3], float)
+        D = np.zeros([3, 3], float)
 
         if self.NumPiles < 0:               # SYMMETRIC LAMINATE 
             Nply = abs(self.NumPiles)       # in this case Nply = half the real number of plies     
             t_thick = sum(self.Thickness)*2
             low_reference = - sum(self.Thickness)
-            iterplies = np.pad(np.arange(0,Nply),(0,Nply),'symmetric') # e.g.: transforms [0,1,2] in [0,1,2,2,1,0]
+            iterplies = np.pad(np.arange(0,Nply), (0,Nply), 'symmetric')  # e.g.: transforms [0,1,2] in [0,1,2,2,1,0]
         else:                               # NON-SYMMETRIC LAMINATE
             Nply = self.NumPiles            # in this case Nply 0 real number of plies
             t_thick = sum(self.Thickness)
             low_reference = - sum(self.Thickness) / 2
-            iterplies = np.arange(0,Nply)
+            iterplies = np.arange(0, Nply)
         
         for i in iterplies:
             
-            thick = self.Thickness[i] # tener en cuenta caso simetrico
+            thick = self.Thickness[i]  # tener en cuenta caso simetrico
             centroid = low_reference + thick/2            
 
-            Q_bar = self.QMatrix(i) # get Q_bar of the lamina in the laminate coordinate system
+            Q_bar = self.QMatrix(i)  # get Q_bar of the lamina in the laminate coordinate system
 
             # Calculate A, B, C matrices in the laminate coordinate system
-            A += Q_bar*thick # extensional_matrix
-            B += Q_bar * centroid * thick # bending_matrix
-            D += Q_bar * ((centroid)**2 * thick + (thick**3)/12) # coupling_matrix
+            A += Q_bar*thick  # extensional_matrix
+            B += Q_bar * centroid * thick  # bending_matrix
+            D += Q_bar * (centroid**2 * thick + (thick**3)/12)  # coupling_matrix
 
             low_reference += thick
 
         return A, B, D
 
+
 # Clase para definir propiedades de tipo placa -------------------------------------------------------------------------
 class N2PShell(N2PProperty):
     """
@@ -316,7 +315,7 @@ class N2PShell(N2PProperty):
 # ----------------------------------------------------------------------------------------------------------------------
 
 
-# Clase para definir propiedades de tipo solido -------------------------------------------------------------------------
+# Clase para definir propiedades de tipo solido ------------------------------------------------------------------------
 class N2PSolid(N2PProperty):
     """
     Class for defining solid properties. It derives from N2PProperty.

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Classes/N2PResult.py

@@ -34,7 +34,7 @@ class N2PResult:
         self.__description__ = description
         self.__elem_types__ = elemTypes
         self.__fcode__ = fcode
-        self.__name__ = name
+        self.__name = name
         self.__loadCase_father__ = loadCase_father
     # ---------------------------------------------------------------------------------------------
 
@@ -61,7 +61,7 @@ class N2PResult:
     # Metodo para obtener la descripcion del resultado --------------------------------------------
     @property
     def Description(self) -> str:
-        return(self.__description__)
+        return self.__description__
     # ----------------------------------------------------------------------------------------------
 
     # Metodo para obtener los tipos de elemento en los cuales se han obtenido resultados -----------
@@ -69,19 +69,19 @@ class N2PResult:
     def TypesElements(self) -> list[str]:
         """Returns a list with the element types where results are available.
         """
-        return(list(self.__elem_types__))
+        return list(self.__elem_types__)
     # ---------------------------------------------------------------------------------------------
 
     # Metodo para obtener el format code del resultado -> PREGUNTAR A ROBERTO OP2??? --------------
     @property
     def FormatCode(self) -> str:
-        return(str(self.__fcode__))
+        return str(self.__fcode__)
     # ---------------------------------------------------------------------------------------------
 
     # Metodo para obtener el nombre del resultado -------------------------------------------------
     @property
     def Name(self) -> str:
-        return(str(self.__name__))
+        return str(self.__name)
     # ---------------------------------------------------------------------------------------------
 
     # Metodo para obtener las componentes disponibles en el resultado -----------------------------

{naxtopy-2.1.0 → naxtopy-2.1.2}/src/NaxToPy/Core/Constants/Constants.py

@@ -1,14 +1,14 @@
 """Constants of the NaxToPy package"""
 
 # NaxToPy Version
-VERSION = "2.1.0"
+VERSION = "2.1.2"
 
 # Supported for Naxto:
 NAXTO_VERSION = '2024R2'
-NAXTO_STEP = "0"
+NAXTO_STEP = "3"
 
 # Assembly version of NaxToModel.dll
-VIZZER_COMPATIBILITY = ("4.2.0.0")
+VIZZER_COMPATIBILITY = ("4.2.0.0", "4.2.0.1", "4.2.0.2", "4.2.0.3")
 """Tuple with the compatible versions of NaxToModel.dll"""
 
 # PYTHON EXTERNO ----------------------------------------------------------------------------------