NaxToPy 1.0.1__tar.gz → 1.1.1__tar.gz

{NaxToPy-1.0.1/src/NaxToPy.egg-info → NaxToPy-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NaxToPy
-Version: 1.0.1
+Version: 1.1.1
 Summary: Package for postprocessing FEM results in Python
 Home-page: https://idaerosolutions.com/
 Download-URL: https://appsource.microsoft.com/en-us/product/SaaS/idaerosolutionssl1685692009813.naxto?signInModalType=2&ctaType=1
@@ -196,11 +196,15 @@ To see previous version see the pre-release versions in https://test.pypi.org/pr
 2. Bug Fix: N2PLog.set_directory now works correctly
 3. New download page for NaxTo and NaxToPy
 
+### v.1.1.0
+1. Bug Fix: PSOLID with material coordinate = -1 is now suppported
+2. Now, it is possible to modify the BDF data from Nastran and rewrite the files.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
 
-This version is only compatible with **NaxTo 2024.0.0**.
+This version is only compatible with **NaxTo 2024.0.1**.
 Check in Programs and Features the NaxTo version that is installed.
 
 NaxToPy only use three dependeces:

{NaxToPy-1.0.1 → NaxToPy-1.1.1}/README.md

@@ -72,11 +72,15 @@ To see previous version see the pre-release versions in https://test.pypi.org/pr
 2. Bug Fix: N2PLog.set_directory now works correctly
 3. New download page for NaxTo and NaxToPy
 
+### v.1.1.0
+1. Bug Fix: PSOLID with material coordinate = -1 is now suppported
+2. Now, it is possible to modify the BDF data from Nastran and rewrite the files.
+
 # Documentation
 
 **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
 
-This version is only compatible with **NaxTo 2024.0.0**.
+This version is only compatible with **NaxTo 2024.0.1**.
 Check in Programs and Features the NaxTo version that is installed.
 
 NaxToPy only use three dependeces:

{NaxToPy-1.0.1 → NaxToPy-1.1.1}/pyproject.toml

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

NaxToPy-1.1.1/src/NaxToPy/Core/Classes/AllClasses.py

@@ -0,0 +1,15 @@
+from NaxToPy.Core.Classes.N2PComponent import *
+from NaxToPy.Core.Classes.N2PResult import *
+from NaxToPy.Core.Classes.ProgresBar import *
+from NaxToPy.Core.Classes import N2PModelInputData
+from NaxToPy.Core.Classes.N2PConnector import *
+from NaxToPy.Core.Classes.N2PFreeBody import *
+from NaxToPy.Core.Classes.N2PCoord import *
+from NaxToPy.Core.Classes.N2PIncrement import *
+from NaxToPy.Core.Classes.N2PSection import *
+from NaxToPy.Core.Classes.N2PSet import *
+from NaxToPy.Core.Classes.N2PMaterial import *
+from NaxToPy.Core.Classes.N2PLoadCase import *
+from NaxToPy.Core.Classes.N2PNode import *
+from NaxToPy.Core.Classes.N2PElement import *
+from NaxToPy.Core.Classes.N2PProperty import *

{NaxToPy-1.0.1 → NaxToPy-1.1.1}/src/NaxToPy/Core/Classes/N2PComponent.py

@@ -4,6 +4,8 @@ from VizzerClasses import N2ParamInputResults
 from VizzerClasses import N2TensorTransformation
 from array import array
 import numpy as np
+from NaxToPy.Core._AuxFunc._NetToPython import _numpytonet
+from typing import Union
 
 
 # Clase Component de Python
@@ -73,7 +75,7 @@ class N2PComponent:
     # Metodo para llamar a la funcion de VizzerClasses 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: tuple = (1,0,0), v2: tuple = (0,1,0)) -> tuple[list, str]:
+                         v1: Union[tuple, np.ndarray] = (1,0,0), v2: Union[tuple, np.ndarray] = (0,1,0)) -> tuple[list, str]:
         """ Returns a tuple with the list of floats with the result array asked and a str with the position of the
         results
 
@@ -139,13 +141,7 @@ class N2PComponent:
 
         resultsParameters = self._create_n2paraminputresult(sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)
-
-        if self.__result_father__.__loadCase_father__.TypeLC == "DERIVED":
-            results = list(self.__result_father__.__loadCase_father__._N2PLoadCase__n2loadcase.CalculateLastArray(
-                           resultsParameters, 0))
-
-        else:
-            results = list(
+        results = list(
             self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel.CalculateArrayLastResult(
                 resultsParameters, 0))
 
@@ -163,7 +159,7 @@ class N2PComponent:
     # Metodo para llamar a la funcion de VizzerClasses 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: tuple = (1,0,0), v2: tuple = (0,1,0)) -> tuple[np.array, str]:
+                         v1: Union[tuple, np.ndarray ] = (1,0,0), v2: Union[tuple, np.ndarray ] = (0,1,0)) -> tuple[np.array, str]:
         """ Returns a tuple with the numpy array of floats with the result array asked and a str with the position of
         the results
 
@@ -205,9 +201,9 @@ class N2PComponent:
                 -10 : User defined,
                 >0  : Solver ID of the Predefined Coordinate System.
 
-            v1: tuple
+            v1: tuple|ndarray
 
-            v2: tuple -> Directions vectors that generate the coordinate system axis:
+            v2: tuple|ndarray -> Directions vectors that generate the coordinate system axis:
                 x=v1,
                 z=v1^v2,
                 y=z^x.
