#include <NEML2CentralDifference.h>

Inheritance diagram for NEML2CentralDifference:

Public Types
enum	TimeOrder { FIRST, SECOND }

typedef DataFileName	DataFileParameterType

Public Member Functions
	NEML2CentralDifference (const InputParameters &parameters)

void	initialSetup () override

void	meshChanged () override

void	postSolve () override

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 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

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

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	evaluateRHSResidual () override
	Evaluate the RHS residual. More...

void	rebuildBoundaryElementList ()

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

virtual TagID	massMatrixTagID () const override

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
NEML2Assembly *	_neml2_assembly = nullptr
	The assembly object with cached assembly information. More...

NEML2FEInterpolation *	_fe = nullptr
	The FE interface for getting variable values/gradients interpolated onto the finite element space. More...

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

Private Attributes
std::vector< const Elem * >	_boundary_elems = {}
	Empty element vector to help zero out the algebraic range. More...

std::vector< const Node * >	_no_node = {}
	Empty node vector to help zero out the algebraic range. More...

bool	_boundary_elems_dirty = true
	Whether the cached boundary element list needs rebuilding. More...

Detailed Description

Definition at line 18 of file NEML2CentralDifference.h.

Member Enumeration Documentation

◆ TimeOrder

enum ExplicitMixedOrder::TimeOrder

inherited

Enumerator
FIRST
SECOND

Definition at line 56 of file ExplicitMixedOrder.h.

   {
     FIRST,
     SECOND
   };

Constructor & Destructor Documentation

◆ NEML2CentralDifference()

NEML2CentralDifference::NEML2CentralDifference ( const InputParameters & parameters )

Definition at line 33 of file NEML2CentralDifference.C.

   : ExplicitMixedOrder(parameters)
 {
 }

Member Function Documentation

◆ advancesProblemState()

virtual bool ExplicitMixedOrder::advancesProblemState ( ) const

inlineoverridevirtualinherited

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

inlineoverridevirtualinherited

Implements ExplicitTimeIntegrator.

Definition at line 48 of file ExplicitMixedOrder.h.

   {
     mooseError("NOT SUPPORTED");
   }

◆ computeICs()

void ExplicitMixedOrder::computeICs ( )

protectedinherited

Definition at line 363 of file ExplicitMixedOrder.C.

Referenced by ExplicitMixedOrder::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

protectedinherited

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 ( )

overridevirtualinherited

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 NEML2CentralDifference::evaluateRHSResidual ( )

overrideprotectedvirtual

Evaluate the RHS residual.

Reimplemented from ExplicitMixedOrder.

Definition at line 94 of file NEML2CentralDifference.C.

 {
   if (_boundary_elems_dirty)
     rebuildBoundaryElementList();
 
   if (_fe->contextUpToDate() && _neml2_assembly->upToDate())
   {
     libMesh::ConstElemRange boundary_elem_range(&_boundary_elems);
     _fe_problem.setCurrentAlgebraicElementRange(&boundary_elem_range);
 
     libMesh::ConstNodeRange null_node_range(&_no_node);
     _fe_problem.setCurrentAlgebraicNodeRange(&null_node_range);
   }
 
   ExplicitMixedOrder::evaluateRHSResidual();
 
   // Reset the algebraic ranges
   _fe_problem.setCurrentAlgebraicElementRange(nullptr);
   _fe_problem.setCurrentAlgebraicNodeRange(nullptr);
 }

◆ findVariableTimeOrder()

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

inherited

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 ( )

overridevirtualinherited

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.");
 }

◆ initialSetup()

void NEML2CentralDifference::initialSetup ( )

overridevirtual

Reimplemented from ExplicitTimeIntegrator.

Definition at line 71 of file NEML2CentralDifference.C.

 {
   ExplicitMixedOrder::initialSetup();
   _neml2_assembly = &_fe_problem.getUserObject<NEML2Assembly>("assembly", /*tid=*/0);
   _fe = &_fe_problem.getUserObject<NEML2FEInterpolation>("fe", /*tid=*/0);
   rebuildBoundaryElementList();
 }

◆ massMatrixTagID()

TagID ExplicitMixedOrder::massMatrixTagID ( ) const

