Struct Block 

pub struct Block<C, F, const G: usize, const M: usize, const N: usize, const P: usize> { /* private fields */ }

Implementations

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> Block<C, F, G, M, N, P>

where F: FiniteElement<G, M, N, P>,

pub fn volume(&self) -> Quantity<Volume>

Trait Implementations

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> Debug for Block<C, F, G, M, N, P>

where F: FiniteElement<G, M, N, P>,

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

Formats the value using the given formatter.

impl<C, F, const G: usize, const N: usize, const P: usize> ElasticElements<2> for Block<C, F, G, 2, N, P>

where C: Elastic, F: PlanarElasticFiniteElement<C, G, N, P>,

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

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<2>, nodal_stiffnesses: &mut NodalStiffnessesSolid<2>, ) -> 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<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ElasticElements<3> for Block<C, F, G, M, N, P>

where C: Elastic, F: ElasticFiniteElement<C, G, M, N, P>,

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

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, nodal_stiffnesses: &mut NodalStiffnessesSolid<3>, ) -> 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<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ElasticHyperviscousElements<3> for Block<C, F, G, M, N, P>

where C: ElasticHyperviscous, F: ElasticHyperviscousFiniteElement<C, G, M, N, P>, Self: ViscoelasticElements<3>,

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

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

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, V, E> ElasticIVElements<G, V, 3> for Block<C, F, G, M, N, P>

where C: ElasticIV<V>, C::Residual: Erase<Erased = E>, F: ElasticIVFiniteElement<C, G, M, N, P, V, E>, E: Tensor, for<'a> &'a C::Residual: Div<C::TangentVv, Output = V>, for<'a> &'a V: Mul<Quantity<Dimensionless>, Output = V> + Mul<Scalar, Output = V>, for<'a> &'a Matrix: Mul<&'a V, Output = Vector>, V: Erase<Erased = E> + Jacobian + Solution, <V as Tensor>::Unit: UnitDiv<<V as Tensor>::Unit, Output = Dimensionless>,

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

The internal variables every integration point starts from.

fn internal_variables_increment( &self, nodal_coordinates: &NodalCoordinates<3>, internal_variables: &InternalVariablesField<G, V>, nodal_decrement: &NodalCoordinates<3>, 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<3>, internal_variables: &InternalVariablesField<G, V>, ) -> Result<InternalVariablesField<G, V>, ElementModelError>

Solves the internal variables everywhere, holding the deformation fixed.

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

fn nodal_forces_eliminated_into( &self, nodal_coordinates: &NodalCoordinates<3>, internal_variables: &InternalVariablesField<G, V>, nodal_forces: &mut NodalForcesSolid<3>, ) -> 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_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, internal_variables: &InternalVariablesField<G, V>, nodal_stiffnesses: &mut NodalStiffnessesSolid<3>, ) -> 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<C, F, const G: usize, const N: usize, const P: usize, Y> ElasticViscoplasticDaeElements<Y, 3> for Block<C, F, G, 3, N, P>

where F: SolidFiniteElement<G, 3, N, P> + ElasticViscoplasticFiniteElement<C, G, 3, N, P, Y>, Y: Clone + Differentiable<Time> + Tensor, C: ElasticViscoplastic<Y> + StateEvolution<Time, Y, Drive = DeformationGradient, Field: Integrable<Point = ViscoplasticStateVariables<Y>>>, EvolvedIncrement<C, Time, Y>: Clone + Differentiable<Time>, TensorVector<ViscoplasticStateVariables<Y>>: Tensor<Item = ViscoplasticStateVariables<Y>>, TensorVector<EvolvedIncrement<C, Time, Y>>: Tensor<Item = EvolvedIncrement<C, Time, Y>>, ViscoplasticStateVariables<G, Y>: Clone + Differentiable + Tensor, ViscoplasticStateVariablesHistory<G, Y>: TensorVec<Item = ViscoplasticStateVariables<G, Y>>,

type Field = List<<C as StateEvolution<Time, Y>>::Field>

The whole-mesh field this topology’s plastic state lives on.

