From 9dc443956d595a1f689765618ad957bc7e610646 Mon Sep 17 00:00:00 2001 From: Thomas Oberbichler Date: Wed, 27 Apr 2022 11:25:54 +0200 Subject: [PATCH] Remove type alias --- nfem/model.py | 49 +++++++++++++++++++++++-------------------------- nfem/node.py | 12 +++++------- nfem/spring.py | 21 +++++++++------------ nfem/truss.py | 20 +++++++++----------- 4 files changed, 46 insertions(+), 56 deletions(-) diff --git a/nfem/model.py b/nfem/model.py index e4a7594..d03b7b3 100755 --- a/nfem/model.py +++ b/nfem/model.py @@ -24,9 +24,6 @@ DofID = Union[str, Dof, Tuple[str, str]] -Vector = npt.NDArray[np.float64] -Matrix = npt.NDArray[np.float64] - class Model: """Model of a nonlinear finite element problem.""" @@ -44,7 +41,7 @@ def __init__(self, name: str = None): self._previous_model: Model = None self.det_k: Optional[float] = None self.first_eigenvalue: Optional[float] = None - self.first_eigenvector_model: Optional[Vector] = None + self.first_eigenvector_model: Optional[npt.NDArray[np.float64]] = None # === modeling @@ -222,7 +219,7 @@ def dof(self, id: str) -> Dof: # === r and k - def compute_linear_r(self) -> Vector: + def compute_linear_r(self) -> npt.NDArray[np.float64]: """Compute the linear residual force vector of the element.""" assembler = Assembler(self) @@ -235,40 +232,40 @@ def compute_linear_r(self) -> Vector: r[:] *= self.load_factor - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_linear_r() r = assembler.assemble_vector(compute_local) return r[:n] - def compute_linear_k(self) -> Matrix: + def compute_linear_k(self) -> npt.NDArray[np.float64]: """Compute the linear stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_linear_k() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def compute_linear_kg(self) -> Matrix: + def compute_linear_kg(self) -> npt.NDArray[np.float64]: """Compute the linear geometric stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_linear_kg() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def compute_r(self) -> Vector: + def compute_r(self) -> npt.NDArray[np.float64]: """Compute the nonlinear residual force vector of the element.""" assembler = Assembler(self) @@ -281,75 +278,75 @@ def compute_r(self) -> Vector: r[:] *= self.load_factor - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_r() assembler.assemble_vector(compute_local, out=r) return r[:n] - def compute_k(self) -> Matrix: + def compute_k(self) -> npt.NDArray[np.float64]: """Compute the nonlinear stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_k() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def get_stiffness(self) -> Matrix: + def get_stiffness(self) -> npt.NDArray[np.float64]: return self.compute_k() - def compute_ke(self) -> Matrix: + def compute_ke(self) -> npt.NDArray[np.float64]: """Compute the elastic stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_ke() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def compute_km(self) -> Matrix: + def compute_km(self) -> npt.NDArray[np.float64]: """Compute the material stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_km() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def compute_kg(self) -> Matrix: + def compute_kg(self) -> npt.NDArray[np.float64]: """Compute the geometric stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_kg() k = assembler.assemble_matrix(compute_local) return k[:n, :n] - def compute_kd(self) -> Matrix: + def compute_kd(self) -> npt.NDArray[np.float64]: """Compute the initial-displacement stiffness matrix of the element.""" assembler = Assembler(self) n, _ = assembler.size - def compute_local(element: Element) -> Vector: + def compute_local(element: Element) -> npt.NDArray[np.float64]: return element.compute_kd() k = assembler.assemble_matrix(compute_local) @@ -389,7 +386,7 @@ def get_lam_increment(self) -> float: return current_value - previous_value - def get_increment_vector(self, assembler: Assembler = None) -> Vector: + def get_increment_vector(self, assembler: Assembler = None) -> npt.NDArray[np.float64]: """Get the increment that resulted in the current position. @assembler: Initialized assembler. @@ -796,7 +793,7 @@ def solve_eigenvalues(self, assembler: Assembler = None) -> None: self.first_eigenvector_model = model - def get_tangent_vector(self, assembler: Assembler = None) -> Vector: + def get_tangent_vector(self, assembler: Assembler = None) -> npt.NDArray[np.float64]: """Get the tangent vector. @tangent: Tangent vector t = [v, 1] @@ -1097,7 +1094,7 @@ def scale_prediction(self, factor): self.load_factor += delta_lambda def get_delta_dof_vector(self, model_b: Model = None, - assembler: Assembler = None) -> Vector: + assembler: Assembler = None) -> npt.NDArray[np.float64]: """Get the delta dof between this and a given model_b as a numpy array. @model_b: Model that is used as reference for the delta dof diff --git a/nfem/node.py b/nfem/node.py index 993ede8..683aecb 100644 --- a/nfem/node.py +++ b/nfem/node.py @@ -9,8 +9,6 @@ from typing import Sequence -Vector = npt.NDArray[np.float64] - class Node: """Three dimensional Node. @@ -85,7 +83,7 @@ def ref_z(self, value: float) -> None: self._dof_z.ref_value = value @property - def ref_location(self) -> Vector: + def ref_location(self) -> npt.NDArray[np.float64]: """Get or set the location in the undeformed configuration.""" return np.array([self.ref_x, self.ref_y, self.ref_z]) @@ -123,7 +121,7 @@ def z(self, value: float) -> None: self._dof_z.value = value @property - def location(self) -> Vector: + def location(self) -> npt.NDArray[np.float64]: """Get or set the location in the deformed configuration.""" return np.array([self.x, self.y, self.z]) @@ -161,7 +159,7 @@ def w(self, value: float) -> None: self._dof_z.delta = value @property - def displacement(self) -> Vector: + def displacement(self) -> npt.NDArray[np.float64]: """Get or set the displacement.""" return np.array([self.u, self.v, self.w]) @@ -199,7 +197,7 @@ def fz(self, value: float) -> None: self._dof_z.external_force = value @property - def external_force(self) -> Vector: + def external_force(self) -> npt.NDArray[np.float64]: """Get or set the external force.""" return np.array([self.fx, self.fy, self.fz]) @@ -237,7 +235,7 @@ def rz(self, value: float) -> None: self._dof_z.residual = value @property - def residual(self) -> Vector: + def residual(self) -> npt.NDArray[np.float64]: """Get or set the residual force.""" return np.array([self.rx, self.ry, self.rz]) diff --git a/nfem/spring.py b/nfem/spring.py index 8b52bcc..792bb7f 100644 --- a/nfem/spring.py +++ b/nfem/spring.py @@ -10,9 +10,6 @@ from typing import Sequence -Vector = npt.NDArray[np.float64] -Matrix = npt.NDArray[np.float64] - class Spring: """Linear spring element.""" @@ -41,7 +38,7 @@ def dofs(self) -> Sequence[Dof]: # linear analysis - def compute_linear_r(self) -> Vector: + def compute_linear_r(self) -> npt.NDArray[np.float64]: """Compute the linear residual force vector of the element.""" return np.array([ self.kx * self.node.u, @@ -49,7 +46,7 @@ def compute_linear_r(self) -> Vector: self.kz * self.node.w, ], float) - def compute_linear_k(self) -> Matrix: + def compute_linear_k(self) -> npt.NDArray[np.float64]: """Compute the linear stiffness matrix of the element.""" return np.array([ [self.kx, 0, 0], @@ -57,33 +54,33 @@ def compute_linear_k(self) -> Matrix: [0, 0, self.kz], ], float) - def compute_linear_kg(self) -> Matrix: + def compute_linear_kg(self) -> npt.NDArray[np.float64]: """Compute the linear geometric stiffness matrix of the element.""" return np.zeros((3, 3)) # nonlinear analysis - def compute_r(self) -> Vector: + def compute_r(self) -> npt.NDArray[np.float64]: """Compute the nonlinear residual force vector of the element.""" return self.compute_linear_r() - def compute_k(self) -> Matrix: + def compute_k(self) -> npt.NDArray[np.float64]: """Compute the nonlinear stiffness matrix of the element.""" return self.compute_ke() - def compute_ke(self) -> Matrix: + def compute_ke(self) -> npt.NDArray[np.float64]: """Compute the elastic stiffness matrix of the element.""" return self.compute_linear_k() - def compute_km(self) -> Matrix: + def compute_km(self) -> npt.NDArray[np.float64]: """Compute the material stiffness matrix of the element.""" return self.compute_linear_k() - def compute_kg(self) -> Matrix: + def compute_kg(self) -> npt.NDArray[np.float64]: """Compute the geometric stiffness matrix of the element.""" return np.zeros((3, 3)) - def compute_kd(self) -> Matrix: + def compute_kd(self) -> npt.NDArray[np.float64]: """Compute the initial-displacement stiffness matrix of the element.""" return np.zeros((3, 3)) diff --git a/nfem/truss.py b/nfem/truss.py index 50e74c2..bc91828 100755 --- a/nfem/truss.py +++ b/nfem/truss.py @@ -11,8 +11,6 @@ from typing import Optional, Sequence -Vector = npt.NDArray[np.float64] -Matrix = npt.NDArray[np.float64] dg = np.array([ [-1, 0, 0, 1, 0, 0], @@ -123,7 +121,7 @@ def normal_force(self) -> float: # linear analysis - def compute_linear_r(self) -> Vector: + def compute_linear_r(self) -> npt.NDArray[np.float64]: """Compute the linear residual force vector of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -138,7 +136,7 @@ def compute_linear_r(self) -> Vector: return dp @ dg - def compute_linear_k(self) -> Matrix: + def compute_linear_k(self) -> npt.NDArray[np.float64]: """Compute the linear stiffness matrix of the element.""" A1 = self.node_b.ref_location - self.node_a.ref_location @@ -149,7 +147,7 @@ def compute_linear_k(self) -> Matrix: return dg.T @ ddp @ dg - def compute_linear_kg(self) -> Matrix: + def compute_linear_kg(self) -> npt.NDArray[np.float64]: """Compute the linear geometric stiffness matrix of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -166,7 +164,7 @@ def compute_linear_kg(self) -> Matrix: # nonlinear analysis - def compute_r(self) -> Vector: + def compute_r(self) -> npt.NDArray[np.float64]: """Compute the nonlinear residual force vector of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -181,7 +179,7 @@ def compute_r(self) -> Vector: return dp @ dg - def compute_k(self) -> Matrix: + def compute_k(self) -> npt.NDArray[np.float64]: """Compute the nonlinear stiffness matrix of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -199,11 +197,11 @@ def compute_k(self) -> Matrix: return dg.T @ ddp @ dg - def compute_ke(self) -> Matrix: + def compute_ke(self) -> npt.NDArray[np.float64]: """Compute the elastic stiffness matrix of the element.""" return self.compute_linear_k() - def compute_km(self) -> Matrix: + def compute_km(self) -> npt.NDArray[np.float64]: """Compute the material stiffness matrix of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -215,7 +213,7 @@ def compute_km(self) -> Matrix: return dg.T @ ddp @ dg - def compute_kg(self) -> Matrix: + def compute_kg(self) -> npt.NDArray[np.float64]: """Compute the geometric stiffness matrix of the element.""" a1 = self.node_b.location - self.node_a.location A1 = self.node_b.ref_location - self.node_a.ref_location @@ -230,7 +228,7 @@ def compute_kg(self) -> Matrix: return dg.T @ ddp @ dg - def compute_kd(self) -> Matrix: + def compute_kd(self) -> npt.NDArray[np.float64]: """Compute the initial-displacement stiffness matrix of the element.""" km = self.compute_km() ke = self.compute_linear_k()