NaxToPy 1.5.6__tar.gz → 2.0.1__tar.gz

{NaxToPy-1.5.6 → naxtopy-2.0.1}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Idaero Solutions
+Copyright (c) 2024 Idaero Solutions
 
 This freeware license agreement (“agreement”) is a legally binding contract
 between the individual who downloads the software (“you”) and the licensor,

{NaxToPy-1.5.6/src/NaxToPy.egg-info → naxtopy-2.0.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 1.5.6
+Version: 2.0.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
 Author-email: Idaero Solutions <manuel.sanchez@idaerosolutions.com>
-License: Copyright (c) 2023 Idaero Solutions
+License: Copyright (c) 2024 Idaero Solutions
         
         This freeware license agreement (“agreement”) is a legally binding contract
         between the individual who downloads the software (“you”) and the licensor,
@@ -135,9 +135,9 @@ Requires-Dist: setuptools>=67.8.0
 
 **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 it contents.
+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.
 
 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
@@ -146,15 +146,19 @@ links on the left).
 
 **NaxToPy** is a powerful tool for FEM analysis post-processing!
 
-**CAUTION:** This version is only compatible with **NaxTo 2024.0.5**.
-Check in _Programs and Features_ the NaxTo version that is installed.
+**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.1**. It is compatible with all the steps of this version (2024.1.0, 2024.1.1, 2024.1.2, etc.).
+Check in _Programs and Features_ the NaxTo version that is installed. 
 
 ## Installation
 
+If python is installed and `pip` is added to the PATH:
 
-If python is callable from the command line:
+`pip install NaxToPy`
+
+An alternative, if Python is callable from the command line:
 
-`py -m pip install NaxToPy`
+`python -m pip install NaxToPy`
 
 For **Visual Studio** users:
 - Open "Python Environments" window
@@ -178,7 +182,7 @@ same directory. When ever you want to use the NaxToPy package add the following
 
 If python is callable from the command line:
 
-`py -m pip install -U NaxToPy`
+`python -m pip install -U NaxToPy`
 
 For Visual Studio users:
 - Open "Python Environments" window
@@ -254,6 +258,17 @@ To see previous version see the pre-release versions in https://test.pypi.org/pr
 1. The method new_envelope_loadcase() now has the option to choose the envelope group. Which means the user can ask for
 the LoadCases that are critical or the Increment that is critical instead of the value.
 
+### v.2.0.0
+1. Changes made to align the library with updates in lower-level dependencies.
+2. New internal methods to look for the compatibility with low-level dependencies.
+3. The name of the .log is now NaxToPy_Year-Month-Day.log.
+
+### v.2.0.1
+1. The compatibility is extended to all NaxTo steps of the same version.
+2. The property N2PLoadCase.ActiveIncrement is subtitued by N2PLoadCase.ActiveN2PIncrement.
+It uses an object instaed of an int.
+3. Update of the examples of some docstrings.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -333,7 +348,7 @@ loadcaseslist = model.LoadCases
 pressure_lc = model.get_load_case("pressure")
 
 # Change the active increment (by default is the last one):
-pressure_lc.ActiveIncrement = 10
+pressure_lc.ActiveN2PIncrement = pressure_lc.get_increment(10)
 
 # Look for all results
 all_results = pressure_lc.Results

{NaxToPy-1.5.6 → naxtopy-2.0.1}/README.md

@@ -11,9 +11,9 @@
 
 **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 it contents.
+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.
 
 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
@@ -22,15 +22,19 @@ links on the left).
 
 **NaxToPy** is a powerful tool for FEM analysis post-processing!
 
-**CAUTION:** This version is only compatible with **NaxTo 2024.0.5**.
-Check in _Programs and Features_ the NaxTo version that is installed.
+**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.1**. It is compatible with all the steps of this version (2024.1.0, 2024.1.1, 2024.1.2, etc.).
+Check in _Programs and Features_ the NaxTo version that is installed. 
 
 ## Installation
 
+If python is installed and `pip` is added to the PATH:
 
-If python is callable from the command line:
+`pip install NaxToPy`
+
+An alternative, if Python is callable from the command line:
 
-`py -m pip install NaxToPy`
+`python -m pip install NaxToPy`
 
 For **Visual Studio** users:
 - Open "Python Environments" window
@@ -54,7 +58,7 @@ same directory. When ever you want to use the NaxToPy package add the following
 
 If python is callable from the command line:
 
