Implements a form of the central difference time integrator that calculates acceleration directly from the residual forces. More...

#include <ExplicitMixedOrder.h>

Inheritance diagram for ExplicitMixedOrder:

[legend]

Public Types
enum	TimeOrder { FIRST, SECOND }

typedef DataFileName	DataFileParameterType

Public Member Functions
	ExplicitMixedOrder (const InputParameters &parameters)

virtual int	order () override

virtual void	computeTimeDerivatives () override

virtual void	solve () override

virtual void	postResidual (NumericVector< Number > &residual) override

virtual bool	overridesSolve () const override

virtual void	postSolve () override

virtual bool	advancesProblemState () const override

virtual bool	performExplicitSolve (SparseMatrix< Number > &mass_matrix) override

void	computeADTimeDerivatives (ADReal &, const dof_id_type &, ADReal &) const override

virtual void	init () override

virtual void	meshChanged () override

TimeOrder	findVariableTimeOrder (unsigned int var_num) const
	Retrieve the order of the highest time derivative of a variable. More...

virtual void	initialSetup () override

virtual void	preSolve () override

virtual bool	isExplicit () const override

virtual void	preStep ()

virtual void	postStep ()

virtual unsigned int	getNumNonlinearIterations () const

virtual unsigned int	getNumLinearIterations () const

const Real &	dt () const

virtual unsigned int	numStatesRequired () const

virtual const bool &	isLumped () const

bool	integratesVar (const unsigned int var_num) const

void	setNumIterationsLastSolve ()

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	haveParameter (const std::string &name) const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

TagID	uDotFactorTag () const

TagID	uDotDotFactorTag () const

virtual Real	timeDerivativeRHSContribution (dof_id_type dof_id, const std::vector< Real > &factors={}) const

virtual Real	timeDerivativeMatrixContribution (const Real factor) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Types
enum	SolveType

Protected Member Functions
void	updateDOFIndices ()
	compile the dof indices for first and second order in time variables More...

virtual TagID	massMatrixTagID () const override

virtual void	evaluateRHSResidual ()
	Evaluate the RHS residual. More...

template<typename T , typename T2 , typename T3 , typename T4 >
void	computeTimeDerivativeHelper (T &u_dot, T2 &u_dotdot, const T3 &u_old, const T4 &u_older) const
	Helper function that actually does the math for computing the time derivative. More...

void	computeICs ()

void	setupSolver ()

bool	solveLinearSystem (SparseMatrix< Number > &mass_matrix)

bool	checkLinearConvergence ()

unsigned int	getNumNonlinearIterationsLastSolve () const

unsigned int	getNumLinearIterationsLastSolve () const

void	copyVector (const NumericVector< Number > &from, NumericVector< Number > &to)

virtual Real	duDotDuCoeff () const

void	computeDuDotDu ()

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

NumericVector< Number > *	addVector (const std::string &name, const bool project, const libMesh::ParallelType type)

Protected Attributes
const bool &	_constant_mass
	Whether we are reusing the mass matrix. More...

const bool &	_recompute_mass_matrix_on_mesh_change
	Must be set to true to use adaptivity with a constant mass matrix. More...

bool	_mesh_changed
	Whether the mesh changed just before the current solve. More...

const TagName &	_mass_matrix_name
	Mass matrix name. More...

NumericVector< Real > *	_mass_matrix_lumped
	Lumped mass matrix. More...

const NumericVector< Number > &	_solution_older
	The older solution. More...

std::unordered_set< unsigned int > &	_vars_first

std::vector< dof_id_type > &	_local_first_order_indices

std::unordered_set< unsigned int > &	_vars_second

std::vector< dof_id_type > &	_local_second_order_indices

	CONSISTENT

	LUMPED

	LUMP_PRECONDITIONED

MooseEnum	_solve_type

NumericVector< Real > *	_explicit_residual

NumericVector< Real > *	_solution_update

NumericVector< Real > *	_mass_matrix_diag_inverted

NumericVector< Real > *	_ones

TagID	_Ke_time_tag

std::unique_ptr< libMesh::LinearSolver< Number > >	_linear_solver

std::unique_ptr< LumpedPreconditioner >	_preconditioner

Real	_current_time

FEProblemBase &	_fe_problem

SystemBase &	_sys

std::vector< Real > &	_du_dot_du

int &	_t_step

Real &	_dt

Real &	_dt_old

unsigned int	_n_nonlinear_iterations

unsigned int	_n_linear_iterations

bool	_is_lumped

