models#

The EasyFEA/models/ module in EasyFEA provides essential tools for creating and managing models. These models are used to build _Simu instances and mainly contain material parameters.

With this module, you can construct:

Detailed materials API#

class EasyFEA.models._IModel[source]#

Model interface.

Need_Update(value=True)[source]#

Indicates whether the object needs to be updated.

abstract property dim: int#

model dimension

property isHeterogeneous: bool#

indicates whether the model has heterogeneous parameters

abstract property modelType: ModelType#

model type

abstract property thickness: float#

thickness used in the model

Module containing constitutive laws for materials, including elastic, hyperelastic, damage, thermal, and beam materials.

class EasyFEA.Models.Beam[source]#

Beam models

class BeamStructure(beams)#

Beam structure class.

Calc_D_e_pg(groupElem)#

Returns a matrix characterizing the beams’s stiffness behavior.

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Get_axis_e(groupElem)#

Returns the fiber and cross bar vertical axis on every elements.

return xAxis_e, yAxis_e

Return type:

tuple[ndarray[tuple[Any, ...], dtype[floating]], ndarray[tuple[Any, ...], dtype[floating]]]

property areas: list[float]#

beams areas

property beams: list[_Beam]#
property dim: int#

model dimensions

1D -> tension compression

2D -> tension compression + bending + flexion

3D -> all

property dof_n: int#

Degrees of freedom per node.

1D -> [u1, … , un]

2D -> [u1, v1, rz1, …, un, vn, rzn]

3D -> [u1, v1, w1, rx1, ry1, rz1, …, u2, v2, w2, rx2, ry2, rz2]

property modelType: ModelType#

model type

property nBeam: int#

Number of beams in the structure

property thickness: float#

The beam structure can have several beams and therefore different sections.

You need to look at the section of the beam you are interested in.

class Isotropic(dim, line, section, E, v, yAxis=(0, 1, 0))#

Isotropic elastic beam.

E: float#

Young’s modulus

Get_D()#

Returns a matrix characterizing the beam’s stiffness behavior.

Return type:

ndarray[tuple[Any, ...], dtype[floating]]

property mu: float#

shear modulus (G)

v: float#

Poisson’s ratio

class EasyFEA.Models.Elastic[source]#

Elastic models

class Anisotropic(dim, C, useVoigtNotation, axis1=(1, 0, 0), axis2=(0, 1, 0), thickness=1.0)#

Anisotropic Linearized Elastic material.

Set_C(C, useVoigtNotation=True, update_S=True)#

Updates the constitutives laws by updating the C stiffness and S compliance matrices in Kelvin Mandel notation.

Parameters:

  • C (_types.FloatArray) – Stifness matrix (Lamé’s law)

  • useVoigtNotation (bool, optional) – uses Kevin Mandel’s notation, by default True

  • update_S (bool, optional) – updates the compliance matrix (Hooke’s law), by default True

Walpole_Decomposition()#

Walpole’s decomposition in Kelvin Mandel notation such that:

C = sum(ci * Ei).

returns ci, Ei

Return type:

tuple[ndarray[tuple[Any, ...], dtype[floating]], ndarray[tuple[Any, ...], dtype[floating]]]

property axis1: ndarray[tuple[Any, ...], dtype[floating]]#

axis1 vector

property axis2: ndarray[tuple[Any, ...], dtype[floating]]#

axis2 vector

class Isotropic(dim, E=210000.0, v=0.3, planeStress=True, thickness=1.0)#

Isotropic Linearized Elastic material.

E: float#

Young’s modulus

Walpole_Decomposition()#

Walpole’s decomposition in Kelvin Mandel notation such that:

C = sum(ci * Ei).

returns ci, Ei

Return type:

tuple[ndarray[tuple[Any, ...], dtype[floating]], ndarray[tuple[Any, ...], dtype[floating]]]

get_bulk()#

Bulk modulus

get_lambda()#
get_mu()#

Shear coefficient

v: float#

Poisson’s ratio (-1<v<0.5)

class Orthotropic(dim, E1, E2, E3, G23, G13, G12, v23, v13, v12, axis_1=(1, 0, 0), axis_2=(0, 1, 0), planeStress=True, thickness=1.0)#