-`py -m pip install -U NaxToPy`
+`python -m pip install -U NaxToPy`
 
 For Visual Studio users:
 - Open "Python Environments" window
@@ -130,6 +134,17 @@ To see previous version see the pre-release versions in https://test.pypi.org/pr
 1. The method new_envelope_loadcase() now has the option to choose the envelope group. Which means the user can ask for
 the LoadCases that are critical or the Increment that is critical instead of the value.
 
+### v.2.0.0
+1. Changes made to align the library with updates in lower-level dependencies.
+2. New internal methods to look for the compatibility with low-level dependencies.
+3. The name of the .log is now NaxToPy_Year-Month-Day.log.
+
+### v.2.0.1
+1. The compatibility is extended to all NaxTo steps of the same version.
+2. The property N2PLoadCase.ActiveIncrement is subtitued by N2PLoadCase.ActiveN2PIncrement.
+It uses an object instaed of an int.
+3. Update of the examples of some docstrings.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -209,7 +224,7 @@ loadcaseslist = model.LoadCases
 pressure_lc = model.get_load_case("pressure")
 
 # Change the active increment (by default is the last one):
-pressure_lc.ActiveIncrement = 10
+pressure_lc.ActiveN2PIncrement = pressure_lc.get_increment(10)
 
 # Look for all results
 all_results = pressure_lc.Results

{NaxToPy-1.5.6 → naxtopy-2.0.1}/pyproject.toml

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

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PComponent.py

@@ -1,7 +1,7 @@
 from NaxToPy.Core.Classes.N2PSection import N2PSection
 from NaxToPy.Core.Errors.N2PLog import N2PLog
-from VizzerClasses import N2ParamInputResults
-from VizzerClasses import N2TensorTransformation
+from NaxToModel import N2ParamInputResults
+from NaxToModel import N2TensorTransformation
 from array import array
 import numpy as np
 from NaxToPy.Core._AuxFunc._NetToPython import _numpytonet
@@ -31,7 +31,7 @@ class N2PComponent:
         """
         self.__name__ = name
         self.__sections__ = [N2PSection(sections[i].Name,
-                                        sections[i].number) for i in range(0, len(sections))]
+                                        sections[i].Number) for i in range(0, len(sections))]
         self.__result_father__ = result_father
     # ---------------------------------------------------------------------------------------------
 
@@ -62,7 +62,7 @@ class N2PComponent:
         component = self.Name
         return bool(N2TensorTransformation.IsResultSupported(solver, result, component))
 
-    # Metodo para llamar a la funcion de VizzerClasses 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]:
@@ -72,7 +72,7 @@ class N2PComponent:
                                     realPolar, coordsys, v1, v2)
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para llamar a la funcion de VizzerClasses 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]:
@@ -136,7 +136,7 @@ class N2PComponent:
             results: tuple(list[float], str)
 
         """
-        # Aquí se prepara la llamada a la funcion de VizzerClasses.N2PModelContent.getArraytoPlot(). Esta usa como
+        # Aquí se prepara la llamada a la funcion de NaxToModel.N2PModelContent.getArraytoPlot(). Esta usa como
         # argumento un objeto de la clase N2ParamImputResults. Por se instancia y se modifican sus propiedades antes
         # de hacer la llamada a la funcion.
 
@@ -164,7 +164,7 @@ class N2PComponent:
             return(-1, 'NO RESULTS')
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para llamar a la funcion de VizzerClasses 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)) -> tuple[np.array, str]:
@@ -245,7 +245,7 @@ class N2PComponent:
             return(-1, 'NO RESULTS')
     # ------------------------------------------------------------------------------------------------------------------
 
-    # # Metodo que devulve un dataframe con los resulados tras llamar a la funcion de VizzerClasses--
+    # # 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:
@@ -392,7 +392,7 @@ class N2PComponent:
         return py_dict
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo que crea la formula que necesita la funcion de VizzerClasses ----------------------------------------------
+    # 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):

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PElement.py

@@ -1,7 +1,7 @@
 import array
 
 from NaxToPy.Core.Classes.N2PNode import N2PNode
-from VizzerClasses import N2ElementsCoordinateSystems
+from NaxToModel import N2ElementsCoordinateSystems
 
 # Clase Element de Python
 class N2PElement:

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PFreeBody.py

@@ -1,6 +1,6 @@
 """ Module with all the FreeBody related classes.
 """