type State = TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>

The per-element grouped state — a per-Gauss-point list for one block, a TensorTuple of those for Blocks.

type History = TensorVector<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>>

Time history of Self::State.

fn flatten( state: &ViscoplasticStateVariables<G, Y>, ) -> TensorVector<PointStateVariables<Y>>

Flattens Self::State into Self::Field’s Point.

fn unflatten( flat: &TensorVector<PointStateVariables<Y>>, ) -> ViscoplasticStateVariables<G, Y>

The inverse of Self::flatten.

fn dae_rate( &self, t: Quantity<Time>, nodal_coordinates: &NodalCoordinates<3>, flat: &TensorVector<PointStateVariables<Y>>, ) -> Result<TensorVector<Derivative<EvolvedIncrement<C, Time, Y>, Time>>, ElementModelError>

Evaluates every Gauss point’s plastic rate at nodal_coordinates.

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, Y> ElasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>, 3> for Block<C, F, G, M, N, P>

where C: ElasticViscoplastic<Y>, F: ElasticViscoplasticFiniteElement<C, G, M, N, P, Y>, Y: Differentiable + Tensor,

fn initial_state(&self) -> ViscoplasticStateVariables<G, Y>

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, nodal_forces: &mut NodalForcesSolid<3>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, nodal_stiffnesses: &mut NodalStiffnessesSolid<3>, ) -> Result<(), ElementModelError>

fn state_variables_evolution( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, ) -> Result<ViscoplasticEvolution<G, Y>, 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<C, F, const G: usize, const M: usize, const N: usize, const P: usize> Elements for Block<C, F, G, M, N, P>

where F: FiniteElement<G, M, N, P>,

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

impl<C, F, const G: usize, const N: usize, const P: usize> From<(C, PrimitiveConnectivity<2, N>, &TensorVector<TensorRank1<2, Reference, Length>>)> for Block<C, F, G, 2, N, P>

where F: FiniteElement<G, 2, N, P> + From<PlanarElementNodalReferenceCoordinates<N>>,

fn from( (constitutive_model, connectivity, coordinates): (C, PrimitiveConnectivity<2, N>, &NodalReferenceCoordinates<2>), ) -> Self

Converts to this type from the input type.

impl<C, F, const G: usize, const N: usize, const P: usize> From<(C, PrimitiveConnectivity<3, N>, &TensorVector<TensorRank1<3, Reference, Length>>)> for Block<C, F, G, 3, N, P>

where F: FiniteElement<G, 3, N, P> + From<ElementNodalReferenceCoordinates<N>>,

fn from( (constitutive_model, connectivity, coordinates): (C, PrimitiveConnectivity<3, N>, &NodalReferenceCoordinates<3>), ) -> Self

Converts to this type from the input type.

impl<C, F, const G: usize, const N: usize, const P: usize> From<(C, Vec<[usize; N]>, &TensorVector<TensorRank1<2, Reference, Length>>)> for Block<C, F, G, 2, N, P>

where F: FiniteElement<G, 2, N, P> + From<PlanarElementNodalReferenceCoordinates<N>>,

fn from( (constitutive_model, connectivity, coordinates): (C, Vec<[usize; N]>, &NodalReferenceCoordinates<2>), ) -> Self

Converts to this type from the input type.

impl<C, F, const G: usize, const N: usize, const P: usize> From<(C, Vec<[usize; N]>, &TensorVector<TensorRank1<3, Reference, Length>>)> for Block<C, F, G, 3, N, P>

where F: FiniteElement<G, 3, N, P> + From<ElementNodalReferenceCoordinates<N>>,

fn from( (constitutive_model, connectivity, coordinates): (C, Vec<[usize; N]>, &NodalReferenceCoordinates<3>), ) -> Self

Converts to this type from the input type.

impl<C, F, const G: usize, const N: usize, const P: usize> From<(C, Vec<[usize; N]>, &TensorVector<TensorRank1<3, Reference, Length>>, Quantity<Length>)> for Block<C, F, G, M, N, P>