bool &	_var_restriction

std::vector< dof_id_type > &	_local_indices

std::unordered_set< unsigned int > &	_vars

std::unique_ptr< NumericVector< Number > >	_from_subvector

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

NonlinearSystemBase *	_nl

libMesh::NonlinearImplicitSystem *	_nonlinear_implicit_system

NumericVector< Number > *	_Re_time

NumericVector< Number > *	_Re_non_time

const TagID	_u_dot_factor_tag

const TagID	_u_dotdot_factor_tag

LinearSystem *	_linear_system

libMesh::LinearImplicitSystem *	_linear_implicit_system

FEProblemBase &	_mci_feproblem

const NumericVector< Number > *const &	_solution

const NumericVector< Number > &	_solution_old

std::unique_ptr< NumericVector< Number > > &	_solution_sub

std::unique_ptr< NumericVector< Number > > &	_solution_old_sub

const Parallel::Communicator &	_communicator

Detailed Description

Implements a form of the central difference time integrator that calculates acceleration directly from the residual forces.

Definition at line 25 of file ExplicitMixedOrder.h.

Member Enumeration Documentation

◆ TimeOrder

enum ExplicitMixedOrder::TimeOrder

Enumerator
FIRST
SECOND

Definition at line 56 of file ExplicitMixedOrder.h.

   {
     FIRST,
     SECOND
   };

Constructor & Destructor Documentation

◆ ExplicitMixedOrder()

ExplicitMixedOrder::ExplicitMixedOrder ( const InputParameters & parameters )

Definition at line 83 of file ExplicitMixedOrder.C.

   : ExplicitTimeIntegrator(parameters),
     _constant_mass(getParam<bool>("use_constant_mass")),
     _recompute_mass_matrix_on_mesh_change(
         getParam<bool>("recompute_mass_matrix_after_mesh_change")),
     _mesh_changed(true),
     _mass_matrix_name(getParam<TagName>("mass_matrix_tag")),
     _mass_matrix_lumped(addVector("mass_matrix_lumped", true, GHOSTED)),
     _solution_older(_sys.solutionState(2)),
     _vars_first(declareRestartableData<std::unordered_set<unsigned int>>("first_order_vars")),
     _local_first_order_indices(
         declareRestartableData<std::vector<dof_id_type>>("first_local_indices")),
     _vars_second(declareRestartableData<std::unordered_set<unsigned int>>("second_order_vars")),
     _local_second_order_indices(
         declareRestartableData<std::vector<dof_id_type>>("second_local_indices"))
 {
   _fe_problem.setUDotRequested(true);
   _fe_problem.setUDotOldRequested(true);
   _fe_problem.setUDotDotRequested(true);
 }

Member Function Documentation

◆ advancesProblemState()

virtual bool ExplicitMixedOrder::advancesProblemState ( ) const

inlineoverridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 44 of file ExplicitMixedOrder.h.

44 { return true; }

◆ computeADTimeDerivatives()

void ExplicitMixedOrder::computeADTimeDerivatives	(	ADReal &	,
		const dof_id_type &	,
		ADReal &
	)		const

inlineoverridevirtual

Implements ExplicitTimeIntegrator.

Definition at line 48 of file ExplicitMixedOrder.h.

   {
     mooseError("NOT SUPPORTED");
   }

◆ computeICs()

void ExplicitMixedOrder::computeICs ( )

protected

Definition at line 363 of file ExplicitMixedOrder.C.

Referenced by init().

 {
   // Compute the first-order approximation of the velocity at the current time step
   // using the Euler scheme, where the velocity is estimated as the difference
   // between the current solution and the previous time step, divided by the time
   auto vel = _sys.solutionUDot();
   *vel = *_solution;
   *vel -= _solution_old;
   *vel /= _dt;
   vel->close();
 }

◆ computeTimeDerivativeHelper()

template<typename T , typename T2 , typename T3 , typename T4 >

void ExplicitMixedOrder::computeTimeDerivativeHelper	(	T &	u_dot,
		T2 &	u_dotdot,
		const T3 &	u_old,
		const T4 &	u_older
	)		const

protected

Helper function that actually does the math for computing the time derivative.