-from VizzerClasses import N2FBDSection, N2FBD, N2FBDResult
+from NaxToModel import N2FBDSection, N2FBD, N2FBDResult
 from NaxToPy.Core.Classes.N2PNode import N2PNode
 from NaxToPy.Core.Classes.N2PElement import N2PElement
 from NaxToPy.Core.Classes.N2PCoord import N2PCoord
@@ -61,7 +61,7 @@ class N2PFreeBody(object):
         else:
             self.__centroid = True
 
-        # Llamada al constructor de VizzerClasses
+        # Llamada al constructor de NaxToModel
         n2fbdsection = N2FBDSection(self.__name)
 
         # Se incluye la parte:

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PIncrement.py

@@ -1,64 +1,52 @@
 # Clase Increment de Python --------------------------------------------------------------------------------------------
 class N2PIncrement:
-    '''Class which contains the information associated to an increment/frame of a N2PLoadCase instance.
-
-    Attributes:
-        Name: str.
-        ImaginaryEigenvalue: float.
-        RealEigenvalue: float.
-        ID: int.
-        Time: double.
-    '''
+    """Class which contains the information associated to an increment/frame of a N2PLoadCase instance."""
 
     # Constructor de N2PIncrement --------------------------------------------------------------------------------------
-    def __init__(self, name, eigi, eigr, number, time):
-        '''Python Increment Constructor
-            Input:
-                name: str -> name of the increment
-                eigi: double -> value of the imaginary eigenvalue
-                eigr: double -> value of the real eigenvalue
-                number: int -> number of the increment within the sequence of increments in the load case
-                time: double -> value of the increment
-            ----------
-            Returns:
-                N2PIncrement: object
-        '''
-        self.__name__ = name
-        self.__eigi__ = eigi
-        self.__eigr__ = eigr
-        self.__number__ = number
-        self.__time__ = time
+    def __init__(self, info):
+        self.__info__ = info
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el nombre del incremento ---------------------------------------------------------------------
     @property
     def Name(self) -> str:
-        return(str(self.__name__))
+        """Name of the Increment"""
+        return(str(self.__info__.Name))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el valor del autovalor real ------------------------------------------------------------------
     @property
     def RealEigenvalue(self) -> float:
-        return(float(self.__eigr__))
+        """Real Eigenvalue of the increment"""
+        return(float(self.__info__.EigReal))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el valor del autovalor imaginario ------------------------------------------------------------
     @property
     def ImaginaryEigenvalue(self) -> float:
-        return(float(self.__eigi__))
+        """Imaginary Eigenvalue of the increment"""
+        return(float(self.__info__.EigImg))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el ID del incremento en el caso de carga -----------------------------------------------------
     @property
     def ID(self) -> int:
-        return(int(self.__number__))
+        """Solver ID of the Increment"""
+        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.__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))
     # ------------------------------------------------------------------------------------------------------------------
 
     # Special Method for Object Representation -------------------------------------------------------------------------

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PLoadCase.py

@@ -46,27 +46,23 @@ class N2PLoadCase:
         self.__id__ = id
         self.__idoriginal__ = id_original
 
-        self.__increments__ = [N2PIncrement(increments[i].Name,
-                                            increments[i].eigi,
-                                            increments[i].eigr,
-                                            increments[i].number,
-                                            increments[i].time) for i in range(0, len(increments))]
+        self.__increments__ = [N2PIncrement(increments[i]) for i in range(0, len(increments))]
 
         self.__incrementsnumberlist__ = increments_number_list
         self.__iscomplex__ = is_complex
         self.__lctype__ = lc_type
         self.__namelc__ = name