where F: From<(ElementNodalReferenceCoordinates<N>, Quantity<Length>)>,

fn from( (constitutive_model, connectivity, coordinates, thickness): (C, Vec<[usize; N]>, &NodalReferenceCoordinates<3>, Quantity<Length>), ) -> Self

Converts to this type from the input type.

impl<C, F, const G: usize, const N: usize, const P: usize> HyperelasticElements<2> for Block<C, F, G, 2, N, P>

where C: Hyperelastic, F: PlanarHyperelasticFiniteElement<C, G, N, P>, Self: ElasticElements<2>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<2>, ) -> Result<Quantity<Energy>, ElementModelError>

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

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

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> HyperelasticElements<3> for Block<C, F, G, M, N, P>

where C: Hyperelastic, F: HyperelasticFiniteElement<C, G, M, N, P>, Self: ElasticElements<3>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<3>, ) -> Result<Quantity<Energy>, ElementModelError>

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

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

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, V, E> HyperelasticIVElements<G, V, 3> for Block<C, F, G, M, N, P>

where C: HyperelasticIV<V>, C::Residual: Erase<Erased = E>, F: HyperelasticIVFiniteElement<C, G, M, N, P, V, E>, Self: ElasticIVElements<G, V, 3>, E: Tensor, for<'a> &'a C::Residual: Div<C::TangentVv, Output = V>, for<'a> &'a V: Mul<Quantity<Dimensionless>, Output = V> + Mul<Scalar, Output = V>, for<'a> &'a Matrix: Mul<&'a V, Output = Vector>, V: Erase<Erased = E> + Jacobian + Solution, <V as Tensor>::Unit: UnitDiv<<V as Tensor>::Unit, Output = Dimensionless>,

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

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, Y> HyperelasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>, 3> for Block<C, F, G, M, N, P>

where C: HyperelasticViscoplastic<Y>, F: HyperelasticViscoplasticFiniteElement<C, G, M, N, P, Y>, Self: ElasticViscoplasticElements<ViscoplasticStateVariables<G, Y>, 3>, Y: Differentiable + Tensor,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, ) -> Result<Quantity<Energy>, ElementModelError>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> HyperviscoelasticElements<3> for Block<C, F, G, M, N, P>

where C: Hyperviscoelastic, F: HyperviscoelasticFiniteElement<C, G, M, N, P>, Self: ElasticHyperviscousElements<3>,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<3>, ) -> Result<Quantity<Energy>, ElementModelError>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> SolidElements for Block<C, F, G, M, N, P>

where C: Solid, F: SolidFiniteElement<G, M, N, P>,

type DeformationGradients = TensorList<TensorRank2<3, Current, Reference>, G>

type DeformationGradientRates = TensorList<TensorRank2<3, Current, Reference, Rate>, G>

fn deformation_gradients( &self, nodal_coordinates: &NodalCoordinates<3>, ) -> Vec<Self::DeformationGradients>

fn deformation_gradient_rates( &self, nodal_coordinates: &NodalCoordinates<3>, nodal_velocities: &NodalVelocities<3>, ) -> Vec<Self::DeformationGradientRates>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ThermalConductionElements for Block<C, F, G, M, N, P>

where C: ThermalConduction, F: ThermalConductionFiniteElement<C, G, M, N, P>,

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<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ThermalElements<C, F, G, M, N, P> for Block<C, F, G, M, N, P>

where C: Thermal, F: ThermalFiniteElement<G, M, N, P>,

fn nodal_temperatures_element( &self, element_connectivity: &[usize; N], nodal_temperatures: &NodalTemperatures, ) -> ElementNodalTemperatures<N>

fn temperature_gradients( &self, nodal_temperatures: &NodalTemperatures, ) -> Vec<TemperatureGradients<G>>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ViscoelasticElements<3> for Block<C, F, G, M, N, P>

where C: Viscoelastic, F: ViscoelasticFiniteElement<C, G, M, N, P>,

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

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, nodal_velocities: &NodalVelocities<3>, nodal_stiffnesses: &mut NodalDampingsSolid<3>, ) -> 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>