Definition at line 124 of file ExplicitMixedOrder.h.

 {
   // computing first derivative
   // using the Central Difference method
   // u_dot_old = (first_term - second_term) / 2 / dt
   //       first_term = u
   //      second_term = u_older
   u_dot -= u_older; // 'older than older' solution
   u_dot *= 1.0 / (2.0 * _dt);
 
   // computing second derivative
   // using the Central Difference method
   // u_dotdot_old = (first_term - second_term + third_term) / dt / dt
   //       first_term = u
   //      second_term = 2 * u_old
   //       third_term = u_older
   u_dotdot -= u_old;
   u_dotdot -= u_old;
   u_dotdot += u_older;
   u_dotdot *= 1.0 / (_dt * _dt);
 }

◆ computeTimeDerivatives()

void ExplicitMixedOrder::computeTimeDerivatives ( )

overridevirtual

Implements ExplicitTimeIntegrator.

Definition at line 105 of file ExplicitMixedOrder.C.

 {
   /*
   Because this is called in NonLinearSystemBase
   this should not actually compute the time derivatives.
   Calculating time derivatives here will cause issues for the
   solution update.
   */
   return;
 }

◆ evaluateRHSResidual()

void ExplicitMixedOrder::evaluateRHSResidual ( )

protectedvirtual

Evaluate the RHS residual.

Reimplemented in NEML2CentralDifference.

Definition at line 195 of file ExplicitMixedOrder.C.

Referenced by NEML2CentralDifference::evaluateRHSResidual(), and solve().

 {
   // Compute the residual
   _fe_problem.computeResidual(
       *_nonlinear_implicit_system->current_local_solution, *_explicit_residual, _nl->number());
 
   // Move the residual to the RHS
   *_explicit_residual *= -1.0;
 }

◆ findVariableTimeOrder()

ExplicitMixedOrder::TimeOrder ExplicitMixedOrder::findVariableTimeOrder ( unsigned int var_num ) const

Retrieve the order of the highest time derivative of a variable.

Returns: Returns the time order enum of this variable.

Definition at line 376 of file ExplicitMixedOrder.C.

Referenced by ExplicitDirichletBCBase::timestepSetup().

 {
   if (_vars_first.empty() && _vars_second.empty())
     mooseError("Time order sets are both empty.");
   if (_vars_first.count(var_num))
     return FIRST;
   else if (_vars_second.count(var_num))
     return SECOND;
   else
     mooseError("Variable " + _sys.system().variable_name(var_num) +
                " does not exist in time order sets.");
 }

◆ init()

void ExplicitMixedOrder::init ( )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 290 of file ExplicitMixedOrder.C.

 {
   ExplicitTimeIntegrator::init();
 
   // Compute ICs for velocity
   computeICs();
 
   // Seperate variables into first and second time integration order and find
   // the local indices for each
   const auto & var_names_first = getParam<std::vector<VariableName>>("first_order_vars");
   const auto & var_names_second = getParam<std::vector<VariableName>>("second_order_vars");
   std::vector<unsigned int> var_num_vec;
 
   auto & lm_sys = _sys.system();
   lm_sys.get_all_variable_numbers(var_num_vec);
   std::unordered_set<unsigned int> var_nums(var_num_vec.begin(), var_num_vec.end());
 
   for (const auto & var_name : var_names_first)
     if (lm_sys.has_variable(var_name))
     {
       const auto var_num = lm_sys.variable_number(var_name);
       _vars_first.insert(var_num);
       var_nums.erase(var_num);
     }
 
   for (const auto & var_name : var_names_second)
     if (lm_sys.has_variable(var_name))
     {
       const auto var_num = lm_sys.variable_number(var_name);
       _vars_second.insert(var_num);
       var_nums.erase(var_num);
     }
 
   // If var_nums is empty then that means the user has specified all the variables in this system
   if (!var_nums.empty())
     mooseError("Not all nonlinear variables have their order specified.");
 }

◆ massMatrixTagID()

TagID ExplicitMixedOrder::massMatrixTagID ( ) const

overrideprotectedvirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 132 of file ExplicitMixedOrder.C.

Referenced by solve().

 {
   return _sys.subproblem().getMatrixTagID(_mass_matrix_name);
 }

◆ meshChanged()

void ExplicitMixedOrder::meshChanged ( )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Reimplemented in NEML2CentralDifference.

Definition at line 117 of file ExplicitMixedOrder.C.

Referenced by NEML2CentralDifference::meshChanged().

 {
   if (_constant_mass && !_recompute_mass_matrix_on_mesh_change)
     paramError("recompute_mass_matrix_after_mesh_change",
                "Must be set to true explicitly by the user to support adaptivity with "
                "`use_constant_mass`.");
 
   // after mesh changes we need to recompute the mass matrix, it is not interpolable as it contains
   // a volume integrated quantity!
   _mesh_changed = true;
 
   ExplicitTimeIntegrator::meshChanged();
 }

