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<Quantity<Power>, ElementModelError>

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

impl<B, const G: usize, V, const D: usize> ElasticIVElements<G, V, D> for Model<B, D>

where B: ElasticIVElements<G, V, D>, V: Tensor,

fn internal_variables_initial(&self) -> InternalVariablesField<G, V>

The internal variables every integration point starts from.

fn internal_variables_increment( &self, nodal_coordinates: &NodalCoordinates<D>, internal_variables: &InternalVariablesField<G, V>, nodal_decrement: &NodalCoordinates<D>, step: Scalar, ) -> Result<InternalVariablesField<G, V>, ElementModelError>

Steps the internal variables everywhere alongside a decrement of the nodal coordinates, rather than solving them where the coordinates now are.

fn internal_variables_root( &self, local_solver: &NewtonRaphson, nodal_coordinates: &NodalCoordinates<D>, internal_variables: &InternalVariablesField<G, V>, ) -> Result<InternalVariablesField<G, V>, ElementModelError>

Solves the internal variables everywhere, holding the deformation fixed.

fn nodal_forces_eliminated_into( &self, nodal_coordinates: &NodalCoordinates<D>, internal_variables: &InternalVariablesField<G, V>, nodal_forces: &mut NodalForcesSolid<D>, ) -> Result<(), ElementModelError>

The nodal forces with the residual of the internal variables eliminated into them, for when they are carried rather than solved.

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

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

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

fn nodal_forces_eliminated( &self, nodal_coordinates: &NodalCoordinates<D>, internal_variables: &InternalVariablesField<G, V>, ) -> Result<NodalForcesSolid<D>, ElementModelError>

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

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

where B: ElasticViscoplasticElements<S, D>, S: Differentiable,

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<Derivative<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<Quantity<Energy>, TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: HyperelasticElements<D>,

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

impl<B, const D: usize> FirstOrderMinimize<Quantity<PowerTemperature>, TensorVector<Quantity<Power>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderOptimization<Quantity<PowerTemperature>, NodalForcesThermal, 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>, NodalDampingsSolid<D>, NodalCoordinates<D>, NodalCoordinatesHistory<D>, NodalVelocitiesHistory<D>>, time: &[Quantity<Time>], solver: impl FirstOrderRootFinding<NodalForcesSolid<D>, NodalDampingsSolid<D>, NodalVelocities<D>>, ) -> Result<(Times, NodalCoordinatesHistory<D>, NodalVelocitiesHistory<D>), IntegrationError>

impl<B, const D: usize> FirstOrderRoot<TensorVector<Quantity<Power>>, TensorVector<QuantitySparseVec<PowerPerTemperature>>, TensorVector<Quantity<Temperature>>> 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> FirstOrderRoot<TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank2SparseVec<D, Current, Current, ForcePerLength>>, TensorVector<TensorRank1<D, Current, Length>>> 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 G: usize, V, const D: usize> FirstOrderRootIV<G, V, D> for Model<B, D>

where B: ElasticIVElements<G, V, D>, V: Tensor,

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

impl<B, const D: usize> From<(B, TensorVector<TensorRank1<D, Reference, Length>>)> 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<Quantity<Energy>, 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, const G: usize, V, const D: usize> HyperelasticIVElements<G, V, D> for Model<B, D>

where B: HyperelasticIVElements<G, V, D>, V: Tensor,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<D>, internal_variables: &InternalVariablesField<G, V>, ) -> Result<Quantity<Energy>, ElementModelError>

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

where B: HyperelasticViscoplasticElements<S, D>, S: Differentiable,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<Quantity<Energy>, 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<Quantity<Energy>, ElementModelError>

impl<B, Y> RootRkmkDae<3, Y> for Model<B, 3>

where B: ElasticViscoplasticDaeElements<Y, 3> + ElasticViscoplasticElements<B::State, 3>, <B::Field as Integrable>::Point: Clone, <B::Field as Integrable>::Increment: Clone + Differentiable<Time>, for<'a> &'a Derivative<<B::Field as Integrable>::Increment, Time>: Mul<Quantity<Time>, Output = <B::Field as Integrable>::Increment>, Derivative<<B::Field as Integrable>::Increment, Time>: Mul<Quantity<Time>, Output = <B::Field as Integrable>::Increment>, B::State: Clone, B::History: TensorVec<Item = B::State>,

type History = <B as ElasticViscoplasticDaeElements<Y, 3>>::History

The model’s plastic-state history type.

fn root_rkmk_dae<Tab: ButcherTableau>( &self, solver: impl FirstOrderRootFinding<NodalForcesSolid<3>, NodalStiffnessesSolid<3>, NodalCoordinates<3>>, time: &[Quantity<Time>], bcs: ElasticViscoplasticBCs, ) -> Result<(Times, NodalCoordinatesHistory<3>, Self::History), IntegrationError>

