#include <ComputeInitialConditionThread.h>

Public Member Functions
	ComputeInitialConditionThread (FEProblemBase &fe_problem)

	ComputeInitialConditionThread (ComputeInitialConditionThread &x, Threads::split split)

void	operator() (const libMesh::ConstElemRange &range)

void	join (const ComputeInitialConditionThread &)

Protected Member Functions
void	printGeneralExecutionInformation () const
	Print information about the loop, mostly order of execution of objects.

Protected Attributes
FEProblemBase &	_fe_problem

THREAD_ID	_tid

Private Member Functions
	ComputeInitialConditionThread (FEProblemBase &fe_problem, const std::set< VariableName > *target_vars)
	Set IC on specific variables.

Private Attributes
const std::set< VariableName > *	_target_vars = nullptr
	the names of target variables for which the initial conditions are applied

Friends
class	FEProblemBase

Detailed Description

Definition at line 20 of file ComputeInitialConditionThread.h.

Constructor & Destructor Documentation

◆ ComputeInitialConditionThread() [1/3]

ComputeInitialConditionThread::ComputeInitialConditionThread ( FEProblemBase & fe_problem )

Definition at line 16 of file ComputeInitialConditionThread.C.

  : _fe_problem(fe_problem)
{
}

◆ ComputeInitialConditionThread() [2/3]

ComputeInitialConditionThread::ComputeInitialConditionThread	(	ComputeInitialConditionThread &	x,
		Threads::split	split
	)

Definition at line 21 of file ComputeInitialConditionThread.C.

  : _fe_problem(x._fe_problem), _target_vars(x._target_vars)
{
}

◆ ComputeInitialConditionThread() [3/3]

ComputeInitialConditionThread::ComputeInitialConditionThread	(	FEProblemBase &	fe_problem,
		const std::set< VariableName > *	target_vars
	)

private

Set IC on specific variables.

Definition at line 27 of file ComputeInitialConditionThread.C.

  : _fe_problem(fe_problem), _target_vars(target_vars)
{
}

Member Function Documentation

◆ join()

void ComputeInitialConditionThread::join ( const ComputeInitialConditionThread & )

Definition at line 121 of file ComputeInitialConditionThread.C.

122{

123}

◆ operator()()

void ComputeInitialConditionThread::operator() ( const libMesh::ConstElemRange & range )

Definition at line 34 of file ComputeInitialConditionThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
  const auto current_ic_state = _fe_problem.getCurrentICState();
 
  const InitialConditionWarehouse & warehouse = _fe_problem.getInitialConditionWarehouse();
  printGeneralExecutionInformation();
 
  // Iterate over all the elements in the range
  for (const auto & elem : range)
  {
    const unsigned int n_nodes = elem->n_nodes();
 
    // we need to execute objects that are for all subdomains covered by this
    // elements' nodes.
    std::set<SubdomainID> block_ids;
    for (unsigned int n = 0; n < n_nodes; n++)
    {
      auto node = elem->node_ptr(n);
      const auto & ids = _fe_problem.mesh().getNodeBlockIds(*node);
      block_ids.insert(ids.begin(), ids.end());
    }
 
    // we need to remember the order the variables originally are provided in
    // since the ics dependencies are resolved to handle the inter-variable
    // dependencies correctly.
    std::vector<MooseVariableFEBase *> order;
 
    // group all initial condition objects by variable. so we can compute all
    // its dof values at once and copy into solution vector once.  This is
    // necessary because we have to collect extra off-block ic objects from
    // nodes shared between subdomains for cases where the off-block ic "wins"
    // on the interface.  The grouping is required because we need to have all
    // the dof values for the element determined together so we can compute
    // the correct qp values, etc. for the variable.
    std::map<MooseVariableFEBase *, std::vector<std::shared_ptr<InitialConditionBase>>> groups;
    for (auto id : block_ids)
      if (warehouse.hasActiveBlockObjects(id, _tid))
        for (auto ic : warehouse.getActiveBlockObjects(id, _tid))
        {
          if ((id != elem->subdomain_id() && !ic->variable().isNodal()) ||
              ic->getState() != current_ic_state)
            continue;
 
          // Skip initial conditions based on target variable usage
          const auto & var_name = ic->variable().name();
          if (_target_vars && !_target_vars->count(var_name))
            continue;
 
          order.push_back(&(ic->variable()));
          groups[&(ic->variable())].push_back(ic);
        }
 
    _fe_problem.setCurrentSubdomainID(elem, _tid);
    _fe_problem.prepare(elem, _tid);
    _fe_problem.reinitElem(elem, _tid);
 
    for (auto var : order)
    {
      DenseVector<Real> Ue;
      auto & vec = groups[var];
 
      // because of all the off-node shenanigans/grouping above, per-variable
      // objects could possible have their order jumbled - so re-sort just in
      // case.
      try
      {
        DependencyResolverInterface::sort<std::shared_ptr<InitialConditionBase>>(vec);
      }
      catch (CyclicDependencyException<std::shared_ptr<InitialConditionBase>> & e)
      {
        DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<InitialConditionBase>>(
            e, "Cyclic dependency detected in object ordering");
      }
 
      for (auto ic : vec)
        ic->compute();
      vec.clear();
 
      // Now that all dofs are set for this variable, solemnize the solution.
      var->insert(var->sys().solution());
    }
  }
}

◆ printGeneralExecutionInformation()

void ComputeInitialConditionThread::printGeneralExecutionInformation ( ) const

protected

Print information about the loop, mostly order of execution of objects.

Definition at line 126 of file ComputeInitialConditionThread.C.

{
  const auto & ic_wh = _fe_problem.getInitialConditionWarehouse();
  if (_fe_problem.shouldPrintExecution(_tid) && ic_wh.hasActiveObjects())
  {
    const auto & console = _fe_problem.console();
    const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
    console << "[DBG] Executing initial conditions on elements on " << execute_on << std::endl;
    console << "[DBG] Unordered list:" << std::endl;
    console << ic_wh.activeObjectsToFormattedString() << std::endl;
    console << "[DBG] The order of execution is defined by dependency resolution on every element"
            << std::endl;
  }
}