Orthotropic Linearized Elastic material.

E1: float#

Young’s modulus along axis_1.

E2: float#

Young’s modulus along axis_2.

E3: float#

Young’s modulus along axis_3.

G12: float#

Shear modulus in the 1-2 plane.

G13: float#

Shear modulus in the 1-3 plane.

G23: float#

Shear modulus in the 2-3 plane.

Walpole_Decomposition()#

Walpole’s decomposition in Kelvin Mandel notation such that:

C = sum(ci * Ei).

returns ci, Ei

Return type:

tuple[ndarray[tuple[Any, ...], dtype[floating]], ndarray[tuple[Any, ...], dtype[floating]]]

property axis_1: ndarray[tuple[Any, ...], dtype[floating]]#

Axis 1

property axis_2: ndarray[tuple[Any, ...], dtype[floating]]#

Axis 2

v12: float#

Poisson’s ratio for transverse strain along the axis_2 when stressed along the axis_1.

v13: float#

Poisson’s ratio for transverse strain along the axis_3 when stressed along the axis_1.

v23: float#

Poisson’s ratio for transverse strain along the axis_3 when stressed along the axis_2.

class TransverselyIsotropic(dim, El, Et, Gl, vl, vt, axis_l=(1, 0, 0), axis_t=(0, 1, 0), planeStress=True, thickness=1.0)#

Transversely Isotropic Linearized Elastic material.

El: float#

Longitudinal Young’s modulus.

Et: float#

Transverse Young’s modulus.

Gl: float#

Longitudinal shear modulus.

property Gt: float | ndarray[tuple[Any, ...], dtype[floating]]#

Transverse shear modulus.

Walpole_Decomposition()#

Walpole’s decomposition in Kelvin Mandel notation such that:

C = sum(ci * Ei).

returns ci, Ei

Return type:

tuple[ndarray[tuple[Any, ...], dtype[floating]], ndarray[tuple[Any, ...], dtype[floating]]]

property axis_l: ndarray[tuple[Any, ...], dtype[floating]]#

Longitudinal axis

property axis_t: ndarray[tuple[Any, ...], dtype[floating]]#

Transversal axis

property kt: float | ndarray[tuple[Any, ...], dtype[floating]]#
vl: float#

Longitudinal Poisson’s ratio (-1<vl<0.5).

vt: float#

Transverse Poisson ratio (-1<vt<1)

class EasyFEA.Models.HyperElastic[source]#

Hyperelastic models

class HolzapfelOgden(dim, C0, C1, C2, C3, C4, C5, C6, C7, K, Mu1, Mu2, T1, T2, ks=100, thickness=1.0)#
C0: float#
C1: float#
C2: float#
C3: float#
C4: float#
C5: float#
C6: float#
C7: float#
Compute_W(hyperElasticState)#