@@ -378,7 +374,8 @@ class N2PComponent:
         cs_dict = self.__result_father__.__loadCase_father__.__modelFather__._N2PModelContent__vzmodel.CalculateArrayLastResult(
                 formula, resultsParameters, 0)
 
-        py_dict = {(int(key.split(":")[0].split("LC")[1]), int(key.split(":")[1][2:])): np.array(value, np.float64)
+        py_dict = {(int(key.split(":")[0].replace("DoF_LCD", "-").replace("DoF_LC", "")),
+                    int(key.split(":")[1][2:])): np.array(value, np.float64)
                    for key, value in dict(cs_dict[0]).items()}
 
         return py_dict
@@ -419,12 +416,12 @@ class N2PComponent:
             elif coordsys < 0 and (v1 != (1, 0, 0) or v2 != (0, 1, 0)):
                 # Esto es una array de doubles. Si se quiere hacer una transformacion tanto en sistemas ya definidos en
                 # el solver como por el usuario hay que pasarlo como argumento de N2ParamInputResult
-                x, y, z = _get_axis(v1, v2)
-                x_array = array("d", x)
-                y_array = array("d", y)
-                z_array = array("d", z)
-                resultsParameters = N2ParamInputResults.structResults(0, x_array, y_array, z_array)
+                new_sys = _get_axis(v1, v2)
+                new_sys = _numpytonet(new_sys)
+
+                resultsParameters = N2ParamInputResults.structResults(0)
                 resultsParameters.coordSys = -10
+                resultsParameters.orientationcoordinatesystem = new_sys
 
             elif coordsys == -1:
                 resultsParameters = N2ParamInputResults.structResults(0)
@@ -519,31 +516,23 @@ class N2PComponent:
 # ----------------------------------------------------------------------------------------------------------------------
 
 
-def _get_axis(v1: tuple, v2: tuple) -> tuple:
+def _get_axis(v1: Union[tuple, np.ndarray], v2: Union[tuple, np.ndarray]) -> np.ndarray:
     """Function that returns the components of the three vectors of a rectangular coordinate system
 
     Args:
-        v1: tuple
-        v2: tuple
+        v1: tuple|ndarray
+        v2: tuple|ndarray
 
     Returns:
-        x, y, z: tuple
+        ndarray
     """
+    v1 = np.array(v1)
+    v1 = v1/np.linalg.norm(v1)
 
-    n1 = (v1[0]**2 + v1[1]**2 + v1[2]**2)**0.5
-    v1 = (v1[0]/n1, v1[1]/n1, v1[2]/n1)
-    
-    n2 = (v2[0]**2 + v2[1]**2 + v2[2]**2)**0.5
-    v2 = (v2[0]/n2, v2[1]/n2, v2[2]/n2)
-
-    x = v1
+    v2 = np.array(v2)
+    v2 = v2/np.linalg.norm(v2)
 
-    z = (v1[1] * v2[2] - v1[2] * v2[1],
-         v1[2] * v2[0] - v1[0] * v2[2],
-         v1[0] * v2[1] - v1[1] * v2[0])
-    
-    y = (z[1] * x[2] - z[2] * x[1],
-         z[2] * x[0] - z[0] * x[2],
-         z[0] * x[1] - z[1] * x[0])
+    z = np.cross(v1, v2)
+    y = np.cross(z, v1)
 
-    return x, y, z
+    return np.vstack((v1, y, z))

{NaxToPy-1.0.1 → NaxToPy-1.1.1}/src/NaxToPy/Core/Classes/N2PCoord.py

@@ -27,13 +27,13 @@ class N2PCoord(object):
     def ID(self) -> int:
         return int(self.__info.ID)
 
-    @property
-    def PartID(self) -> str:
-        try:
-            partid = int(self.__info.partID)
-        except:
-            partid = 0
-        return self.__model__._N2PModelContent__partIDtoStr.get(self.__info.Part, -1)
+    # @property
+    # def PartID(self) -> str:
+    #     try:
+    #         partid = int(self.__info.partID)
+    #     except:
+    #         partid = 0
+    #     return self.__model__._N2PModelContent__partIDtoStr.get(self.__info.Part, -1)
     
     @property
     def TypeSys(self) -> str:

{NaxToPy-1.0.1 → NaxToPy-1.1.1}/src/NaxToPy/Core/Classes/N2PLoadCase.py

@@ -27,7 +27,7 @@ class N2PLoadCase:
 
     # Constructor de N2PLoadCase ---------------------------------------------------------------------------------------
     def __init__(self, id, id_original, increments, increments_number_list, is_complex, lc_type, name, results,
-                 solution_type, model_father, n2loadcase):
+                 solution_type, solver, model_father, n2loadcase):
         '''Python Load Case Constructor
         Input:
             ID: int -> Identification Number of the Load Case
@@ -37,6 +37,7 @@ class N2PLoadCase:
             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
             Results: list[N2Results] -> list with instances of N2Results
         ----------
         Returns:
@@ -66,6 +67,7 @@ class N2PLoadCase:
 
         self.__solutiontype__ = solution_type
         self.__activeIncrement__ = list(increments)[-1].number
+        self.__solver__ = solver
         self.__modelFather__ = model_father
         self.__n2loadcase = n2loadcase
     # ------------------------------------------------------------------------------------------------------------------
@@ -155,6 +157,12 @@ class N2PLoadCase:
         return(str(self.__solutiontype__))
     # ------------------------------------------------------------------------------------------------------------------
 
+    # Metodo para obtener el solver del caso de carga ------------------------------------------------------------------
+    @property
+    def Solver(self) -> str:
+        return(str(self.__solver__))
+    # ------------------------------------------------------------------------------------------------------------------
+
     # 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