NaxToPy 1.5.6__tar.gz → 2.0.0__tar.gz

{NaxToPy-1.5.6 → naxtopy-2.0.0}/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.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 1.5.6
+Version: 2.0.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
 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,
@@ -146,8 +146,9 @@ 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 may be 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
 
@@ -254,6 +255,11 @@ 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.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

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

@@ -22,8 +22,9 @@ 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 may be 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
 
@@ -130,6 +131,11 @@ 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.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.

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

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

{NaxToPy-1.5.6 → naxtopy-2.0.0}/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.0}/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.0}/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.0}/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.0}/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

{NaxToPy-1.5.6 → naxtopy-2.0.0}/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.0}/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.0}/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.0}/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.0}/src/NaxToPy/Core/Constants/Constants.py

@@ -1,14 +1,15 @@
 """Constants of the NaxToPy package"""
 
 # NaxToPy Version
-VERSION = "1.5.6"
+VERSION = "2.0.0"
 
 # Supported for Naxto:
-NAXTO_VERSION = '2024R0'
-NAXTO_STEP = "5"
+NAXTO_VERSION = '2024R1'
+NAXTO_STEP = "0"
 
-# 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")
+"""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_

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Core/Errors/N2PLog.py

@@ -52,7 +52,7 @@ class N2PLog(ABC):
     if __directory == "C:\\Users":
         __directory = os.path.expanduser("~") + "\\Documents\\"
 
-    __filename = time.strftime("NaxToPy_%d-%m-%Y.log", time.localtime())
+    __filename = time.strftime("NaxToPy_%Y-%m-%d.log", time.localtime())
     __path = os.path.join(__directory, __filename)
 
     __logger = logging.getLogger('Logger')
@@ -136,8 +136,8 @@ class N2PLog(ABC):
 
         @staticmethod
         def D101(path) -> None:
-            """Method that shows the location of the VizzerClasses library found"""
-            message = f"VizzerClasses found at: {path}"
+            """Method that shows the location of the NaxToModel library found"""
+            message = f"NaxToModel found at: {path}"
             N2PLog._N2PLog__logger.debug(message)
 
         @staticmethod
@@ -207,18 +207,23 @@ own information message. Use the following structure as a standard message (I +
         def I100() -> None:
             """ Information that show that the NaxToPy Runing Code.
             """
-            from IdaeroLicense import LicenseManager
+            from NaxToLicense import LicenseManager
             from System import DateTime
+            from datetime import datetime
+
+            current_date = datetime.now()
+
+            time_date = DateTime(current_date.year, current_date.month, current_date.day, current_date.hour,
+                                 current_date.minute, current_date.second)
 
-            time_date = DateTime.Now
             licen = LicenseManager()
 
-            if licen.HasLicense():
+            if not licen.HasLicense():
                 err = LicenseManager.GenerateCommunityLicense()
                 licen.HasLicense()
 
             code = licen.GetRunCode(time_date)
-            message = f"I100: The NaxToPy Running with the code: {code}"
+            message = f"I100: NaxToPy Running with the code: {code}"
             N2PLog._set_format2(time_date.ToString().split(" ")[1])
             N2PLog._N2PLog__logger.info(message)
             N2PLog._set_format1()
@@ -268,16 +273,16 @@ own information message. Use the following structure as a standard message (I +
 
         @staticmethod
         def I108() -> None:
-            """ Information given when the program use the develover version of VizzerClasses.
+            """ Information given when the program use the develover version of NaxToModel.
             """
-            message = "I108: Working with developer version of VizzerClasses."
+            message = "I108: Working with developer version of NaxToModel."
             N2PLog._N2PLog__logger.info(message)
 
         @staticmethod
         def I109() -> None:
-            """ Information given when the VizzerClasses library is load correctly.
+            """ Information given when the NaxToModel library is load correctly.
             """
-            message = f"I109: The library VizzerClasses.dll was load successfully."
+            message = f"I109: The library NaxToModel.dll was load successfully."
             N2PLog._N2PLog__logger.info(message)
 
         @staticmethod
@@ -378,6 +383,22 @@ own information message. Use the following structure as a standard message (I +
             message = f"W103: The Path Value in Windows Register has been deleted."
             N2PLog._N2PLog__logger.warning(message)
 
+        @staticmethod
+        def W104(naxver) -> None:
+            """ Warning raised when the version NaxTo that this NaxToPy version is prepared for is not found
+            """
+            message = f"W104: This NaxToPy should work with {naxver}, that is NOT found. Checking compatibility with" \
+                      f"other versions installed"
+            N2PLog._N2PLog__logger.warning(message)
+
+        @staticmethod
+        def W105() -> None:
+            """ Warning raised when the assemblies founded are not saved as compatible
+            """
+            message = f"W105: No library was found to be compatible with this NaxToPy version. The package may" \
+                      f"work but is recommended to find a compatible NaxTo or NaxToPy version."
+            N2PLog._N2PLog__logger.warning(message)
+
         @staticmethod
         def W200() -> None:
             """ Warning raised when the executable file is build without the icon