Computes the quadratic energy W(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

We_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_d2Wde(hyperElasticState)#

Computes dΣde.

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

dΣde_e_pg of shape (Ne, pg, d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dWde(hyperElasticState)#

Computes the second Piola-Kirchhoff tensor Σ(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Return type:

FeArray

Returns:

  • FeArray – Σ_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

  • Σxx, Σyy, Σzz, sqrt(2) Σyz, sqrt(2) Σxz, sqrt(2) Σxy

K: float#

Bulk modulus

Mu1: float#
Mu2: float#
T1#

direction(s) 1, used for the invariants I4 and I8

T2#

direction(s) 2, used for the invariants I6 and I8

class HyperElasticState(mesh, u, matrixType)#

Hyperelastic state.

Compute_C()#

Computes the right Cauchy-Green tensor C(u) = F(u)’.F(u)

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Returns:

  • FeArray – C_e_pg of shape (Ne, pg, 3, 3)

  • dim = 1

  • ——-

  • cxx 0 0

  • 0 1 0

  • 0 0 1

  • dim = 2

  • ——-

  • cxx cxy 0

  • cyx cyy 0

  • 0 0 1

  • dim = 3

  • ——-

  • cxx cxy cxz

  • cyx cyy cyz

  • czx czy czz

Compute_De()#

Computes De(u) derivative green lagrange matrix.

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Returns if dim = 2#

FeArray.FeArrayALike

D_e_pg of shape (Ne, pg, 3, 4)

[1+dxux, 0, dxuy, 0] # xx

[0, dyux, 0, 1+dyuy] # yy

2**(-1/2) [dyux, 1+dxux, 1+dyuy, dxuy # xy

Returns if dim = 3#

FeArray.FeArrayALike

D_e_pg of shape (Ne, pg, 6, 9)

[1+dxux, 0, 0, dxuy, 0, 0, dxuz, 0, 0] # xx

[0, dyux, 0, 0, 1+dyuy, 0, 0, dyuz, 0] # yy

[0, 0, dzux, 0, 0, dzuy, 0, 0, 1+dzuz] # zz

2**(-1/2) [0, dzux, dyux, 0, dzuy, 1 + dyuy, 0, 1 + dzuz, dyuz] # yz

2**(-1/2) [dzux, 0, 1 + dxux, dzuy, 0, dxuy, 1 + dzuz, 0, dxuz] # xz

2**(-1/2) [dyux, 1+dxux, 0, 1+dyuy, dxuy, 0, dyuz, dxuz, 0] # xy

Compute_Epsilon()#

Computes the linearized deformation Epsilon = 1/2 (grad(u)’ + grad(u))

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Returns if dim = 2#

FeArray

Eps_e_pg of shape (Ne, pg, 3)

[xx, yy, 2**(-1/2) xy]

Returns if dim = 3#

FeArray

Eps_e_pg of shape (Ne, pg, 6)

[xx, yy, zz, 2**(-1/2) yz, 2**(-1/2) xz, 2**(-1/2) xy]

Compute_F()#

Computes the deformation gradient F(u) = I + grad(u)

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Returns:

  • FeArray – F(u) of shape (Ne, pg, 3, 3)

  • dim = 1

  • ——-

  • 1+dxux 0 0

  • 0 1 0

  • 0 0 1

  • dim = 2

  • ——-

  • 1+dxux dyux 0

  • dxuy 1+dyuy 0

  • 0 0 1

  • dim = 3

  • ——-

  • 1+dxux dyux dzux

  • dxuy 1+dyuy dzuy

  • dxuz dyuz 1+dzuz

Compute_GreenLagrange()#

Computes the Green-Lagrange deformation E = 1/2 (C - I)

Returns:

E_e_pg of shape (Ne, pg, dim, dim)

Return type:

FeArray

Compute_I1()#

Computes I1(u)

Returns:

I1_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_I2()#

Computes I2(u)

Returns:

I2_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_I3()#

Computes I3(u)

Returns:

I3_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_I4(T)#

Computes I4(u)

Parameters:

T (_types.FloatArray) – direction(s)

Returns:

I4_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_I6(T)#

Computes I6(u)

Parameters:

T (_types.FloatArray) – direction(s)

Returns:

I6_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_I8(T1, T2)#

Computes I8(u)

Parameters:

  • T1 (_types.FloatArray) – direction(s) 1

  • T2 (_types.FloatArray) – direction(s) 2

Returns:

I8_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_J()#

Computes the deformation gradient J = det(F)

Returns:

J_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_d2I1dC()#

Computes d2I1dC(u)

Returns:

d2I1dC of shape (d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_d2I2dC()#

Computes d2I2dC(u)

Returns:

d2I2dC of shape (d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_d2I3dC()#

Computes d2I3dC(u)

Returns:

d2I3dC_e_pg of shape (Ne, pg, d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_d2I4dC()#

Computes d2I4dC(u)

Returns:

d2I4dC of shape (d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_d2I6dC()#

Computes d2I6dC(u)

Returns:

d2I6dC of shape (d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_d2I8dC()#

Computes d2I8dC(u)

Returns:

d2I8dC of shape (d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI1dC()#

Computes dI1dC(u)

Returns:

dI1dC of shape (d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI2dC()#

Computes dI2dC(u)

Returns:

dI2dC_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI3dC()#

Computes dI3dC(u)

Returns:

dI3dC_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI4dC(T)#

Computes dI4dC(u)

Parameters:

T (_types.FloatArray) – direction(s)

Returns:

dI4dC_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI6dC(T)#

Computes dI6dC(u)

Parameters:

T (_types.FloatArray) – direction(s)

Returns:

dI6dC_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dI8dC(T1, T2)#

Computes dI8dC(u)

Parameters:

  • T1 (_types.FloatArray) – direction(s) 1

  • T2 (_types.FloatArray) – direction(s) 2

Returns:

dI8dC_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

property mesh#
class MooneyRivlin(dim, K1, K2, K=0.0, thickness=1.0)#
Compute_W(hyperElasticState)#

Computes the quadratic energy W(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

We_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_d2Wde(hyperElasticState)#

Computes dΣde.

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

dΣde_e_pg of shape (Ne, pg, d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dWde(hyperElasticState)#

Computes the second Piola-Kirchhoff tensor Σ(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Return type:

FeArray

Returns:

  • FeArray – Σ_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

  • Σxx, Σyy, Σzz, sqrt(2) Σyz, sqrt(2) Σxz, sqrt(2) Σxy

K: float#

Bulk modulus

K1: float#

Kappa1

K2: float#

Kappa2

class NeoHookean(dim, K, thickness=1.0)#
Compute_W(hyperElasticState)#

Computes the quadratic energy W(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

We_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_d2Wde(hyperElasticState)#

Computes dΣde.

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

dΣde_e_pg of shape (Ne, pg, d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dWde(hyperElasticState)#

Computes the second Piola-Kirchhoff tensor Σ(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Return type:

FeArray

Returns:

  • FeArray – Σ_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

  • Σxx, Σyy, Σzz, sqrt(2) Σyz, sqrt(2) Σxz, sqrt(2) Σxy

K: float#

Bulk modulus

class SaintVenantKirchhoff(dim, lmbda, mu, K=0.0, thickness=1.0)#
Compute_W(hyperElasticState)#

Computes the quadratic energy W(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

We_e_pg of shape (Ne, pg)

Return type:

FeArray

Compute_d2Wde(hyperElasticState)#

Computes dΣde.

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Returns:

dΣde_e_pg of shape (Ne, pg, d, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

Return type:

FeArray

Compute_dWde(hyperElasticState)#

Computes the second Piola-Kirchhoff tensor Σ(u).

Parameters:

hyperElasticState (HyperElasticState) – Hyperelastic state containing the mesh, the discretized field, and the matrix type.

Return type:

FeArray

Returns:

  • FeArray – Σ_e_pg of shape (Ne, pg, d), where d = 1, 3, 6 depending on whether the solution dimension is 1D, 2D, or 3D.

  • Σxx, Σyy, Σzz, sqrt(2) Σyz, sqrt(2) Σxz, sqrt(2) Σxy

K: float#

Bulk modulus

lmbda: float#

Lame’s first parameter

mu: float#

Shear modulus

class EasyFEA.Models.PhaseField(material, split, regularization, Gc, l0, solver=SolverType.History, A=None, useNumba=True)[source]#

PhaseField class.

A#

matrix characterizing the weak anisotropy in the crack surface density function

Calc_C(Epsilon_e_pg, verif=False)[source]#

Computes the splited stifness matrices for the given strain field.

Parameters:

Epsilon_e_pg (FeArray.FeArrayALike) – strains field (e, p, D)

Returns:

cP_e_pg, cM_e_pg: positive and negative stifness matrices (e, p, D, D)

Return type:

FeArray

Calc_Sigma_e_pg(Epsilon_e_pg)[source]#

Computes the Stress field using the strains and the split such that:

SigmaP_e_pg = cP_e_pg * Epsilon_e_pg

SigmaM_e_pg = cM_e_pg * Epsilon_e_pg

Parameters:

Epsilon_e_pg (FeArray.FeArrayALike) – strains field (e, p, D)

Returns:

SigmaP_e_pg, SigmaM_e_pg: positive and negative stress fields (e, p, D)

Return type:

FeArray

Calc_psi_e_pg(Epsilon_e_pg)[source]#

Computes the elastic energy densities.

psiP_e_pg = 1/2 SigmaP_e_pg * Epsilon_e_pg

psiM_e_pg = 1/2 SigmaM_e_pg * Epsilon_e_pg

Such as :

SigmaP_e_pg = cP_e_pg * Epsilon_e_pg

SigmaM_e_pg = cM_e_pg * Epsilon_e_pg

Return type:

tuple[Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]], Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]]

Gc: float#

critical energy release rate

Get_f_e_pg(PsiP_e_pg)[source]#

Returns source therm

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Get_g_e_pg(d_n, mesh, matrixType, k_res=1e-12)[source]#

Returns degradation function

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

Get_r_e_pg(PsiP_e_pg)[source]#

Returns reaction therm

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

static Get_regularizations()[source]#

Returns regularizations available

Return type:

list[ReguType]

static Get_solvers()[source]#

Returns available solvers used to manage crack irreversibility

Return type:

list[SolverType]

static Get_splits()[source]#

Returns splits available

Return type:

list[SplitType]

class ReguType(value)[source]#

Regularization models.

AT1 = 'AT1'#
AT2 = 'AT2'#
class SolverType(value)[source]#

Solver used to manage crack irreversibility.

BoundConstrain = 'BoundConstrain'#
History = 'History'#
HistoryDamage = 'HistoryDamage'#
class SplitType(value)[source]#

Split models.

Amor = 'Amor'#
AnisotStrain = 'AnisotStrain'#
AnisotStrain_MP = 'AnisotStrain_MP'#
AnisotStrain_NoCross = 'AnisotStrain_NoCross'#
AnisotStrain_PM = 'AnisotStrain_PM'#
AnisotStress = 'AnisotStress'#
AnisotStress_MP = 'AnisotStress_MP'#
AnisotStress_NoCross = 'AnisotStress_NoCross'#
AnisotStress_PM = 'AnisotStress_PM'#
Bourdin = 'Bourdin'#
He = 'He'#
Miehe = 'Miehe'#
Stress = 'Stress'#
Zhang = 'Zhang'#
property c_w#

scaling parameter for accurate dissipation of crack energy

property dim: int#

model dimension

property isHeterogeneous: bool#

indicates whether the model has heterogeneous parameters

property k: float | ndarray[tuple[Any, ...], dtype[floating]]#

get diffusion therm

l0: float#

half crack width

property material: _Elastic#

elastic material

property modelType: ModelType#

model type

regularization: ReguType#

crack regularization model

solver: SolverType#

solver used to manage crack irreversibility

split: SplitType#

split used to decompose the elastic energy density

property thickness: float#

thickness used in the model

EasyFEA.Models.Reshape_variable(variable, Ne, nPg)[source]#

Resizes variable to (Ne, nPg, …) shape.

Return type:

Union[FeArray, ndarray[tuple[Any, ...], dtype[Any]]]

class EasyFEA.Models.Thermal(k, c=0.0, thickness=1.0)[source]#

Thermal class.

c#

mass heat capacity [J K^-1 kg^-1]

dim: int#
property isHeterogeneous: bool#

indicates whether the model has heterogeneous parameters

k#

thermal conductivity [W m^-1]

property modelType: ModelType#

model type

thickness: float#
class EasyFEA.Models.WeakForms(field, computeK, computeC=None, computeM=None, computeF=None, thickness=1.0)[source]#

Class responsible for computing the finite element matrices used in the system ( K u + C v + M a = F ).

property computeC: BiLinearForm | None#

Function used to build damping matrix C from ( K u + C v + M a = F ).

property computeF: LinearForm | None#

Function used to build force vector F from ( K u + C v + M a = F ).

property computeK: BiLinearForm | None#

Function used to build stiffness matrix K from ( K u + C v + M a = F ).

property computeM: BiLinearForm | None#

Function used to build mass matrix M from ( K u + C v + M a = F ).

property dim: int#

model dimension

property field: Field#

Finite element field.

property modelType: ModelType#

model type

thickness: float#
On this page
Edit on GitHub

This Page