Solve under an applied load, resolving nodal equilibrium at every RK stage of every load-step window while every Gauss point’s plastic state advances on its group.

fn root_rkmk_dae_adaptive<Tab: EmbeddedTableau>( &self, solver: impl FirstOrderRootFinding<NodalForcesSolid<3>, NodalStiffnessesSolid<3>, NodalCoordinates<3>>, time: &[Quantity<Time>], bcs: ElasticViscoplasticBCs, abs_tol: Scalar, rel_tol: Scalar, ) -> Result<(Times, NodalCoordinatesHistory<3>, Self::History), IntegrationError>

As Self::root_rkmk_dae, but the whole span is stepped under embedded (Tab::D) error control rather than on the supplied load grid.

impl<B, Y> RootRkmkDaeMinimize<3, Y> for Model<B, 3>

where B: ElasticViscoplasticDaeElements<Y, 3> + HyperelasticViscoplasticElements<B::State, 3>, <B::Field as Integrable>::Point: Clone, <B::Field as Integrable>::Increment: Clone + Differentiable<Time>, for<'a> &'a Derivative<<B::Field as Integrable>::Increment, Time>: Mul<Quantity<Time>, Output = <B::Field as Integrable>::Increment>, Derivative<<B::Field as Integrable>::Increment, Time>: Mul<Quantity<Time>, Output = <B::Field as Integrable>::Increment>, B::State: Clone, B::History: TensorVec<Item = B::State>,

type History = <B as ElasticViscoplasticDaeElements<Y, 3>>::History

The model’s plastic-state history type.

fn root_rkmk_dae_minimize<Tab: ButcherTableau>( &self, solver: impl SecondOrderOptimization<Quantity<Energy>, NodalForcesSolid<3>, NodalStiffnessesSolid<3>, NodalCoordinates<3>>, time: &[Quantity<Time>], bcs: ElasticViscoplasticBCs, ) -> Result<(Times, NodalCoordinatesHistory<3>, Self::History), IntegrationError>

Solve under an applied load, resolving nodal equilibrium by potential minimization at every RK stage of every load-step window while every Gauss point’s plastic state advances on its group.

fn root_rkmk_dae_adaptive_minimize<Tab: EmbeddedTableau>( &self, solver: impl SecondOrderOptimization<Quantity<Energy>, NodalForcesSolid<3>, NodalStiffnessesSolid<3>, NodalCoordinates<3>>, time: &[Quantity<Time>], bcs: ElasticViscoplasticBCs, abs_tol: Scalar, rel_tol: Scalar, ) -> Result<(Times, NodalCoordinatesHistory<3>, Self::History), IntegrationError>

As Self::root_rkmk_dae_minimize, but the whole span is stepped under embedded (Tab::D) error control rather than on the supplied load grid.

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

where B: ElasticHyperviscousElements<D>,

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

impl<B, const D: usize> SecondOrderMinimize<Quantity<Energy>, TensorVector<TensorRank1<D, Current, Force>>, TensorRank2SparseVec2DSymmetric<D, Current, Current, ForcePerLength>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: HyperelasticElements<D>,

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

impl<B, const D: usize> SecondOrderMinimize<Quantity<PowerTemperature>, TensorVector<Quantity<Power>>, TensorVector<QuantitySparseVec<PowerPerTemperature>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

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

impl<B, const G: usize, V, const D: usize> SecondOrderMinimizeIV<G, V, D> for Model<B, D>

where B: HyperelasticIVElements<G, V, D>, V: Tensor,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl SecondOrderOptimization<Quantity<Energy>, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>> + SecondOrderOptimizationIncremental<Quantity<Energy>, NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, strategy: SolveStrategy, ) -> Result<NodalCoordinates<D>, OptimizationError>

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

where B: ThermalConductionElements,

fn potential( &self, nodal_temperatures: &NodalTemperatures, ) -> Result<Quantity<PowerTemperature>, 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<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<const D: usize, B, M> TryFrom<(Mesh<D>, M)> for Model<B, D>

where B: FromConnectivities<D, M>,

type Error = String

The type returned in the event of a conversion error.

fn try_from( (mesh, constitutive_models): (Mesh<D>, M), ) -> 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 NodalDampingsSolid<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<NodalDampingsSolid<D>, ElementModelError>

impl<B, const D: usize> ZerothOrderRoot<TensorVector<Quantity<Power>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

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

impl<B, const D: usize> ZerothOrderRoot<TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: ElasticElements<D>,

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