#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. More...

Protected Attributes
FEProblemBase &	_fe_problem

THREAD_ID	_tid

Detailed Description

Definition at line 20 of file ComputeInitialConditionThread.h.

Constructor & Destructor Documentation

◆ ComputeInitialConditionThread() [1/2]

ComputeInitialConditionThread::ComputeInitialConditionThread ( FEProblemBase & fe_problem )

Definition at line 16 of file ComputeInitialConditionThread.C.

   : _fe_problem(fe_problem)
 {
 }

◆ ComputeInitialConditionThread() [2/2]

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

Definition at line 21 of file ComputeInitialConditionThread.C.

   : _fe_problem(x._fe_problem)
 {
 }

Member Function Documentation

◆ join()

void ComputeInitialConditionThread::join ( const ComputeInitialConditionThread & )

Definition at line 109 of file ComputeInitialConditionThread.C.

110 {

111 }

◆ operator()()

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

Definition at line 28 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;
           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 114 of file ComputeInitialConditionThread.C.

Referenced by operator()().

 {
   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;
   }
 }