NaxToPy 2.2.3__tar.gz → 3.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: NaxToPy
-Version: 2.2.3
+Version: 3.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
@@ -127,7 +127,7 @@ Dynamic: home-page
 
 [![Idaero](https://img.shields.io/badge/powered%20by-Idaero%20Solutions-299797)](https://idaerosolutions.com)
 [![PyPi](https://img.shields.io/pypi/v/NaxToPy?color=ffd500)](https://pypi.org/project/NaxToPy/)
-[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-00699d)](https://www.python.org/downloads/)
+[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-00699d)](https://www.python.org/downloads/)
 ![License](https://img.shields.io/badge/license-proprietary-red)
 [![MicrosoftStore](https://img.shields.io/badge/Microsoft%20Store-NaxTo-blue?logo=microsoftstore&logoColor=blue&labelColor=lightgrey)](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US)
 [![PyPi - Downloads](https://img.shields.io/pypi/dm/NaxToPy?color=dgreen)](https://pypi.org/project/NaxToPy/#files)
@@ -151,10 +151,10 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 ---------------
 
 ⚠️**Warning:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
-This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0, 2024.3.1).
+This version is compatible with **NaxTo 2025.0**. 
 Check in _Programs and Features_ the NaxTo version that is installed.
 
-📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/2.2.1/#history) to find which newer version is compatible with it.
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/3.0.0/#history) to find which newer version is compatible with it.
 
 
 ## Installation
@@ -327,12 +327,22 @@ is redundant. The coordinate system will prevail.
 8. BugFix: The method get_elements_attached() is fixed so when there are MPC connectors with the same ID.
 
 ### v.2.2.3
-1. Requirement: Now NaxToPy require the package [**h5py** ](https://pypi.org/project/h5py/).
+1. Requirement: Now NaxToPy require the package [**h5py**](https://pypi.org/project/h5py/).
 2. Feat: N2PGetLoadFastener now can use PAG method and display format.
 3. BugFix: Some bugs are solved in N2PGetFastener and N2PGetLoadFastener.
 4. Feat: N2PGetLoadFastener can export results in HDF5 format.
 5. BugFix: The filtering in the method get_result_by_LCs_Incr() in elements when results are in Corner Data is fixed.
 
+### v.3.0.0
+1. Feat: Now it is supported more properties from Nastran: PBAR, PBARL, PBEAM, PBEAML, PBUSH, PWELD, PELAS, PFAST, PMASS, PGAP. They are kept as N2PBeam, N2PBeamL, N2PBush, N2PWeld, N2PElas, N2PFast, N2PMass, N2PGap.
+2. Feat: Now it is supported more properties from Abaqus: *BEAM SECTION and *BEAM GENERAL SECTION as N2PBeamL and N2PBeam.
+3. Feat: Overloaded `get_result_by_LCs_Incr()` to accept a list of components. It load multiple components and load cases of the same result in parallel, improving efficiency.
+4. Feat: New property N2PComp.EqQBenMatrix that returns the equivalent stifness matrix for bending. 
+5. Feat: Added `N2PComp.EqMemProps` and `N2PComp.EqBenProps` properties to return equivalent engineering values (Ex, Ey, G, and ν) for membrane and bending behavior, respectively.
+6. Feat: Added two new methods in `N2PModelContent`: `get_material()` and `get_property()` to search easelly for materials and properties.
+7. Feat: new method in `N2PModelContent`: `get_elements_filtered()`. It returns a list of `N2PElement` that matches a material, property, part or type-element.
+8. Feat: New checks in the results methods to avoid invalid parameters.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -550,7 +560,10 @@ For more documentation visit https://idaerosolutions.com/Home/NaxToPy
 
 Reference Guide at: https://www.idaerosolutions.com/NaxToPyDoc/NaxToPy.html
 
-
 # License
 
-Copyright is owned by Idaero Solutions©
+See the license in Python\Lib\site-packages\NaxToPy-{version}.dist-info\LICENSE or executing the command `python -m pip show NaxToPy`
+
+-------------
+
+<p align="center">  <img src="https://www.idaerosolutions.com/images/web/Idaero.png" alt="Idaero Icon" width=200></p><div align="center">© 2025 Idaero Solutions S.L. All rights reserved.</div>

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

@@ -1,6 +1,6 @@
 [![Idaero](https://img.shields.io/badge/powered%20by-Idaero%20Solutions-299797)](https://idaerosolutions.com)
 [![PyPi](https://img.shields.io/pypi/v/NaxToPy?color=ffd500)](https://pypi.org/project/NaxToPy/)
-[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-00699d)](https://www.python.org/downloads/)
+[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-00699d)](https://www.python.org/downloads/)
 ![License](https://img.shields.io/badge/license-proprietary-red)
 [![MicrosoftStore](https://img.shields.io/badge/Microsoft%20Store-NaxTo-blue?logo=microsoftstore&logoColor=blue&labelColor=lightgrey)](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US)
 [![PyPi - Downloads](https://img.shields.io/pypi/dm/NaxToPy?color=dgreen)](https://pypi.org/project/NaxToPy/#files)
@@ -24,10 +24,10 @@ additional software beyond NaxTo (see the Download and Homepage links on the lef
 ---------------
 
 ⚠️**Warning:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
-This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0, 2024.3.1).
+This version is compatible with **NaxTo 2025.0**. 
 Check in _Programs and Features_ the NaxTo version that is installed.
 
-📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/2.2.1/#history) to find which newer version is compatible with it.
+📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/3.0.0/#history) to find which newer version is compatible with it.
 
 
 ## Installation
@@ -200,12 +200,22 @@ is redundant. The coordinate system will prevail.
 8. BugFix: The method get_elements_attached() is fixed so when there are MPC connectors with the same ID.
 
 ### v.2.2.3
-1. Requirement: Now NaxToPy require the package [**h5py** ](https://pypi.org/project/h5py/).
+1. Requirement: Now NaxToPy require the package [**h5py**](https://pypi.org/project/h5py/).
 2. Feat: N2PGetLoadFastener now can use PAG method and display format.
 3. BugFix: Some bugs are solved in N2PGetFastener and N2PGetLoadFastener.
 4. Feat: N2PGetLoadFastener can export results in HDF5 format.
 5. BugFix: The filtering in the method get_result_by_LCs_Incr() in elements when results are in Corner Data is fixed.
 
+### v.3.0.0
+1. Feat: Now it is supported more properties from Nastran: PBAR, PBARL, PBEAM, PBEAML, PBUSH, PWELD, PELAS, PFAST, PMASS, PGAP. They are kept as N2PBeam, N2PBeamL, N2PBush, N2PWeld, N2PElas, N2PFast, N2PMass, N2PGap.
+2. Feat: Now it is supported more properties from Abaqus: *BEAM SECTION and *BEAM GENERAL SECTION as N2PBeamL and N2PBeam.
+3. Feat: Overloaded `get_result_by_LCs_Incr()` to accept a list of components. It load multiple components and load cases of the same result in parallel, improving efficiency.
+4. Feat: New property N2PComp.EqQBenMatrix that returns the equivalent stifness matrix for bending. 
+5. Feat: Added `N2PComp.EqMemProps` and `N2PComp.EqBenProps` properties to return equivalent engineering values (Ex, Ey, G, and ν) for membrane and bending behavior, respectively.
+6. Feat: Added two new methods in `N2PModelContent`: `get_material()` and `get_property()` to search easelly for materials and properties.
+7. Feat: new method in `N2PModelContent`: `get_elements_filtered()`. It returns a list of `N2PElement` that matches a material, property, part or type-element.
+8. Feat: New checks in the results methods to avoid invalid parameters.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
@@ -423,7 +433,10 @@ For more documentation visit https://idaerosolutions.com/Home/NaxToPy
 
 Reference Guide at: https://www.idaerosolutions.com/NaxToPyDoc/NaxToPy.html
 
-
 # License
 
-Copyright is owned by Idaero Solutions©
+See the license in Python\Lib\site-packages\NaxToPy-{version}.dist-info\LICENSE or executing the command `python -m pip show NaxToPy`
+
+-------------
+
+<p align="center">  <img src="https://www.idaerosolutions.com/images/web/Idaero.png" alt="Idaero Icon" width=200></p><div align="center">© 2025 Idaero Solutions S.L. All rights reserved.</div>

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

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

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

@@ -4,6 +4,7 @@ import gc
 from array import array
 import numpy as np
 from typing import Union
+import ctypes
 
 from NaxToModel import N2ParamInputResults
 from NaxToModel import N2TensorTransformation
@@ -162,7 +163,7 @@ class N2PComponent:
         #resultsParameters.coordSys = -10
         #orientationcoordinatesystem = algo
 
-        resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
+        resultsParameters = self._create_n2paraminputresult(None, sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
         results = list(
             self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
@@ -254,7 +255,7 @@ class N2PComponent:
             >>> # 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,
+        resultsParameters = self._create_n2paraminputresult(None, sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
 
         results = \
@@ -399,39 +400,83 @@ class N2PComponent:
     # # ------------------------------------------------------------------------------------------------------------------
 
     # Método que devuelve un diccionario con la tupla (LC, Incr) como clave y una lista de resultados como valor -------
-    def _get_result_by_LCs_Incr(self, list_lc_incr: list[tuple["N2PLoadCase", "N2PIncrement"],...],
+    def _get_result_by_LCs_Incr(self, list_lc_incr: list[tuple["N2PLoadCase", "N2PIncrement"],...], components = None,
                                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),
-                               filter_list: list = None) -> dict[tuple: list[float,...]]:
+                               filter_list: list = None) -> dict[tuple: list[float]]:
 
-        formula = self._create_formula(list_lc_incr)
-
-        if not formula:
-            return None
-
-        resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
-                                                            realPolar, coordsys, v1, v2)
-
-        cs_dict = self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
-                formula, resultsParameters, 0)
+        py_dict = {}  # Dictionary that is going to be returned.
+        first_shoot = True
+        i = 0
+        n_opt = 0
+        n_lcs = len(list_lc_incr)
         
-        if filter_list and not cornerData:
-            ii_map = [item.InternalID for item in filter_list]
-        elif filter_list and cornerData:
-            if isinstance(filter_list[0], N2PElement):
-                ii_map = list(self._result_father._loadCase_father._modelFather.elementnodal(filter_list).keys())
+        # A first shoot with a block of 5 load cases is made. The memory used in the process wil be measured
+        # using the function _get_memory_usage(). Acording to de memory used, the optimum number of load cases
+        # per block will be claculated and the remain load cases will be launched in blocks.
+        while i < n_lcs:
+            
+            if first_shoot:
+                formula = self._create_formula(list_lc_incr[0:5])
             else:
-                N2PLog.Error.E234()
-        else:
-            ii_map = None
-
-        py_dict = {(int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")),
-                    int(key.split(":")[1][2:])): self._filter_array(np.array(value, np.float64), filter_list, None, ii_map, cornerData)
-                   for key, value in dict(cs_dict[0]).items()}
-        
-        del cs_dict
-        gc.collect()
+                formula = self._create_formula(list_lc_incr[i : i + n_opt])
+
+            if not formula:
+                return None
+            
+            if components is None: components = [None] 
+            for component in components:
+                resultsParameters = self._create_n2paraminputresult(component, sections, aveSections, cornerData, aveNodes, variation,
+                                                                    realPolar, coordsys, v1, v2)
+
+                if first_shoot:
+                    _, available_memory, initial_memory = _get_memory_usage()
+
+                cs_dict = self._result_father._loadCase_father._modelFather._N2PModelContent__vzmodel.CalculateArrayLastResult(
+                        formula, resultsParameters, 0)
+                
+                if filter_list and not cornerData:
+                    ii_map = [item.InternalID for item in filter_list]
+                elif filter_list and cornerData:
+                    if isinstance(filter_list[0], N2PElement):
+                        ii_map = list(self._result_father._loadCase_father._modelFather.elementnodal(filter_list).keys())
+                    else:
+                        N2PLog.Error.E234()
+                else:
+                    ii_map = None
+
+                if not components[0]:
+                    py_dict_aux = {
+                        (int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")), int(key.split(":")[1][2:])) :
+                        self._filter_array(np.array(value, np.float64), filter_list, None, ii_map, cornerData)
+                        for key, value in dict(cs_dict[0]).items()
+                    }
+                else:
+                    py_dict_aux = {
+                        (int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")), int(key.split(":")[1][2:]), component) :
+                        self._filter_array(np.array(value, np.float64), filter_list, None, ii_map, cornerData)
+                        for key, value in dict(cs_dict[0]).items()
+                    }
+                
+                del cs_dict
+                self._result_father._loadCase_father._modelFather.clear_results_memory()
+                py_dict.update(py_dict_aux)
+
+                # Clear memomry
+                py_dict_aux.clear() 
+                gc.collect()
+
+            if first_shoot:
+                _, _, final_memory = _get_memory_usage()
+                used_memory = final_memory - initial_memory
+                # Minimum number is fixed to 100
+                used_memory = used_memory if used_memory > 100 else 100
+                n_opt = int(available_memory*0.9/used_memory*5)
+                i = 5
+                first_shoot = False
+            else:
+                i += n_opt
         
         return py_dict
     # ------------------------------------------------------------------------------------------------------------------
@@ -457,7 +502,7 @@ class N2PComponent:
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo que crea el N2ParamInputResult ----------------------------------------------------------------------------
-    def _create_n2paraminputresult(self, sections, aveSections, cornerData, aveNodes, variation,
+    def _create_n2paraminputresult(self, component, sections, aveSections, cornerData, aveNodes, variation,
                                    realPolar, coordsys, v1, v2) -> N2ParamInputResults:
 
         # Aqui comprobamos que si queremos hacer una transformacion y si esta es posible:
@@ -483,19 +528,22 @@ class N2PComponent:
 
             else:
                 # If coordsys doesn't match any known case, log an error and return failure
-                N2PLog.Error.E220()
-                return (-1, 'NO RESULTS')
+                msg = N2PLog.Error.E220()
+                raise Exception(msg)
 
         elif not self.IsTransformable and (coordsys != -1000 or (v1 != (1, 0, 0) or v2 != (0, 1, 0))):
-            N2PLog.Error.E219()
-            return (-1, 'NO RESULTS')
+            msg = N2PLog.Error.E219()
+            raise Exception(msg)
 
         else:
             # Initializer if it is no transformable
             resultsParameters = N2ParamInputResults.structResults(0)
 
         # Component Selected
-        resultsParameters.Component = str(self.Name)
+        if component:
+            resultsParameters.Component = component
+        else:
+            resultsParameters.Component = str(self.Name)
 
         # Entity Selection (So Far 'ALL')
         resultsParameters.IdsEntities = ''
@@ -523,15 +571,25 @@ class N2PComponent:
                 sectionParam += str(section.Name) + '#'
         else:
             if not isinstance(sections, list):
-                N2PLog.Error.E218()
+                msg = N2PLog.Error.E218()
+                raise TypeError(msg)
+            actual_sections = {s.Name for s in self.Sections}
             for section in sections:
                 if type(section) is N2PSection:
                     sectionParam += str(section.Name) + '#'
                 else:
-                    sectionParam += str(section) + '#'
+                    if section in actual_sections:
+                        sectionParam += str(section) + '#'
+                    else:
+                        msg = N2PLog.Error.E238(section, actual_sections)
+                        raise Exception(msg)
 
         resultsParameters.sectPoint = sectionParam
 
+        avasectionsupported = (-1, -2, -3, -4, -6)
+        if aveSections not in avasectionsupported:
+            msg = N2PLog.Error.E237(aveSections, avasectionsupported)
+            raise Exception(msg)
         resultsParameters.aveSection = aveSections
 
         # CornerData Selection, Average & Variation
@@ -539,8 +597,8 @@ class N2PComponent:
 
         _aveIntraSupported = (0, -1, -2, -3, -6)
         if (aveNodes not in _aveIntraSupported):
-            N2PLog.Error.E236(aveNodes, _aveIntraSupported)
-            return (-1)
+            msg = N2PLog.Error.E236(aveNodes, _aveIntraSupported)
+            raise Exception(msg)
         else:
             resultsParameters.aveIntra = aveNodes
 
@@ -554,9 +612,10 @@ class N2PComponent:
         resultsParameters.variation = variation
 
         # Real/Imaginary or Magnitude/Phase
-        __complexSupported__ = (0, 1, 2)
-        if (realPolar not in __complexSupported__):
-            return (-1)
+        __complexSupported = (0, 1, 2)
+        if (realPolar not in __complexSupported):
+            msg = N2PLog.Error.E239(realPolar, __complexSupported)
+            raise Exception(msg)
         else:
             resultsParameters.real_cartesian_polar = realPolar
 
@@ -615,3 +674,29 @@ def _get_axis(v1: Union[tuple, np.ndarray], v2: Union[tuple, np.ndarray]) -> np.
     y = np.cross(z, v1)
 
     return np.vstack((v1, y, z))
+
+def _get_memory_usage() -> tuple[float, float, float]:
+    """Returns total_memory, available_memory, used_memory in MB"""
+
+    class MEMORYSTATUSEX(ctypes.Structure):
+        _fields_ = [
+            ("dwLength", ctypes.c_ulong),
+            ("dwMemoryLoad", ctypes.c_ulong),
+            ("ullTotalPhys", ctypes.c_ulonglong),
+            ("ullAvailPhys", ctypes.c_ulonglong),
+            ("ullTotalPageFile", ctypes.c_ulonglong),
+            ("ullAvailPageFile", ctypes.c_ulonglong),
+            ("ullTotalVirtual", ctypes.c_ulonglong),
+            ("ullAvailVirtual", ctypes.c_ulonglong),
+            ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+        ]
+
+    memory_status = MEMORYSTATUSEX()
+    memory_status.dwLength = ctypes.sizeof(MEMORYSTATUSEX)
+    ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(memory_status))
+
+    total_memory = memory_status.ullTotalPhys / (1024 ** 2)  # Convert to MB
+    available_memory = memory_status.ullAvailPhys / (1024 ** 2)  # Convert to MB
+    used_memory = total_memory - available_memory
+
+    return total_memory, available_memory, used_memory

{naxtopy-2.2.3 → naxtopy-3.0.0}/src/NaxToPy/Core/Classes/N2PElement.py

@@ -59,11 +59,14 @@ class N2PElement:
 
     # Metodo para obtener la propiedad del elemento --------------------------------------------------------------------------------
     @property
-    def Prop(self) -> Union[int, str]:
+    def Prop(self) -> Union[tuple[int, str], tuple[str, str]]:
         id_prop = int(self.__info.prop)
         if self.__model.Solver == "Abaqus":
             id_prop = self.__model._N2PModelContent__propertyIDtoStr.get(id_prop)
-        return id_prop
+            part = "ASSEMBLY"
+        else:
+            part = self.PartID
+        return (id_prop, part)
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el material del elemento ---------------------------------------------------------------------

{naxtopy-2.2.3 → naxtopy-3.0.0}/src/NaxToPy/Core/Classes/N2PFreeBody.py

@@ -74,6 +74,7 @@ class N2PFreeBody(object):
 
         # Llamada al constructor de NaxToModel
         n2fbdsection = N2FBDSection(self.__name)
+        n2fbdsection.OpenFile = self.__model._N2PModelContent__vzmodel
 
         # Se incluye la parte:
         n2fbdsection.NodesPartID = self.__model._N2PModelContent__StrPartToID.get(self.__nodelist[0].PartID, 0)
@@ -101,14 +102,14 @@ class N2PFreeBody(object):
             n2fbdsection.ElementsId.Add(element.ID)
 
         # Instancio un objeto de la clase N2FBD
-        n2fbd = N2FBD(self.__model._N2PModelContent__vzmodel, n2fbdsection)
+        n2fbd = N2FBD(n2fbdsection)
 
         # Le añado los casos de carga y los incrementos:
         listacasos = System.Collections.Generic.List[System.Int32]()
         listaframes = System.Collections.Generic.List[System.Int32]()
         listacasos.Add(self.__loadcase.ID)
         listaframes.Add(self.__increment.ID)
-        n2fbd.AddLCandFrame(listacasos, listaframes, 0)
+        n2fbd.GetGpforcesLcInc(listacasos, listaframes)
 
         # Ejecuto el métedo que calcula las resultantes (por fin)
         # tuple_lc_inc = System.Tuple[System.Int32](self.__loadcase.ID, self.__increment.ID)

{naxtopy-2.2.3 → naxtopy-3.0.0}/src/NaxToPy/Core/Classes/N2PLoadCase.py

@@ -17,7 +17,6 @@ class N2PLoadCase:
         NumIncrements: int.
         ActiveN2PIncrement: N2PIncrement.
         TypeLC: int.
-        IsComplex: bool.
         InternalID: int.
     """
 
@@ -26,7 +25,6 @@ class N2PLoadCase:
         "__idoriginal",
         "__increments",
         "__incrementsnumberlist",
-        "__iscomplex",
         "__lctype",
         "__namelc",
         "__results",
@@ -37,11 +35,12 @@ class N2PLoadCase:
         "__n2loadcase",
         "__increments_by_name",
         "__increments_by_id",
+        "__ref_temp"
     )
 
 
     # Constructor de N2PLoadCase ---------------------------------------------------------------------------------------
-    def __init__(self, id_lc, id_original, increments, increments_number_list, is_complex, lc_type, name, results,
+    def __init__(self, id_lc, id_original, increments, increments_number_list, lc_type, name, results,
                  solution_type, solver, model_father, n2loadcase):
         '''Python Load Case Constructor
         Input:
@@ -49,7 +48,6 @@ class N2PLoadCase:
             IDOriginal: int -> Original Identification Number of the Load Case
             Increments: list[N2Increment] -> list with instances of N2Increment
             IncrementsNumberList: list[int] -> list with the number associated to each increment
-            IsComplex: bool -> boolean value. True if the LC is associated to a complex LC
             LCType: str -> Type of solution applied in the load case
             Name : str -> Name of the load case
             Solver : str -> Solver of the load case
@@ -64,7 +62,6 @@ class N2PLoadCase:
         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(
@@ -73,7 +70,6 @@ class N2PLoadCase:
             results[i].derivedComps,
             results[i].Description,
             results[i].elemTypes,
-            results[i].fcode,
             results[i].Name,
             self) for i in range(0, len(results))}
 
@@ -85,6 +81,7 @@ class N2PLoadCase:
 
         self.__increments_by_name = dict()
         self.__increments_by_id = dict()
+        self.__ref_temp: float = None
     # ------------------------------------------------------------------------------------------------------------------
 
     # Metodo para obtener el numero de identificacion interno del caso de carga ----------------------------------------
@@ -114,13 +111,6 @@ class N2PLoadCase:
         return self.__increments
     # ------------------------------------------------------------------------------------------------------------------
 
-    # Metodo para obtener si un caso de carga esta asociado a una solucion compleja ------------------------------------
-    @property
-    def IsComplex(self) -> bool:
-        """Returns a boolean indicating whether the load case is associated to a complex solution"""
-        return bool(self.__iscomplex)
-    # ------------------------------------------------------------------------------------------------------------------
-
     # Metodo para obtener el tipo de caso de Carga ---------------------------------------------------------------------
     @property
     def TypeLC(self) -> str:
@@ -206,6 +196,17 @@ class N2PLoadCase:
         return str(self.__n2loadcase.PathFile)
     # ------------------------------------------------------------------------------------------------------------------
 
+    # Propiedad que devulve la temperatura de referencia ---------------------------------------------------------------
+    @property
+    def RefTemp(self) -> float:
+        """Returns the reference temperature of the load case"""
+        return self.__ref_temp
+    
+    @RefTemp.setter
+    def RefTemp(self, value) -> None:
+        self.__ref_temp = value
+    # ------------------------------------------------------------------------------------------------------------------
+
     # Metodo para obtener los incrementos disponibles en el caso de carga ----------------------------------------------
     def get_increments(self, id: Union[int, str]) -> N2PIncrement:
         ''' Returns the N2PIncrement object with the id=ID or the id=Name of the Increment