◆ order()

virtual int ExplicitMixedOrder::order ( )

inlineoverridevirtual

Implements ExplicitTimeIntegrator.

Definition at line 32 of file ExplicitMixedOrder.h.

32 { return 1; }

◆ overridesSolve()

virtual bool ExplicitMixedOrder::overridesSolve ( ) const

inlineoverridevirtual

Implements ExplicitTimeIntegrator.

Definition at line 37 of file ExplicitMixedOrder.h.

37 { return true; }

◆ performExplicitSolve()

bool ExplicitMixedOrder::performExplicitSolve ( SparseMatrix< Number > & mass_matrix )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 217 of file ExplicitMixedOrder.C.

Referenced by solve().

 {
   bool converged = false;
 
   // Grab all the vectors that we will need
   auto accel = _sys.solutionUDotDot();
   auto vel = _sys.solutionUDot();
 
   // Compute Forward Euler
   // Split diag mass and residual vectors into correct subvectors
   const std::unique_ptr<NumericVector<Number>> mass_inv_first(
       NumericVector<Number>::build(_communicator, libMesh::default_solver_package(), PARALLEL));
   const std::unique_ptr<NumericVector<Real>> exp_res_first(
       NumericVector<Number>::build(_communicator, libMesh::default_solver_package(), PARALLEL));
   _mass_matrix_diag_inverted->create_subvector(*mass_inv_first, _local_first_order_indices, false);
   _explicit_residual->create_subvector(*exp_res_first, _local_first_order_indices, false);
 
   // Need velocity vector split into subvectors
   auto vel_first = vel->get_subvector(_local_first_order_indices);
 
   // Velocity update for foward euler
   vel_first->pointwise_mult(*mass_inv_first, *exp_res_first);
 
   // Restore the velocities
   vel->restore_subvector(std::move(vel_first), _local_first_order_indices);
 
   // Compute Central Difference
   // Split diag mass and residual vectors into correct subvectors
   const std::unique_ptr<NumericVector<Real>> mass_inv_second(
       NumericVector<Number>::build(_communicator, libMesh::default_solver_package(), PARALLEL));
   const std::unique_ptr<NumericVector<Real>> exp_res_second(
       NumericVector<Number>::build(_communicator, libMesh::default_solver_package(), PARALLEL));
   _mass_matrix_diag_inverted->create_subvector(
       *mass_inv_second, _local_second_order_indices, false);
   _explicit_residual->create_subvector(*exp_res_second, _local_second_order_indices, false);
 
   // Only need acceleration and old velocity vector for central difference
   auto accel_second = accel->get_subvector(_local_second_order_indices);
 
   auto vel_second = vel->get_subvector(_local_second_order_indices);
 
   // Compute acceleration for central difference
   accel_second->pointwise_mult(*mass_inv_second, *exp_res_second);
 
   // Scaling the acceleration
   auto accel_scaled = accel_second->clone();
   accel_scaled->scale((_dt + _dt_old) / 2);
 
   // Velocity update for central difference
   *vel_second += *accel_scaled;
 
   // Restore acceleration
   accel->restore_subvector(std::move(accel_second), _local_second_order_indices);
 
   vel->restore_subvector(std::move(vel_second), _local_second_order_indices);
 
   // Same solution update for both methods
   *_solution_update = *vel;
   _solution_update->scale(_dt);
 
   // Check for convergence by seeing if there is a nan or inf
   auto sum = _solution_update->sum();
   converged = std::isfinite(sum);
 
   // The linear iteration count remains zero
   _n_linear_iterations = 0;
   vel->close();
   accel->close();
 
   return converged;
 }

◆ postResidual()

void ExplicitMixedOrder::postResidual ( NumericVector< Number > & residual )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 206 of file ExplicitMixedOrder.C.

 {
   residual += *_Re_time;
   residual += *_Re_non_time;
   residual.close();
 
   // Reset time to the time at which to evaluate nodal BCs, which comes next
   _fe_problem.time() = _current_time;
 }

◆ postSolve()

virtual void ExplicitMixedOrder::postSolve ( )

inlineoverridevirtual

Reimplemented from ExplicitTimeIntegrator.

Reimplemented in NEML2CentralDifference.

Definition at line 39 of file ExplicitMixedOrder.h.

Referenced by NEML2CentralDifference::postSolve().

   { // Once we have the new solution, we want to adanceState to make sure the
     // coupling between the solution and the computed material properties is kept correctly.
     _fe_problem.advanceState();
   }