-        self.__results__ = {results[i].name: N2PResult(results[i].Components,
+        self.__results__ = {results[i].Name: N2PResult(results[i].Components,
                                                        results[i].Position,
                                                        results[i].derivedComps,
-                                                       results[i].description,
+                                                       results[i].Description,
                                                        results[i].elemTypes,
                                                        results[i].fcode,
-                                                       results[i].name,
+                                                       results[i].Name,
                                                        self) for i in range(0, len(results))}
 
         self.__solutiontype__ = solution_type
-        self.__activeIncrement__ = list(increments)[-1].number
+        self.__activeIncrement__ = list(increments)[-1].ID
         self.__solver__ = solver
         self.__modelFather__ = model_father
         self.__n2loadcase = n2loadcase
@@ -123,15 +119,17 @@ class N2PLoadCase:
 
     # Metodo para obtener el incremento activo. Influye en la funcion de llamada a get_result_array
     @property
-    def ActiveIncrement(self) -> str:
-        ''' Returns the active increment of the load case. By default, is the last one.'''
+    def ActiveIncrement(self) -> int:
+        """DEPRECATED PROPERTY. Use ActiveN2PIncrement.ID instaed. Returns the active increment of the load case. By
+        default, is the last one."""
+        N2PLog.Warning.W206()
         return self.__activeIncrement__
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para obtener el incremento activo. Influye en la funcion de llamada a get_result_array
+    # 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:
-        ''' 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
@@ -145,6 +143,24 @@ class N2PLoadCase:
             N2PLog.Error.E207(id)
     # ------------------------------------------------------------------------------------------------------------------
 
+    # Metodo para obtener el incremento activo. Influye en la funcion de llamada a get_result_array
+    @property
+    def ActiveN2PIncrement(self) -> N2PIncrement:
+        """Returns the active increment of the load case. By default, is the last one."""
+        return self.get_increments(self.__activeIncrement__)
+    # ------------------------------------------------------------------------------------------------------------------
+
+    # Metodo para establecer el incremento activo. Influye en la funcion de llamada a get_result_array
+    @ActiveN2PIncrement.setter
+    def ActiveN2PIncrement(self, incr: N2PIncrement) -> None:
+        """Sets the active increment of the load case. By defult is the last one.
+
+        Args:
+            incr: N2PIncrement -> ID or Name of the N2PIncrement
+        """
+        self.__activeIncrement__ = incr.ID
+    # ------------------------------------------------------------------------------------------------------------------
+
     # Metodo como propiedad que devuelve todos los N2PResult. Es igual que llamar a get_results sin
     # parametros
     @property

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PModelInputData.py

@@ -47,9 +47,9 @@ class N2PInputData:
     def Lines(self) -> list[str, ...]:
         return list(self.__inputdata.Lines)
 
-    # @property
-    # def FilePathId(self) -> str:
-    #     return self.__inputdata.FilePathId
+    @property
+    def FilePathId(self) -> int:
+        return self.__inputdata.FilePathId
 
     # @property
     # def Children(self) -> list["N2PInputData"]:
@@ -127,6 +127,9 @@ class N2PModelInputData:
     def __init__(self, listbulkdatacards, inputfiledata):
         self.__listbulkdatacards = listbulkdatacards
         self.__inputfiledata = inputfiledata
+        self.__listinstructions = []
+        self.__listcomments = []
+        self.__dictionary_files_ids = {value: key for key, value in self.DictionaryIDsFiles.items()}
 
     @property
     def ListBulkDataCards(self) -> list[N2PCard, ...]:
@@ -137,10 +140,33 @@ class N2PModelInputData:
     def DictionaryIDsFiles(self) -> dict:
         return dict(self.__inputfiledata.DictionaryIDsFiles)
 
+    @property
+    def DictionaryFilesIDs(self) -> dict:
+        return dict(self.__dictionary_files_ids)
+
     @property
     def TypeOfFile(self) -> str:
         return self.__inputfiledata.TypeOfFile.ToString()
 
+    @property
+    def ListInstructions(self) -> list[N2PInputData]:
+        """List with the instructions of the model. They are the commands above the BEGIN BULK: Executive Control
+        Statements and Control Case Commands"""
+        if self.__listinstructions:
+            return self.__listinstructions
+        else:
+            self.__listinstructions = [N2PInputData(i) for i in self.__inputfiledata.StructuredInfo.ModelInstructions]
+            return self.__listinstructions
+
+    @property
+    def ListComments(self) -> list[N2PInputData]:
+        """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_cards_by_field(self, fields: list[str, ], row: int = 0, col: int = 0) -> list[N2PCard, ]:
         """Method that returns a list with the N2PCard objects of the input FEM file that meet the condition.
         In other words, that field is equal to the string in the position defined. If no row or column is defined, the

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PNode.py

@@ -1,6 +1,6 @@
 import array
 import time
-from VizzerClasses.Classes import N2AdjacencyFunctions
+from NaxToModel.Classes import N2AdjacencyFunctions
 
 
 class N2PNode:

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PReport.py

@@ -7,7 +7,7 @@ from NaxToPy.Core.Classes.N2PComponent import _get_axis
 from NaxToPy.Core._AuxFunc._NetToPython import _numpytonet
 import numpy as np
 from typing import Union
-from VizzerClasses import N2Report, N2ParamInputResults, N2Enums
+from NaxToModel import N2Report, N2ParamInputResults, N2Enums
 from System import Object, Array
 
 

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Classes/N2PResult.py

@@ -1,6 +1,6 @@
 from NaxToPy.Core.Classes.N2PComponent import N2PComponent
 from NaxToPy.Core.Errors.N2PLog import N2PLog
-from VizzerClasses import N2Component
+from NaxToModel import N2Component
 from System.Collections.Generic import List
 
 
@@ -84,7 +84,31 @@ class N2PResult:
 
     # Metodo para obtener las componentes disponibles en el resultado -----------------------------
     def get_component(self, name: str) -> N2PComponent:
-        """Returns a N2Component as component with name specified
+        """Returns a N2Component as component with name specified. It can be a Raw Component or a derived component
+
+        Args:
+            name: str
+
+        Returns:
+            component: N2PComponent
+        """
+
+        if isinstance(name, str):
+            component = self.Components.get(name, None)
+            if not component:
+                component = self.DerivedComponents.get(name, None)
+            if component is None:
+                N2PLog.Error.E215(name)
+            return component
+
+        # Devolver todos los resultados
+        else:
+            N2PLog.Error.E216()
+    # ---------------------------------------------------------------------------------------------
+
+    # Metodo para obtener las componentes originales disponibles en el resultado -----------------------------
+    def get_raw_component(self, name: str) -> N2PComponent:
+        """Returns a N2Component as component with name specified. It checks only in the original list of components
 
         Args:
             name: str
@@ -154,10 +178,10 @@ class N2PResult:
         # Recuperamos la instancia N2ModelModelContent
         mc = self.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel
 
-        # Llamada al constructor de N2Component de VizzerClasses
+        # Llamada al constructor de N2Component de NaxToModel
         new_d_comp = N2Component(mc, name, formula)
 
-        # Se incluye en la lista de compornentes derivadas de vizzerclasses. Para ello tengo que comprobar que existe
+        # Se incluye en la lista de compornentes derivadas de NaxToModel. Para ello tengo que comprobar que existe
         # dicha lista. Si no existe la tengo que crear como lista de C#
         if not mc.DerivedComponents:
             mc.DerivedComponents = List[N2Component]()

{NaxToPy-1.5.6 → naxtopy-2.0.1}/src/NaxToPy/Core/Constants/Constants.py

@@ -1,14 +1,15 @@
 """Constants of the NaxToPy package"""
 
 # NaxToPy Version
-VERSION = "1.5.6"
+VERSION = "2.0.1"
 
 # Supported for Naxto:
-NAXTO_VERSION = '2024R0'
-NAXTO_STEP = "5"
+NAXTO_VERSION = '2024R1'
+NAXTO_STEP = "2"
 
-# Assembly version of VizzerClasses.dll
-VIZZER_ASSEMBLY = "4.0.0.5"
+# Assembly version of NaxToModel.dll
+VIZZER_COMPATIBILITY = ("4.1.0.0", "4.1.0.1", "4.1.0.2")
+"""Tuple with the compatible versions of NaxToModel.dll"""
 
 # PYTHON EXTERNO ----------------------------------------------------------------------------------
 # Versiones de Python soportadas:
@@ -28,10 +29,10 @@ BINARY_EXTENSIONS = ["op2", "xdb", "h5", "h3d", "odb", "rst"]
 
 # NAXTO -------------------------------------------------------------------------------------------
 # Ruta a las librerias de NaxTo
-DEVELOPER_VIZZER = r'C:\GIT_REPOSITORIES\NAXTO\NAXTOVIEW\v.3.0\NAX2VIZZER\VizzerClasses\bin\x64\Debug'
+DEVELOPER_VIZZER = r'C:\GIT_REPOSITORIES\NAXTO\NAXTOVIEW\v.4.0\NaxToView\NaxToModel\bin\x64\Debug'
 
 # DLLs de NaxTo
-VIZZER_CLASSES_DLL = 'VizzerClasses.dll'
+VIZZER_CLASSES_DLL = 'NaxToModel.dll'
 # -------------------------------------------------------------------------------------------------
 
 PEDIGREE_FACTOR = 1000  # Para pasar de id pedigree a id solver: id_solver = id_pedigree // _PEDIGREE_FACTOR_