overrideprotectedvirtualinherited

Reimplemented from ExplicitTimeIntegrator.

Definition at line 132 of file ExplicitMixedOrder.C.

Referenced by ExplicitMixedOrder::solve().

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

◆ meshChanged()

void NEML2CentralDifference::meshChanged ( )

overridevirtual

Reimplemented from ExplicitMixedOrder.

Definition at line 80 of file NEML2CentralDifference.C.

 {
   ExplicitMixedOrder::meshChanged();
   _boundary_elems_dirty = true;
 }

◆ order()

virtual int ExplicitMixedOrder::order ( )

inlineoverridevirtualinherited

Implements ExplicitTimeIntegrator.

Definition at line 32 of file ExplicitMixedOrder.h.

32 { return 1; }

◆ overridesSolve()

virtual bool ExplicitMixedOrder::overridesSolve ( ) const

inlineoverridevirtualinherited

Implements ExplicitTimeIntegrator.

Definition at line 37 of file ExplicitMixedOrder.h.

37 { return true; }

◆ performExplicitSolve()

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

overridevirtualinherited

Reimplemented from ExplicitTimeIntegrator.

Definition at line 217 of file ExplicitMixedOrder.C.

Referenced by ExplicitMixedOrder::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 )

overridevirtualinherited

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()

void NEML2CentralDifference::postSolve ( )

overridevirtual

Reimplemented from ExplicitMixedOrder.

Definition at line 87 of file NEML2CentralDifference.C.

 {
   ExplicitMixedOrder::postSolve();
   _fe->invalidateInterpolations();
 }

◆ rebuildBoundaryElementList()

void NEML2CentralDifference::rebuildBoundaryElementList ( )

protected

Definition at line 39 of file NEML2CentralDifference.C.

Referenced by evaluateRHSResidual(), and initialSetup().

 {
   if (!_nl)
     return;
 
   _boundary_elems.clear();
 
   // build boundary element list by iterating over all integrated BCs
   const auto & ibcs = _nl->getIntegratedBCWarehouse();
   std::unordered_set<BoundaryID> bnds;
   for (const auto & ibc : ibcs.getObjects())
     bnds.insert(ibc->boundaryIDs().begin(), ibc->boundaryIDs().end());
 
   if (!bnds.empty())
   {
     mooseInfo("Dectected BCs on ", bnds.size(), " boundaries.");
 
     // deduplicate elements that have multiple boundaries
     std::unordered_set<const Elem *> unique_elems;
     const auto end = _fe_problem.mesh().bndElemsEnd();
     for (auto it = _fe_problem.mesh().bndElemsBegin(); it != end; ++it)
       if (bnds.find((*it)->_bnd_id) != bnds.end())
         unique_elems.insert((*it)->_elem);
 
     _boundary_elems.assign(unique_elems.begin(), unique_elems.end());
     mooseInfo("Adding ", _boundary_elems.size(), " elements to the algebraic range.");
   }
 
   _boundary_elems_dirty = false;
 }

◆ solve()

void ExplicitMixedOrder::solve ( )

overridevirtualinherited

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 ( )

protectedinherited

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

Definition at line 329 of file ExplicitMixedOrder.C.

Referenced by ExplicitMixedOrder::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 NEML2CentralDifference::validParams ( )

static

Definition at line 21 of file NEML2CentralDifference.C.

 {
   InputParameters params = ExplicitMixedOrder::validParams();
   params.addClassDescription(
       "Central difference time integrator using NEML2 material models and kernels.");
   params.addRequiredParam<UserObjectName>(
       "assembly", "The NEML2Assembly object to use to provide assembly information");
   params.addRequiredParam<UserObjectName>(
       "fe", "The NEML2FEInterpolation object to use to couple variables");
   return params;
 }

Member Data Documentation

◆ _boundary_elems

std::vector<const Elem *> NEML2CentralDifference::_boundary_elems = {}

private

Empty element vector to help zero out the algebraic range.

Definition at line 41 of file NEML2CentralDifference.h.

Referenced by evaluateRHSResidual(), and rebuildBoundaryElementList().

◆ _boundary_elems_dirty