◆ solve()

void ExplicitMixedOrder::solve ( )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 138 of file ExplicitMixedOrder.C.

 {
   // Getting the tagID for the mass matrix
   auto mass_tag = massMatrixTagID();
 
   // Reset iteration counts
   _n_nonlinear_iterations = 0;
   _n_linear_iterations = 0;
 
   _current_time = _fe_problem.time();
 
   auto & mass_matrix = _nonlinear_implicit_system->get_system_matrix();
 
   if (_mesh_changed)
     updateDOFIndices();
 
   // Compute the mass matrix
   if (_mesh_changed || !_constant_mass)
   {
     // We only want to compute "inverted" lumped mass matrix once.
     _fe_problem.computeJacobianTag(
         *_nonlinear_implicit_system->current_local_solution, mass_matrix, mass_tag);
 
     // Calculate and record the lumped mass matrix for use in residual calculation
     mass_matrix.vector_mult(*_mass_matrix_lumped, *_ones);
     _mass_matrix_lumped->close();
 
     // "Invert" the diagonal mass matrix
     *_mass_matrix_diag_inverted = *_mass_matrix_lumped;
     _mass_matrix_diag_inverted->reciprocal();
     _mass_matrix_diag_inverted->close();
   }
 
   _mesh_changed = false;
 
   // Set time to the time at which to evaluate the residual
   _fe_problem.time() = _fe_problem.timeOld();
   _nonlinear_implicit_system->update();
 
   // Evaluate residual and move it to the RHS
   evaluateRHSResidual();
 
   // Perform the linear solve
   bool converged = performExplicitSolve(mass_matrix);
   _nl->overwriteNodeFace(*_nonlinear_implicit_system->solution);
 
   // Update the solution
   *_nonlinear_implicit_system->solution = _nl->solutionOld();
   *_nonlinear_implicit_system->solution += *_solution_update;
 
   _nonlinear_implicit_system->update();
 
   _nl->setSolution(*_nonlinear_implicit_system->current_local_solution);
   _nonlinear_implicit_system->nonlinear_solver->converged = converged;
 }

◆ updateDOFIndices()

void ExplicitMixedOrder::updateDOFIndices ( )

protected

compile the dof indices for first and second order in time variables

Definition at line 329 of file ExplicitMixedOrder.C.

Referenced by solve().

 {
   auto & lm_sys = _sys.system();
 
   std::vector<dof_id_type> var_dof_indices, work_vec;
   for (const auto var_num : _vars_first)
   {
     work_vec = _local_first_order_indices;
     _local_first_order_indices.clear();
     lm_sys.get_dof_map().local_variable_indices(var_dof_indices, lm_sys.get_mesh(), var_num);
     std::merge(work_vec.begin(),
                work_vec.end(),
                var_dof_indices.begin(),
                var_dof_indices.end(),
                std::back_inserter(_local_first_order_indices));
   }
 
   work_vec.clear();
   var_dof_indices.clear();
 
   for (const auto var_num : _vars_second)
   {
     work_vec = _local_second_order_indices;
     _local_second_order_indices.clear();
     lm_sys.get_dof_map().local_variable_indices(var_dof_indices, lm_sys.get_mesh(), var_num);
     std::merge(work_vec.begin(),
                work_vec.end(),
                var_dof_indices.begin(),
                var_dof_indices.end(),
                std::back_inserter(_local_second_order_indices));
   }
 }

◆ validParams()

InputParameters ExplicitMixedOrder::validParams ( )

static

Definition at line 41 of file ExplicitMixedOrder.C.

Referenced by NEML2CentralDifference::validParams().

 {
   InputParameters params = ExplicitTimeIntegrator::validParams();
 
   params.addClassDescription(
       "Implementation of explicit time integration without invoking any of the nonlinear solver.");
 
   params.addParam<bool>("use_constant_mass",
                         false,
                         "If set to true, will only compute the mass matrix in the first time step, "
                         "and keep using it throughout the simulation.");
 
   params.addParam<bool>(
       "recompute_mass_matrix_after_mesh_change",
       false,
       "If set to true, the mass matrix will be recomputed when the mesh changes (e.g. through "
       "adaptivity). If use_constant_mass is set to true, adadaptivity is used, and this parameter "
       "is not set to true, the simulation will error out when the mesh changes.");
 
   params.addParam<TagName>("mass_matrix_tag", "mass", "The tag for the mass matrix");
 
   params.addParam<std::vector<VariableName>>(
       "second_order_vars",
       {},
       "A subset of variables that require second-order integration (velocity and acceleration) to "
       "be applied by this time integrator.");
 
   params.addParam<std::vector<VariableName>>(
       "first_order_vars",
       {},
       "A subset of variables that require first-order integration (velocity only) to be applied by "
       "this time integrator.");
 
   // Prevent users from using variables option by accident.
   params.suppressParameter<std::vector<VariableName>>("variables");
 
   MooseEnum solve_type("consistent lumped lump_preconditioned", "lumped");
   params.setParameters("solve_type", solve_type);
   params.ignoreParameter<MooseEnum>("solve_type");
   return params;
 }

