Allows a constraint u>=v to be enforced during the nonlinear iteration process. More...

#include <RichardsMultiphaseProblem.h>

Inheritance diagram for RichardsMultiphaseProblem:

Public Member Functions
	RichardsMultiphaseProblem (const InputParameters &params)

virtual	~RichardsMultiphaseProblem ()

virtual void	initialSetup ()
	extracts the moose variable numbers associated with bounded_var and lower_var More...

virtual bool	shouldUpdateSolution ()
	returns true, indicating that updateSolution should be run More...

virtual bool	updateSolution (NumericVector< Number > &vec_solution, NumericVector< Number > &ghosted_solution)
	Does the bounding by modifying vec_solution, and then ghosted_solution. More...

Protected Attributes
NonlinearVariableName	_bounded_var_name
	name of the bounded variable (this is the variable that gets altered to respect bounded_var > lower_var) More...

NonlinearVariableName	_lower_var_name
	name of the variable that acts as the lower bound to bounded_var More...

unsigned int	_bounded_var_num
	internal moose variable number associated with _bounded_var More...

unsigned int	_lower_var_num
	internal moose variable number associated with _lower_var More...

Detailed Description

Allows a constraint u>=v to be enforced during the nonlinear iteration process.

This is done by modifying u (which is called bounded_var below)

Definition at line 24 of file RichardsMultiphaseProblem.h.

Constructor & Destructor Documentation

◆ RichardsMultiphaseProblem()

RichardsMultiphaseProblem::RichardsMultiphaseProblem ( const InputParameters & params )

Definition at line 33 of file RichardsMultiphaseProblem.C.

   : FEProblem(params),
     // in the following have to get the names of the variables, and then find their numbers in
     // initialSetup,
     // as their numbers won't be defined at the moment of instantiation of this class
     _bounded_var_name(params.get<NonlinearVariableName>("bounded_var")),
     _lower_var_name(params.get<NonlinearVariableName>("lower_var")),
     _bounded_var_num(0),
     _lower_var_num(0)
 {
 }

◆ ~RichardsMultiphaseProblem()

RichardsMultiphaseProblem::~RichardsMultiphaseProblem ( )

virtual

Definition at line 45 of file RichardsMultiphaseProblem.C.

45 {}

Member Function Documentation

◆ initialSetup()

void RichardsMultiphaseProblem::initialSetup ( )

virtual

extracts the moose variable numbers associated with bounded_var and lower_var

Definition at line 48 of file RichardsMultiphaseProblem.C.

 {
   // the first argument to getVariable is threadID - i hope the following always works
   unsigned int tid = 0;
  
   // We are going to do more specific checks below, hence allowing
   // more specific error messages to be printed in case something goes
   // wrong. Therefore we just pass VAR_ANY here.
   MooseVariableFEBase & bounded = getVariable(
       tid, _bounded_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
   MooseVariableFEBase & lower = getVariable(
       tid, _lower_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
  
   // some checks
   if (!bounded.isNodal() || !lower.isNodal())
     mooseError("Both the bounded and lower variables must be nodal variables in "
                "RichardsMultiphaseProblem");
   if (bounded.feType().family != lower.feType().family)
     mooseError("Both the bounded and lower variables must belong to the same element family, eg "
                "LAGRANGE, in RichardsMultiphaseProblem");
   if (bounded.feType().order != lower.feType().order)
     mooseError("Both the bounded and lower variables must have the same order, eg FIRST, in "
                "RichardsMultiphaseProblem");
  
   // extract the required info
   _bounded_var_num = bounded.number();
   _lower_var_num = lower.number();
  
   FEProblemBase::initialSetup();
 }

◆ shouldUpdateSolution()

bool RichardsMultiphaseProblem::shouldUpdateSolution ( )

virtual

returns true, indicating that updateSolution should be run

Definition at line 80 of file RichardsMultiphaseProblem.C.

 {
   return true;
 }

◆ updateSolution()

bool RichardsMultiphaseProblem::updateSolution	(	NumericVector< Number > &	vec_solution,
		NumericVector< Number > &	ghosted_solution
	)

virtual

Does the bounding by modifying vec_solution, and then ghosted_solution.

Parameters

vec_solution	is the solution that Petsc says we should use.
ghosted_solution	is a ghosted version of vec_solution.

Returns: true if vec_solution was changed at a node in order to respect the bounds

Definition at line 86 of file RichardsMultiphaseProblem.C.

 {
   bool updatedSolution =
       false; // this gets set to true if we needed to enforce the bound at any node
  
   unsigned int sys_num = getNonlinearSystemBase().number();
  
   // For parallel procs i believe that i have to use local_nodes_begin, rather than just nodes_begin
   // _mesh comes from SystemBase (_mesh = getNonlinearSystemBase().subproblem().mesh(), and
   // subproblem is this object)
   for (const auto & node : _mesh.getMesh().local_node_ptr_range())
   {
     // dofs[0] is the dof number of the bounded variable at this node
     // dofs[1] is the dof number of the lower variable at this node
     std::vector<dof_id_type> dofs(2);
     dofs[0] = node->dof_number(sys_num, _bounded_var_num, 0);
     dofs[1] = node->dof_number(sys_num, _lower_var_num, 0);
  
     // soln[0] is the value of the bounded variable at this node
     // soln[1] is the value of the lower variable at this node
     std::vector<Number> soln(2);
     vec_solution.get(dofs, soln);
  
     // do the bounding
     if (soln[0] < soln[1])
     {
       vec_solution.set(dofs[0], soln[1]); // set the bounded variable equal to the lower value
       updatedSolution = true;
     }
   }
  
   // The above vec_solution.set calls potentially added "set" commands to a queue
   // The following actions the queue (doing MPI commands if necessary), so
   // vec_solution will actually be modified by this following command
   vec_solution.close();
  
   // if any proc updated the solution, all procs will know about it
   _communicator.max(updatedSolution);
  
   if (updatedSolution)
   {
     ghosted_solution = vec_solution;
     ghosted_solution.close();
   }
  
   return updatedSolution;
 }