bool NEML2CentralDifference::_boundary_elems_dirty = true

private

Whether the cached boundary element list needs rebuilding.

Definition at line 47 of file NEML2CentralDifference.h.

Referenced by evaluateRHSResidual(), meshChanged(), and rebuildBoundaryElementList().

◆ _constant_mass

const bool& ExplicitMixedOrder::_constant_mass

protectedinherited

Whether we are reusing the mass matrix.

Definition at line 78 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::meshChanged(), and ExplicitMixedOrder::solve().

◆ _fe

NEML2FEInterpolation* NEML2CentralDifference::_fe = nullptr

protected

The FE interface for getting variable values/gradients interpolated onto the finite element space.

Definition at line 37 of file NEML2CentralDifference.h.

Referenced by evaluateRHSResidual(), initialSetup(), and postSolve().

◆ _local_first_order_indices

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

protectedinherited

Definition at line 104 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::performExplicitSolve(), and ExplicitMixedOrder::updateDOFIndices().

◆ _local_second_order_indices

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

protectedinherited

Definition at line 110 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::performExplicitSolve(), and ExplicitMixedOrder::updateDOFIndices().

◆ _mass_matrix_lumped

NumericVector<Real>* ExplicitMixedOrder::_mass_matrix_lumped

protectedinherited

Lumped mass matrix.

Definition at line 95 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::solve().

◆ _mass_matrix_name

const TagName& ExplicitMixedOrder::_mass_matrix_name

protectedinherited

Mass matrix name.

Definition at line 92 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::massMatrixTagID().

◆ _mesh_changed

bool ExplicitMixedOrder::_mesh_changed

protectedinherited

Whether the mesh changed just before the current solve.

Definition at line 89 of file ExplicitMixedOrder.h.

Referenced by ExplicitMixedOrder::meshChanged(), and ExplicitMixedOrder::solve().

◆ _neml2_assembly

NEML2Assembly* NEML2CentralDifference::_neml2_assembly = nullptr

protected

The assembly object with cached assembly information.

Definition at line 34 of file NEML2CentralDifference.h.

Referenced by evaluateRHSResidual(), and initialSetup().

◆ _no_node

std::vector<const Node *> NEML2CentralDifference::_no_node = {}

private

Empty node vector to help zero out the algebraic range.

Definition at line 44 of file NEML2CentralDifference.h.

Referenced by evaluateRHSResidual().

◆ _recompute_mass_matrix_on_mesh_change

const bool& ExplicitMixedOrder::_recompute_mass_matrix_on_mesh_change

protectedinherited

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 ExplicitMixedOrder::meshChanged().

◆ _solution_older

const NumericVector<Number>& ExplicitMixedOrder::_solution_older

protectedinherited

The older solution.

Definition at line 98 of file ExplicitMixedOrder.h.

◆ _vars_first

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

protectedinherited

Definition at line 101 of file ExplicitMixedOrder.h.

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

◆ _vars_second

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

protectedinherited

Definition at line 107 of file ExplicitMixedOrder.h.

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

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TimeOrder

Constructor & Destructor Documentation

◆ NEML2CentralDifference()

Member Function Documentation

◆ advancesProblemState()

◆ computeADTimeDerivatives()

◆ computeICs()

◆ computeTimeDerivativeHelper()

◆ computeTimeDerivatives()

◆ evaluateRHSResidual()

◆ findVariableTimeOrder()

◆ init()

◆ initialSetup()

◆ massMatrixTagID()

◆ meshChanged()

◆ order()

◆ overridesSolve()

◆ performExplicitSolve()

◆ postResidual()

◆ postSolve()

◆ rebuildBoundaryElementList()

◆ solve()

◆ updateDOFIndices()

◆ validParams()

Member Data Documentation

◆ _boundary_elems

◆ _boundary_elems_dirty

◆ _constant_mass

◆ _fe

◆ _local_first_order_indices

◆ _local_second_order_indices

◆ _mass_matrix_lumped

◆ _mass_matrix_name

◆ _mesh_changed

◆ _neml2_assembly

◆ _no_node

◆ _recompute_mass_matrix_on_mesh_change

◆ _solution_older

◆ _vars_first

◆ _vars_second