Member Data Documentation

◆ _constant_mass

const bool& ExplicitMixedOrder::_constant_mass

protected

Whether we are reusing the mass matrix.

Definition at line 78 of file ExplicitMixedOrder.h.

Referenced by meshChanged(), and solve().

◆ _local_first_order_indices

std::vector<dof_id_type>& ExplicitMixedOrder::_local_first_order_indices

protected

Definition at line 104 of file ExplicitMixedOrder.h.

Referenced by performExplicitSolve(), and updateDOFIndices().

◆ _local_second_order_indices

std::vector<dof_id_type>& ExplicitMixedOrder::_local_second_order_indices

protected

Definition at line 110 of file ExplicitMixedOrder.h.

Referenced by performExplicitSolve(), and updateDOFIndices().

◆ _mass_matrix_lumped

NumericVector<Real>* ExplicitMixedOrder::_mass_matrix_lumped

protected

Lumped mass matrix.

Definition at line 95 of file ExplicitMixedOrder.h.

Referenced by solve().

◆ _mass_matrix_name

const TagName& ExplicitMixedOrder::_mass_matrix_name

protected

Mass matrix name.

Definition at line 92 of file ExplicitMixedOrder.h.

Referenced by massMatrixTagID().

◆ _mesh_changed

bool ExplicitMixedOrder::_mesh_changed

protected

Whether the mesh changed just before the current solve.

Definition at line 89 of file ExplicitMixedOrder.h.

Referenced by meshChanged(), and solve().

◆ _recompute_mass_matrix_on_mesh_change

const bool& ExplicitMixedOrder::_recompute_mass_matrix_on_mesh_change

protected

Must be set to true to use adaptivity with a constant mass matrix.

This will recompute the mass matrix when the mesh changes. The user must make sure that the underlying material density stays constant, otherwise simulation results will depend on adaptivity.

Definition at line 86 of file ExplicitMixedOrder.h.

Referenced by meshChanged().

◆ _solution_older

const NumericVector<Number>& ExplicitMixedOrder::_solution_older

protected

The older solution.

Definition at line 98 of file ExplicitMixedOrder.h.

◆ _vars_first

std::unordered_set<unsigned int>& ExplicitMixedOrder::_vars_first

protected

Definition at line 101 of file ExplicitMixedOrder.h.

Referenced by findVariableTimeOrder(), init(), and updateDOFIndices().

◆ _vars_second

std::unordered_set<unsigned int>& ExplicitMixedOrder::_vars_second

protected

Definition at line 107 of file ExplicitMixedOrder.h.

Referenced by findVariableTimeOrder(), init(), and updateDOFIndices().

The documentation for this class was generated from the following files:

solid_mechanics/include/timeintegrators/ExplicitMixedOrder.h
solid_mechanics/src/timeintegrators/ExplicitMixedOrder.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ TimeOrder

Constructor & Destructor Documentation

◆ ExplicitMixedOrder()

Member Function Documentation

◆ advancesProblemState()

◆ computeADTimeDerivatives()

◆ computeICs()

◆ computeTimeDerivativeHelper()

◆ computeTimeDerivatives()

◆ evaluateRHSResidual()

◆ findVariableTimeOrder()

◆ init()

◆ massMatrixTagID()

◆ meshChanged()

◆ order()

◆ overridesSolve()

◆ performExplicitSolve()

◆ postResidual()

◆ postSolve()

◆ solve()

◆ updateDOFIndices()

◆ validParams()

Member Data Documentation

◆ _constant_mass

◆ _local_first_order_indices

◆ _local_second_order_indices

◆ _mass_matrix_lumped

◆ _mass_matrix_name

◆ _mesh_changed

◆ _recompute_mass_matrix_on_mesh_change

◆ _solution_older

◆ _vars_first

◆ _vars_second