Struct Model 

pub struct Model<B, const D: usize> { /* private fields */ }

Implementations

impl<B, const D: usize> Model<B, D>

pub fn blocks(&self) -> &B

Trait Implementations

impl<B: Debug, const D: usize> Debug for Model<B, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B, const D: usize> ElasticElements<D> for Model<B, D>

where B: ElasticElements<D>,

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_forces: &mut NodalForcesSolid<D>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_stiffnesses: &mut NodalStiffnessesSolid<D>, ) -> Result<(), ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<B, const D: usize> ElasticHyperviscousElements<D> for Model<B, D>

where B: ElasticHyperviscousElements<D>,

fn viscous_dissipation( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, ) -> Result<Scalar, ElementModelError>

fn dissipation_potential( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, ) -> Result<Scalar, ElementModelError>

impl<B, S, const D: usize> ElasticViscoplasticElements<S, D> for Model<B, D>

where B: ElasticViscoplasticElements<S, D>,

fn initial_state(&self) -> S

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, nodal_forces: &mut NodalForcesSolid<D>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, nodal_stiffnesses: &mut NodalStiffnessesSolid<D>, ) -> Result<(), ElementModelError>

fn state_variables_evolution( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<S, ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<B, const D: usize> ElementModel<D> for Model<B, D>

where B: Debug,

fn coordinates(&self) -> &NodalReferenceCoordinates<D>

impl<B, const D: usize> Elements for Model<B, D>

where B: Elements,

fn node_neighbors(&self, neighbors: &mut [Vec<usize>])

impl<B, const D: usize> FirstOrderMinimize<f64, TensorVector<TensorRank1<D, 1>>> for Model<B, D>

where B: HyperelasticElements<D>,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderOptimization<Scalar, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> FirstOrderMinimize<f64, Vector> for Model<B, D>

where B: ThermalConductionElements,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderOptimization<Scalar, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> FirstOrderRoot<D> for Model<B, D>

where B: ViscoelasticElements<D>,

fn root( &self, equality_constraint: EqualityConstraint, integrator: impl ImplicitDaeFirstOrderRoot<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalVelocities<D>, NodalVelocitiesHistory<D>>, time: &[Scalar], solver: impl FirstOrderRootFinding<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, ) -> Result<(Times, NodalCoordinatesHistory<D>, NodalVelocitiesHistory<D>), IntegrationError>

impl<B, S, H, const D: usize> FirstOrderRoot<S, H, D> for Model<B, D>

where B: ElasticViscoplasticElements<S, D>, S: Tensor, H: TensorVec<Item = S>,

fn root( &self, integrator: impl ExplicitDaeFirstOrderRoot<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, S, NodalCoordinates<D>, H, NodalCoordinatesHistory<D>>, solver: impl FirstOrderRootFinding<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, time: &[Scalar], bcs: ElasticViscoplasticBCs, ) -> Result<(Times, NodalCoordinatesHistory<D>, H), IntegrationError>

impl<B, const D: usize> FirstOrderRoot<TensorVector<TensorRank1<D, 1>>, TensorVector<TensorRank2SparseVec<D, 1, 1>>, TensorVector<TensorRank1<D, 1>>> for Model<B, D>

where B: ElasticElements<D>,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderRootFinding<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> FirstOrderRoot<Vector, SquareMatrix, Vector> for Model<B, D>

where B: ThermalConductionElements,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderRootFinding<NodalForcesThermal, NodalStiffnessesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> From<(B, TensorVector<TensorRank1<D, 0>>)> for Model<B, D>

fn from((blocks, coordinates): (B, NodalReferenceCoordinates<D>)) -> Self

Converts to this type from the input type.

impl<B, const D: usize> HyperelasticElements<D> for Model<B, D>

where B: HyperelasticElements<D>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<D>, ) -> Result<Scalar, ElementModelError>

fn nodal_stiffnesses_symmetric_into( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_stiffnesses: &mut NodalStiffnessesSolidSymmetric<D>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_symmetric( &self, nodal_coordinates: &NodalCoordinates<D>, ) -> Result<NodalStiffnessesSolidSymmetric<D>, ElementModelError>

impl<B, S, const D: usize> HyperelasticViscoplasticElements<S, D> for Model<B, D>

where B: HyperelasticViscoplasticElements<S, D>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<Scalar, ElementModelError>

impl<B, const D: usize> HyperviscoelasticElements<D> for Model<B, D>

where B: HyperviscoelasticElements<D>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<D>, ) -> Result<Scalar, ElementModelError>

impl<B, const D: usize> SecondOrderMinimize<D> for Model<B, D>

where B: ElasticHyperviscousElements<D>,

fn minimize( &self, equality_constraint: EqualityConstraint, integrator: impl ImplicitDaeSecondOrderMinimize<Scalar, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalVelocities<D>, NodalVelocitiesHistory<D>>, time: &[Scalar], solver: impl SecondOrderOptimization<Scalar, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, ) -> Result<(Times, NodalCoordinatesHistory<D>, NodalVelocitiesHistory<D>), IntegrationError>

impl<B, S, H, const D: usize> SecondOrderMinimize<S, H, D> for Model<B, D>

where B: HyperelasticViscoplasticElements<S, D>, S: Tensor, H: TensorVec<Item = S>,