@@ -835,10 +856,11 @@ own information message. Use the following structure as a standard message (I +
             N2PLog._N2PLog__logger.error(message)
 
         @staticmethod
-        def E312() -> None:
-            ''' Error raised when the components asked for the N2PReport are not found in the model
+        def E312(lc, result) -> None:
+            ''' Error raised when the components asked for the N2PReport are not found in the result of the loadcase
             '''
-            message = f"E312: THE COMPONENTS ASKED FOR THE N2PREPORT ARE NOT IN THE MODEL"
+            message = f"E312: THE COMPONENTS ASKED FOR THE N2PREPORT ARE NOT IN THE RESULT {result} OF THE " \
+                      f"LOAD CASE {lc}"
             N2PLog._N2PLog__logger.error(message)
 
         @staticmethod
@@ -923,7 +945,7 @@ own information message. Use the following structure as a standard message (I +
         def C103() -> None:
             """ Critical Error raised when VizzerClasses.dll is not properly load.
             """
-            message = f"C103: THE LIBRARY 'VizzerClasses.dll' COULDN'T BE LOADED CORRECTLY"
+            message = f"C103: THE LIBRARY 'NaxToModel.dll' COULDN'T BE LOADED CORRECTLY"
             N2PLog._N2PLog__logger.critical(message)
 
         @staticmethod
@@ -963,16 +985,18 @@ own information message. Use the following structure as a standard message (I +
 
         @staticmethod
         def C109(ver, comp_ver) -> None:
-            """ Error raised when NaxTo is not installed.
+            """ Error raised when NaxTo is not compatible with NaxToPy.
             """
-            message = f"C109: THIS VERSION OF NAXTOPY ({ver}) IS ONLY COMPATIBLE WITH THIS ASSEMBLY VERSION: {comp_ver}"
+            message = f"C109: THIS VERSION OF NAXTOPY ({ver}) IS NOT COMPATIBLE WITH THIS ASSEMBLY VERSION: {comp_ver}"
             N2PLog._N2PLog__logger.critical(message)
 
         @staticmethod
-        def C110(ver, comp_ver) -> None:
+        def C110(ver, naxver) -> None:
             """ Error raised when there aren't installed a compatible version of  with minor changes.
             """
-            message = f"C110: THIS VERSION OF NAXTOPY({ver}) IS NOT COMPATIBLE WITH THIS NAXTO VERSION: {comp_ver}"
+            message = f"C110: THIS VERSION OF NAXTOPY({ver}) IS NOT COMPATIBLE WITH THE NAXTO VERSIONS THAT ARE " \
+                      f"INSTALLED. UPDATE TO A COMPATIBLE NAXTO VERSION ({naxver}) OR DOWNLOAD FROM " \
+                      f"https://pypi.org/project/NaxToPy/ A COMPATIBLE NAXTOPY VERSION"
             N2PLog._N2PLog__logger.critical(message)
 
         @staticmethod
@@ -993,6 +1017,14 @@ own information message. Use the following structure as a standard message (I +
                       f"model = NaxToPy.load_model(path, parallelprocessing=True)"
             N2PLog._N2PLog__logger.critical(message)
 
+        @staticmethod
+        def C113(lib, ver, listver) -> None:
+            """ Error raised when the NaxToPy versions the dll is compatible with is not this one
+            """
+            message = f"C113: THE LIBRARY {lib} IS NOT COMPATIBLE WITH NAXTOPY {ver}. INSTALL ANY OF THESE VERSION OF" \
+                      f"NAXTOPY {listver} OR UPDATE NAXTO"
+            N2PLog._N2PLog__logger.critical(message)
+
         @staticmethod
         def C200() -> None:
             """ Critical error raised when numpy couldn't be installed.

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Core/N2PModelContent.py

@@ -1,9 +1,9 @@
-from VizzerClasses import N2ModelContent
-from VizzerClasses import N2LoadCase
-from VizzerClasses.Classes import N2AdjacencyFunctions
-from VizzerClasses.Classes import N2FreeEdges
-from VizzerClasses import EnvelopGroup
-from VizzerClasses import EnvelopCriteria
+from NaxToModel import N2ModelContent
+from NaxToModel import N2LoadCase
+from NaxToModel.Classes import N2AdjacencyFunctions
+from NaxToModel.Classes import N2FreeEdges
+from NaxToModel import EnvelopGroup
+from NaxToModel import EnvelopCriteria
 from NaxToPy.Core.Classes.N2PLoadCase import N2PLoadCase
 from NaxToPy.Core.Classes.N2PIncrement import N2PIncrement
 from NaxToPy.Core.Classes.N2PElement import N2PElement
@@ -19,6 +19,8 @@ from NaxToPy.Core.Classes.N2PSet import N2PSet
 from NaxToPy.Core.Classes.N2PModelInputData import *
 from NaxToPy.Core.Constants.Constants import BINARY_EXTENSIONS
 from NaxToPy.Core.Classes.N2PReport import N2PReport
+
+
 import time
 import sys
 import numpy as np
@@ -27,6 +29,7 @@ import array
 import System
 from collections import OrderedDict
 from typing import Union, overload
+from itertools import chain
 
 
 # Clase Model Content de Python ----------------------------------------------------------------------------------------
@@ -269,15 +272,15 @@ class N2PModelContent:
         ########################################    N2PModelInputData     ##############################################
         ################################################################################################################
         t1 = time.time()
-        if self.__vzmodel.InfoInputFileData is not None:
-            n2pmodelimpudata = self.__vzmodel.InfoInputFileData.ListBulkDataCards
+        if self.__vzmodel.NastranInfoInputFileData is not None:
+            n2pmodelimpudata = self.__vzmodel.NastranInfoInputFileData.ListBulkDataCards
 
             #lista_cards = zeros(len(n2pmodelimpudata), object)
             #diccionario
             #llamar por separado a las tarjetas (props, elems, mat, ...)
             #lista_cards = [construct_dict[card.CardType.ToString()](card) for card in n2pmodelimpudata]
             lista_cards = list(CONSTRUCTDICT[card.CardType.ToString()](card) for card in n2pmodelimpudata)
-            self.__modelinputdata = N2PModelInputData(lista_cards, self.__vzmodel.InfoInputFileData)
+            self.__modelinputdata = N2PModelInputData(lista_cards, self.__vzmodel.NastranInfoInputFileData)
 
         else:
             self.__modelinputdata = None
@@ -385,11 +388,11 @@ class N2PModelContent:
                 if self.Solver == "Nastran" or self.Solver == "Optistruct" or self.Solver == "InputFileNastran":
                     key = int(key)
 
-                if value.GetType().ToString() == 'VizzerClasses.N2MatE':
+                if value.GetType().ToString() == 'NaxToModel.N2MatE':
                     self.__material_dict[key] = N2PMatE(value, self)
-                elif value.GetType().ToString() == 'VizzerClasses.N2MatI':
+                elif value.GetType().ToString() == 'NaxToModel.N2MatI':
                     self.__material_dict[key] = N2PMatI(value, self)
-                elif value.GetType().ToString() == 'VizzerClasses.N2MatMisc':
+                elif value.GetType().ToString() == 'NaxToModel.N2MatMisc':
                     self.__material_dict[key] = N2PMatMisc(value, self)
 
         t2 = time.time()
@@ -423,13 +426,13 @@ class N2PModelContent:
                     if key < 0:
                         N2PLog.Error.E227(key)
 
-                if value.GetType().ToString() == 'VizzerClasses.N2Shell':
+                if value.GetType().ToString() == 'NaxToModel.N2Shell':
                     self.__property_dict[key] = N2PShell(value, self)
 
-                elif value.GetType().ToString() == 'VizzerClasses.N2Comp':
+                elif value.GetType().ToString() == 'NaxToModel.N2Comp':
                     self.__property_dict[key] = N2PComp(value, self)
 
-                elif value.GetType().ToString() == 'VizzerClasses.N2Solid':
+                elif value.GetType().ToString() == 'NaxToModel.N2Solid':
                     self.__property_dict[key] = N2PSolid(value, self)
 
         t2 = time.time()
@@ -1092,13 +1095,13 @@ class N2PModelContent:
         # Argumentos para N2LoadCase
         envelopgroup = N2LoadCase
 
-        # Genera una instancia de un N2LoadCase the VizzerClasses
+        # Genera una instancia de un N2LoadCase de NaxToModel
         cs_lc = N2LoadCase(self.__vzmodel, name, formula)
 
         # Método de N2LoadCase que pone todoo en su sitio
         cs_lc.RecalculateLCInfo2Formule()
 
-        # Se transforma el caso de carga de VizzerClasses en un N2PLoadCase de python
+        # Se transforma el caso de carga de NaxToModel en un N2PLoadCase de python
         py_lc = N2PLoadCase(cs_lc.ID, cs_lc.IDOriginal, cs_lc.Increments, cs_lc.IncrementsNumberList, cs_lc.IsComplex,
                             cs_lc.TypeLoadCase, cs_lc.Name, cs_lc.Results, cs_lc.SolutionType, cs_lc.Solver, self, cs_lc)
 
@@ -1114,7 +1117,8 @@ class N2PModelContent:
 
         return py_lc
 
-    def new_envelope_loadcase(self, name: str, formula: str, criteria: str="ExtremeMax") -> N2PLoadCase:
+    def new_envelope_loadcase(self, name: str, formula: str, criteria: str = "ExtremeMax",
+                              envelgroup: str = "ByContour") -> N2PLoadCase:
         """Method of N2PModelContent that generate a new N2PLoadCase that is the envelope of the load cases and increments
         selected.
 
@@ -1173,13 +1177,13 @@ class N2PModelContent:
         }
         envelopgroup = envelgroup_maping.get(envelgroup, EnvelopGroup.ByContour)
 
-        # Genera una instancia de un N2LoadCase the VizzerClasses
+        # Genera una instancia de un N2LoadCase de NaxToModel
         cs_lc = N2LoadCase(self.__vzmodel, name, formula, True, envelopgroup, False, envelopcriteria)
 
         # Método de N2LoadCase que pone todoo en su sitio
         cs_lc.RecalculateLCInfo2Formule()
 
-        # Se transforma el caso de carga de VizzerClasses en un N2PLoadCase de python
+        # Se transforma el caso de carga de NaxToModel en un N2PLoadCase de python
         py_lc = N2PLoadCase(cs_lc.ID, cs_lc.IDOriginal, cs_lc.Increments, cs_lc.IncrementsNumberList, cs_lc.IsComplex,
                             cs_lc.TypeLoadCase, cs_lc.Name, cs_lc.Results, cs_lc.SolutionType, cs_lc.Solver, self, cs_lc)
 
@@ -1227,7 +1231,7 @@ class N2PModelContent:
             componentssections: str -> Formula with the components and the section desired. Each component can have
                 several sections, and the structure must be: <ComopnentName:X#Y#Z#> where X, Y, Z are the names of the
                 section. After each name of section there must be an #, even if there is only one. Example:
-                "<VONMISES:Z1#Z2#>,<MAX_SHEAR:Z1#Z2#>"
+                "<VONMISES:Z1#Z2#>,<MAX_SHEAR:Z1#Z2#>". If there is no section, use NONE#: "<FX:NONE#>,<FY:NONE#>"
 
             ifenvelope: bool -> Parameter to ask only for the results of the envelope of the load cases
 
@@ -1289,9 +1293,10 @@ class N2PModelContent:
             lcs = [int(lc.split(":")[0][3:]) for lc in lc_incr.split(",")]
             components = [c.split(":")[0][1:] for c in componentssections.split(",")]
             for lc in lcs:
-                A = self.get_load_case(lc).get_result(result).Components.keys()
-                if not all(c in self.get_load_case(lc).get_result(result).Components.keys() for c in components):
-                    N2PLog.Error.E312()
+                all_comps = chain(self.get_load_case(lc).get_result(result).Components.keys(),
+                                  self.get_load_case(lc).get_result(result).DerivedComponents.keys())
+                if not all(c in all_comps for c in components):
+                    N2PLog.Error.E312(lc, result)
                     return "ERROR"
         except:
             N2PLog.Error.E313()
@@ -1381,18 +1386,20 @@ class N2PModelContent:
             N2PLog.Error.E310()
             return None
 
+        n2pcomp = aux_lc.get_result(result).get_component(component)
+
         # Aqui se llama la funcion de verdad que es un metodo de N2PComponent. Se llama a ella porque hace uso de otras
         # funciones ya definidas (n2paraminputresult) en la clase y es mejor no repetir codigo.
-        return aux_lc.get_result(result).get_component(component)._get_result_by_LCs_Incr(list_lc_incr,
-                                                                                          sections,
-                                                                                          aveSections,
-                                                                                          cornerData,
-                                                                                          aveNodes,
-                                                                                          variation,
-                                                                                          realPolar,
-                                                                                          coordsys,
-                                                                                          v1,
-                                                                                          v2)
+        return n2pcomp._get_result_by_LCs_Incr(list_lc_incr,
+                                               sections,
+                                               aveSections,
+                                               cornerData,
+                                               aveNodes,
+                                               variation,
+                                               realPolar,
+                                               coordsys,
+                                               v1,
+                                               v2)
 
     # ------------------------------------------------------------------------------------------------------------------
 

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Core/Reference_Finder/__Reference_Finder.py

@@ -22,7 +22,7 @@ def py_ver_comp() -> None:
 
 # Funcion que devuelve la ruta donde se encuentran las librerias de NaxTo----------------------
 def vizzer_libs() -> list[str, ...]:
-    """Funcion que devuelve las rutas donde se encuentran las librerias de VizzerClasses. Si hay varias versiones
+    """Funcion que devuelve las rutas donde se encuentran las librerias de NaxToModel. Si hay varias versiones
     puede haber varias rutas.
 
     ----------
@@ -32,7 +32,7 @@ def vizzer_libs() -> list[str, ...]:
     """
     vizzer_libs = []
 
-    # Miro en LOCAL MACHINE, donde está instalado el NAXTOVIEW. Ahí se busca la libreria de VizzerClasses.
+    # Miro en LOCAL MACHINE, donde está instalado el NAXTOVIEW. Ahí se busca la libreria de NaxToModel.
     key_id = winreg.HKEY_LOCAL_MACHINE
 
     try:
@@ -154,18 +154,52 @@ def destroy_register() -> None:
 
 
 # ----------------------------------------------------------------------------------------------------------------------
-def compatible_vizzer(vizzer_libs: list) -> str:
-    """Returns the path of the VizzerClasses this NaxToPy version is compatible with"""
+def compatible_vizzer(vizzer_libs: list) -> tuple[str, bool]:
+    """Returns the path of the NaxToModel this NaxToPy version is compatible with"""
 
+    # Se busca si alguna de las rutas contiene la version para la que esta preparado esta version
+    for lib in vizzer_libs:
+        if NAXTO_VERSION in lib:
+            lib_path = lib + "\\" + VIZZER_CLASSES_DLL
+
+            # Si alguna es de esta version hay que ver si el assembly, que cambia con cada step es compatible.
+            # Previamente se verifica que el archivo existe:
+            if os.path.exists(lib_path):
+                versionInfo = FileVersionInfo.GetVersionInfo(lib_path)
+                assemblyVersion = versionInfo.FileVersion
+
+                # Si la version es compatible se devuelve la ruta y un boleano indicando si es compatible
+                if assemblyVersion in VIZZER_COMPATIBILITY:
+                    return lib_path, True
+
+    N2PLog.Warning.W104(NAXTO_VERSION)
+    # Aunque la version este bien, el assembly no. Puede que de un step a otro no haya compatibilidad.
+    backup = ""
+
+    # Comprobamos si hay alguna version que contenga una dll compatible
     for lib in vizzer_libs:
         lib_path = lib + "\\" + VIZZER_CLASSES_DLL
+        if not os.path.exists(lib_path):
+            continue
         versionInfo = FileVersionInfo.GetVersionInfo(lib_path)
         assemblyVersion = versionInfo.FileVersion
 
-        if assemblyVersion == VIZZER_ASSEMBLY:
-            return lib_path
+        if not backup:
+            backup = lib_path
+
+        if assemblyVersion in VIZZER_COMPATIBILITY:
+            return lib_path, True
+
+    N2PLog.Warning.W105()
+
+    # Si ninguna libreria es compatible se prueba con una de ellas, la primera que exista. Pero se indica que no es
+    # compatible. Mas adelante se comprubea si dentro de la libreria se indica que esta version de NaxToPy es compatible
+    # con ella
+    if backup:
+        return backup, False
+    else:
+        N2PLog.Critical.C110(VERSION, NAXTO_VERSION)
 
-    N2PLog.Critical.C109(VERSION, VIZZER_ASSEMBLY)
     # sys.exit()
 # ---------------------------------------------------------------------------------------------
 
@@ -173,14 +207,15 @@ def compatible_vizzer(vizzer_libs: list) -> str:
 def _naxto_gen(vizzer: str) -> str:
     dir_viz = os.path.dirname(vizzer)
     if "GIT_REPOSITORIES" in dir_viz:
-        return os.path.join(r"C:\GIT_REPOSITORIES\NAXTO\NAXTOLibsDebug\NAXLicense\v.3.0", "IdaeroLicense.dll")
-    return os.path.join(dir_viz, "IdaeroLicense.dll")
+        return os.path.join(r"C:\GIT_REPOSITORIES\NAXTO\NAXTOLibsDebug\NAXLicense\v.4.0", "NaxToLicense.dll")
+    return os.path.join(dir_viz, "NaxToLicense.dll")
 
 
-# Inicializador para encontrar la libreria de VizzerClasses
+# Inicializador para encontrar la libreria de NaxToModel
 def __reference_finder():
     # La ruta cambia si se tiene el repositorio de NaxToView
     developer_vizzer = DEVELOPER_VIZZER + "\\" + VIZZER_CLASSES_DLL
+    compatible = True
 
     # Si se crea un .exe queremos que encuentre unas nuevas librerias distribuibles, que estarán en la carpeta temporal que se
     # crea cuando se ejecuta el .exe. Tampoco se ejecutan los modulos del reference finder
@@ -188,7 +223,7 @@ def __reference_finder():
         destroy_register()
         create_register()
         exe_dir = sys._MEIPASS
-        vizzer_path = exe_dir + "\\bin\\VizzerClasses.dll"
+        vizzer_path = exe_dir + "\\bin\\NaxToModel.dll"
         N2PLog.Info.I107()
 
     elif os.path.isfile(developer_vizzer):
@@ -203,21 +238,28 @@ def __reference_finder():
         destroy_register()
         # Compruebo que la version de python es compatible
         py_ver_comp()
-        # Busco todas las vizzerclasses
+        # Busco todas las NaxToModel
         list_libs = vizzer_libs()
-        # Devuelvo el path de la vizzerclasses que es compatible con NaxToPy
-        vizzer_path = compatible_vizzer(list_libs)
+
+        vizzer_path, compatible = compatible_vizzer(list_libs)
 
     # Llamada a las librerias
     try:
         clr.AddReference(vizzer_path)
+        if not compatible:
+            from NaxToModel import Global
+            if VERSION in list(Global.NAXTOPY_COMPATIBILITY):
+                pass
+            else:
+                N2PLog.Critical.C113(vizzer_path, VERSION, list(Global.NAXTOPY_COMPATIBILITY))
+                sys.exit()
         N2PLog.Info.I109()
         N2PLog.Debug.D101(vizzer_path)
         naxto_c = _naxto_gen(vizzer_path)
         clr.AddReference(naxto_c)
     except:
         N2PLog.Critical.C103()
-        # sys.exit("C103: THE LIBRARY 'VizzerClasses.dll' COULDN'T BE LOADED CORRECTLY")
+        # sys.exit("C103: THE LIBRARY 'NaxToModel.dll' COULDN'T BE LOADED CORRECTLY")
 
     N2PLog.Info.I100()
 # ---------------------------------------------------------------------------------------------

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Modules/Fasteners/N2PUpdateFastener.py

@@ -10,7 +10,7 @@ from NaxToPy.Core.N2PModelContent import N2PElement
 class N2PUpdateFastener:
     """
     This class stores information about fasteners and provides methods to update their stiffness and generate a new
-    bdf file with the updated data.
+    FEM Input File (.bdf, .fem, .dat, etc.) file with the updated data.
 
     Fastener information can be input either as a dictionary (for a single type of fastener) or as a list of dictionaries
     (for multiple types). Each dictionary must include at least the keys for diameter ["D"] and elastic modulus ["E"].
@@ -25,9 +25,39 @@ class N2PUpdateFastener:
     of ID lists to ensure proper mapping of variables.
 
     Supported methods for stiffness calculation include HUTH, TATE_ROSENFELD, SWIFT, BOEING, GRUMMAN, and NELSON.
+
+    Example:
+        Example 1:
+
+        >>> import NaxToPy as n2p
+        >>> model = n2p.load_model("model.dat")
+        >>> info1 = {"D": 4.8,
+        ...         "E": 110000}
+        >>> info2 = {"D": 7.2,
+        ...         "E": 70000,
+        ...         "connection_type": "rivet",
+        ...         "shear_type": "double"}
+        >>> ele1 = [1000, 1001, 1002]
+        >>> ele2 = [2000, 2001, 2002]
+        >>> update1 = N2PUpdateFastener(model, [info1, info2], [ele1, ele2], "BOEING")
+        >>> update1.calculate() # This will update the model in memory with the information of the object.
+        >>> model.ModelInputData.rebuild_file() # With the model updated, the model is rewritten
+
+        Example 2:
+
+        >>> model = n2p.load_model("model.dat")
+        >>> update2 = N2PUpdateFastener(model, {}) # Create the object without information
+        >>> update2.IDList = [3000, 3001, 3002] # Add the information using it properties
+        >>> update2.StiffnessMethod = "GRUMMAN"
+        >>> update2.FastenerInformation = {3000: {"D": 4.8, "E": 70000, "connection_type": "rivet"},
+        ...                                3001: {"D": 6.8, "E": 70000, "connection_type": "bolt"},
+        ...                                3002: {"D": 7.2, "E": 70000, "shear_type": "double"}}
+        >>> update2.calculate() # This will update the model in memory with the information of the object.
+        >>> model.ModelInputData.rebuild_file() # With the model updated, the model is rewritten
+
     """
 
-    def __init__(self,model: N2PModelContent, information: Union[dict, list], id_list: list = None,
+    def __init__(self, model: N2PModelContent, information: Union[dict, list], id_list: list = None,
                  stiffness_method: str = "HUTH"):
         self.__model = model
         self.__stiffness_method = stiffness_method
@@ -94,13 +124,8 @@ class N2PUpdateFastener:
         self.__mapping_fastener_properties()
 
     def __mapping_fastener_properties(self):
-
-        properties_map = {}
-        for prop, ID in zip(self.__info_list, self.__id_list):
-            for fastener in ID:
-                properties_map[fastener] = prop
-
-        self.__fastener_properties = properties_map
+        self.__fastener_properties = {fastener: prop for prop, IDs in zip(self.__info_list, self.__id_list) for fastener
+                                      in IDs}
 
     def __read_bolts(self, path: str) -> dict:
         """

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Modules/N2PEnvelope/N2PEnvelope.py

@@ -3,7 +3,7 @@ Module that generates the envelope of points cloud.
 """
 import sys, os
 import numpy as np
-from VizzerClasses import N2Envelope
+from NaxToModel import N2Envelope
 import System
 from NaxToPy.Core._AuxFunc._NetToPython import _nettonumpy, _numpytonet
 from NaxToPy.Core.Errors.N2PLog import N2PLog
@@ -97,14 +97,14 @@ def envelope_ndarray(array2D: np.ndarray) -> np.ndarray:
 
         # _numpytonet(array2D) es una funcion que transforma un array de numpy en un array de .NET, en este caso en un
         # System.Double[,]
-        # Se llama a la funcion de envelope the vizzerclasses
+        # Se llama a la funcion de envelope de NaxToModel
         aux = N2Envelope.Calculate(_numpytonet(array2D), "all")
 
         # Se crea un array de numpy vacio de objetos. Tiene que ser de objetos porque se mezclan variables, ya que en la
         # columna 0 habra enteros mientras que en las demas habra columnas
         envel = np.zeros((aux.GetLength(0), aux.GetLength(1)), dtype=object)
 
-        # Relleno el array de numpy con los valores obtenidos del array de vizzerclasses
+        # Relleno el array de numpy con los valores obtenidos del array de NaxToModel
         for i in range(aux.GetLength(0)):
             for j in range(aux.GetLength(1)):
                 # qhull devulve los indices empezando por 1. Necesitamos que lo devuelva por 0.

{NaxToPy-1.5.6 → naxtopy-2.0.0}/src/NaxToPy/Modules/N2PtoEXE/N2PtoEXE.py

@@ -6,6 +6,7 @@ import sys
 
 import NaxToPy.Core.Reference_Finder.__Reference_Finder as RF
 from NaxToPy.Core.Errors.N2PLog import N2PLog
+from NaxToPy.Core.Constants.Constants import VIZZER_CLASSES_DLL
 
 
 # Funcion que busca el path del icono de NaxToPy -----------------------------------------------------------------------
@@ -169,7 +170,7 @@ def n2ptoexe(path: str, console: bool = True, solver: str = "ALL", abaqusversion
     if __busca_n2p(path):
 
         libs_paths = RF.vizzer_libs()
-        libs_path = RF.compatible_vizzer(libs_paths)[:-18]
+        libs_path = RF.compatible_vizzer(libs_paths)[0][:-(len(VIZZER_CLASSES_DLL) + 1)]
         dll_list = __list_ext_libs(libs_path, solver, abaqusversion)
         
 

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 1.5.6
+Version: 2.0.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
 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,
@@ -146,8 +146,9 @@ 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 may be 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
 
@@ -254,6 +255,11 @@ 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.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.