TheWarehouse.C File Reference

Go to the source code of this file.

Classes
class	WarehouseStorage
class	VecStore

Functions
bool	operator== (const std::unique_ptr< Attribute > &lhs, const std::unique_ptr< Attribute > &rhs)
	TheWarehouse uses this operator function for indexing and caching queries.
void	isValid (MooseObject *obj)
void	checkCoupledScalarVariableBlocks (ScalarKernelBase &scalar_kernel)
	Check the scalar variables coupled into a scalar kernel.

Function Documentation

checkCoupledScalarVariableBlocks()

void checkCoupledScalarVariableBlocks

(

ScalarKernelBase &

scalar_kernel

)

Check the scalar variables coupled into a scalar kernel.

The kernel assembles the matrix entries pairing its own variable's dofs with the coupled variable's dofs, and those entries are preallocated only on the elements where both variables exist. A scalar kernel carries no block restriction of its own to compare against, so the condition is a relation between the two variables: they must share at least one block.

Definition at line 307 of file TheWarehouse.C.

{
  const auto & var = scalar_kernel.variable();
  const auto & subdomains = var.activeSubdomains();
 
  // An empty set of active subdomains means the variable lives on the whole mesh
  if (subdomains.empty())
    return;
 
  for (const MooseVariableScalar * const coupled_var : scalar_kernel.getCoupledMooseScalarVars())
  {
    const auto & coupled_subdomains = coupled_var->activeSubdomains();
    if (coupled_subdomains.empty())
      continue;
 
    std::set<SubdomainID> shared_subdomains;
    std::set_intersection(subdomains.begin(),
                          subdomains.end(),
                          coupled_subdomains.begin(),
                          coupled_subdomains.end(),
                          std::inserter(shared_subdomains, shared_subdomains.begin()));
 
    if (shared_subdomains.empty())
      mooseError("The 'block' parameter of the scalar variable '",
                 coupled_var->name(),
                 "' coupled into the object '",
                 scalar_kernel.name(),
                 "' must overlap the 'block' parameter of the variable '",
                 var.name(),
                 "' that the object acts on:\n    Variable '",
                 var.name(),
                 "': ",
                 Moose::stringify(subdomains, ", "),
                 "\n    Variable '",
                 coupled_var->name(),
                 "': ",
                 Moose::stringify(coupled_subdomains, ", "));
  }
}

Referenced by isValid().

isValid()

void isValid

(

MooseObject *

obj

)

Definition at line 348 of file TheWarehouse.C.

{
  auto blk = dynamic_cast<BlockRestrictable *>(obj);
  if (!blk)
  {
    // Scalar kernels are not block restrictable, so their coupled scalar variables are checked
    // against the variable the kernel acts on
    if (auto scalar_kernel = dynamic_cast<ScalarKernelBase *>(obj))
      checkCoupledScalarVariableBlocks(*scalar_kernel);
    return;
  }
 
  // Check variables
  auto c_ptr = dynamic_cast<Coupleable *>(obj);
  if (c_ptr)
    for (MooseVariableFEBase * var : c_ptr->getCoupledMooseVars())
      blk->checkVariable(*var);
 
  // Check scalar variables
  auto sc_ptr = dynamic_cast<ScalarCoupleable *>(obj);
  if (sc_ptr)
    for (MooseVariableScalar * var : sc_ptr->getCoupledMooseScalarVars())
      blk->checkVariable(*var);
 
  const InputParameters & parameters = obj->parameters();
 
  SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");
 
  THREAD_ID tid = parameters.get<THREAD_ID>("_tid");
 
  if (parameters.isParamValid("variable"))
  {
    // Try the scalar version first
    std::string variable_name = parameters.getMooseType("variable");
    if (variable_name == "")
      // When using vector variables, we are only going to use the first one in the list at the
      // interface level...
      variable_name = parameters.getVecMooseType("variable")[0];
 
    blk->checkVariable(problem.getVariable(
        tid, variable_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY));
  }
}

Referenced by TheWarehouse::add().

operator==()

bool operator==	(	const std::unique_ptr< Attribute > &	lhs,
		const std::unique_ptr< Attribute > &	rhs
	)

TheWarehouse uses this operator function for indexing and caching queries.

So this is important even though you don't see it being called (directly) anywhere - it IS being used.

Definition at line 37 of file TheWarehouse.C.

{
  return (*lhs) == (*rhs);
}