fn minimize( &self, integrator: impl ExplicitDaeSecondOrderMinimize<Scalar, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, S, NodalCoordinates<D>, H, NodalCoordinatesHistory<D>>, solver: impl SecondOrderOptimization<Scalar, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, time: &[Scalar], bcs: ElasticViscoplasticBCs, ) -> Result<(Times, NodalCoordinatesHistory<D>, H), IntegrationError>

impl<B, const D: usize> SecondOrderMinimize<f64, TensorVector<TensorRank1<D, 1>>, TensorRank2SparseVec2DSymmetric<D, 1, 1>, TensorVector<TensorRank1<D, 1>>> for Model<B, D>

where B: HyperelasticElements<D>,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl SecondOrderOptimization<Scalar, NodalForcesSolid<D>, NodalStiffnessesSolidSymmetric<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> SecondOrderMinimize<f64, Vector, SquareMatrix, Vector> for Model<B, D>

where B: ThermalConductionElements,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl SecondOrderOptimization<Scalar, NodalForcesThermal, NodalStiffnessesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> ThermalConductionElements for Model<B, D>

where B: ThermalConductionElements,

fn potential( &self, nodal_temperatures: &NodalTemperatures, ) -> Result<Scalar, ElementModelError>

fn nodal_forces_into( &self, nodal_temperatures: &NodalTemperatures, nodal_forces: &mut NodalForcesThermal, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_temperatures: &NodalTemperatures, nodal_stiffnesses: &mut NodalStiffnessesThermal, ) -> Result<(), ElementModelError>

fn nodal_forces( &self, nodal_temperatures: &NodalTemperatures, ) -> Result<NodalForcesThermal, ElementModelError>

fn nodal_stiffnesses( &self, nodal_temperatures: &NodalTemperatures, ) -> Result<NodalStiffnessesThermal, ElementModelError>

impl<C, F, const G: usize, const N: usize, const P: usize> TryFrom<(Mesh<2>, C)> for Model<Block<C, F, G, 2, N, P>, 2>

where F: FiniteElement<G, 2, N, P> + From<PlanarElementNodalReferenceCoordinates<N>>, PrimitiveConnectivity<2, N>: TryFrom<Connectivity, Error = &'static str>,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, constitutive_model): (Mesh<2>, C), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<C1, C2, F1, F2, const G1: usize, const N1: usize, const P1: usize, const G2: usize, const N2: usize, const P2: usize> TryFrom<(Mesh<3>, (C1, C2))> for Model<Blocks<Block<C1, F1, G1, 3, N1, P1>, Block<C2, F2, G2, 3, N2, P2>>, 3>

where F1: FiniteElement<G1, 3, N1, P1> + From<ElementNodalReferenceCoordinates<N1>>, F2: FiniteElement<G2, 3, N2, P2> + From<ElementNodalReferenceCoordinates<N2>>, PrimitiveConnectivity<3, N1>: TryFrom<Connectivity, Error = &'static str>, PrimitiveConnectivity<3, N2>: TryFrom<Connectivity, Error = &'static str>,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, (constitutive_model_1, constitutive_model_2)): (Mesh<3>, (C1, C2)), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<C1, C2, F1, F2, const G1: usize, const N1: usize, const P1: usize, const G2: usize, const N2: usize, const P2: usize> TryFrom<(Mesh<3>, (C1, C2))> for Model<ElasticViscoplasticAndElastic<Block<C1, F1, G1, 3, N1, P1>, Block<C2, F2, G2, 3, N2, P2>>, 3>

where F1: FiniteElement<G1, 3, N1, P1> + From<ElementNodalReferenceCoordinates<N1>>, F2: FiniteElement<G2, 3, N2, P2> + From<ElementNodalReferenceCoordinates<N2>>, PrimitiveConnectivity<3, N1>: TryFrom<Connectivity, Error = &'static str>, PrimitiveConnectivity<3, N2>: TryFrom<Connectivity, Error = &'static str>,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, (constitutive_model_1, constitutive_model_2)): (Mesh<3>, (C1, C2)), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<C, F> TryFrom<(Mesh<3>, C)> for Model<Block<C, F>, 3>

where F: VirtualElement,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, constitutive_model): (Mesh<3>, C), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<C, F, const G: usize, const N: usize, const P: usize> TryFrom<(Mesh<3>, C)> for Model<Block<C, F, G, 3, N, P>, 3>

where F: FiniteElement<G, 3, N, P> + From<ElementNodalReferenceCoordinates<N>>, PrimitiveConnectivity<3, N>: TryFrom<Connectivity, Error = &'static str>,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, constitutive_model): (Mesh<3>, C), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<B, const D: usize> ViscoelasticElements<D> for Model<B, D>

where B: ViscoelasticElements<D>,

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, nodal_forces: &mut NodalForcesSolid<D>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, nodal_stiffnesses: &mut NodalStiffnessesSolid<D>, ) -> Result<(), ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, nodal_velocities: &NodalVelocities<D>, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<B, const D: usize> ZerothOrderRoot<TensorVector<TensorRank1<D, 1>>> for Model<B, D>

where B: ElasticElements<D>,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl ZerothOrderRootFinding<NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> ZerothOrderRoot<Vector> for Model<B, D>

where B: ThermalConductionElements,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl ZerothOrderRootFinding<NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>