DisplacedProblem::UpdateDisplacedMeshThread Class Reference

#include <DisplacedProblem.h>

Inheritance diagram for DisplacedProblem::UpdateDisplacedMeshThread:

Public Member Functions
	UpdateDisplacedMeshThread (FEProblemBase &fe_problem, DisplacedProblem &displaced_problem)
	UpdateDisplacedMeshThread (UpdateDisplacedMeshThread &x, Threads::split split)
virtual void	onNode (NodeRange::const_iterator &nd) override
void	join (const UpdateDisplacedMeshThread &y)
bool	hasDisplacement ()
	Whether the displaced mesh is modified by the latest call to operator()
void	operator() (const NodeRange &range)
virtual void	pre ()
	Called before the node range loop.
virtual void	post ()
	Called after the node range loop.
virtual void	onNode (NodeRange::const_iterator &node_it)
	Called for each node.
virtual void	postNode (NodeRange::const_iterator &node_it)
	Called after the node assembly is done (including surface assembling)
virtual void	caughtMooseException (MooseException &e)
	Called if a MooseException is caught anywhere during the computation.
virtual bool	keepGoing ()
	Whether or not the loop should continue.

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

Protected Attributes
DisplacedProblem &	_displaced_problem
	Diplaced problem.
MooseMesh &	_ref_mesh
	Original mesh.
const std::vector< const NumericVector< Number > * > &	_nl_soln
	Solution vectors of the nonlinear systems on the displaced problem.
const NumericVector< Number > &	_aux_soln
	Solution vector of the auxliary system on the displaced problem.
std::map< unsigned int, std::pair< const NumericVector< Number > *, std::shared_ptr< NumericVector< Number > > > >	_sys_to_nonghost_and_ghost_soln
FEProblemBase &	_fe_problem
THREAD_ID	_tid

Private Attributes
std::map< unsigned int, std::pair< std::vector< unsigned int >, std::vector< unsigned int > > >	_sys_to_var_num_and_direction
	To locate the system numbers, variable numbers of all displacement variables.
bool	_has_displacement
	A flag to be set by operator() for indicating whether the displaced mesh is indeed modified.

Detailed Description

Definition at line 411 of file DisplacedProblem.h.

Constructor & Destructor Documentation

UpdateDisplacedMeshThread() [1/2]

DisplacedProblem::UpdateDisplacedMeshThread::UpdateDisplacedMeshThread	(	FEProblemBase &	fe_problem,
		DisplacedProblem &	displaced_problem
	)

Definition at line 1419 of file DisplacedProblem.C.

  : ThreadedNodeLoop<NodeRange, NodeRange::const_iterator>(fe_problem),
    _displaced_problem(displaced_problem),
    _ref_mesh(_displaced_problem.refMesh()),
    _nl_soln(_displaced_problem._nl_solution),
    _aux_soln(*_displaced_problem._aux_solution),
    _has_displacement(false)
{
  this->init();
}

UpdateDisplacedMeshThread() [2/2]

DisplacedProblem::UpdateDisplacedMeshThread::UpdateDisplacedMeshThread	(	UpdateDisplacedMeshThread &	x,
		Threads::split	split
	)

Definition at line 1431 of file DisplacedProblem.C.

  : ThreadedNodeLoop<NodeRange, NodeRange::const_iterator>(x, split),
    _displaced_problem(x._displaced_problem),
    _ref_mesh(x._ref_mesh),
    _nl_soln(x._nl_soln),
    _aux_soln(x._aux_soln),
    _sys_to_nonghost_and_ghost_soln(x._sys_to_nonghost_and_ghost_soln),
    _sys_to_var_num_and_direction(x._sys_to_var_num_and_direction),
    _has_displacement(x._has_displacement)
{
}

Member Function Documentation

caughtMooseException()

virtual void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::caughtMooseException ( MooseException &  e )

inlinevirtualinherited

Called if a MooseException is caught anywhere during the computation.

The single input parameter taken is a MooseException object.

Definition at line 56 of file ThreadedNodeLoop.h.

  {
    Threads::spin_mutex::scoped_lock lock(threaded_node_mutex);
 
    std::string what(e.what());
    _fe_problem.setException(what);
  };

hasDisplacement()

bool DisplacedProblem::UpdateDisplacedMeshThread::hasDisplacement ( )

inline

Whether the displaced mesh is modified by the latest call to operator()

Definition at line 429 of file DisplacedProblem.h.

    {
      mooseAssert(!Threads::in_threads,
                  "This function requires a MPI all-gathering operation that cannot be in a "
                  "threaded scope.");
      _ref_mesh.comm().max(_has_displacement);
      return _has_displacement;
    }

Referenced by DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

init()

void DisplacedProblem::UpdateDisplacedMeshThread::init ( )

protected

Definition at line 1445 of file DisplacedProblem.C.

{
  std::vector<std::string> & displacement_variables = _displaced_problem._displacements;
  unsigned int num_displacements = displacement_variables.size();
  auto & es = _displaced_problem.es();
 
  _sys_to_var_num_and_direction.clear();
  _sys_to_nonghost_and_ghost_soln.clear();
 
  for (unsigned int i = 0; i < num_displacements; i++)
  {
    std::string displacement_name = displacement_variables[i];
 
    for (const auto sys_num : make_range(es.n_systems()))
    {
      auto & sys = es.get_system(sys_num);
      if (sys.has_variable(displacement_name))
      {
        auto & val = _sys_to_var_num_and_direction[sys.number()];
        val.first.push_back(sys.variable_number(displacement_name));
        val.second.push_back(i);
        break;
      }
    }
  }
 
  for (const auto & pr : _sys_to_var_num_and_direction)
  {
    auto & sys = es.get_system(pr.first);
    mooseAssert(sys.number() <= _nl_soln.size(),
                "The system number should always be less than or equal to the number of nonlinear "
                "systems. If it is equal, then this system is the auxiliary system");
    const NumericVector<Number> * const nonghost_soln =
        sys.number() < _nl_soln.size() ? _nl_soln[sys.number()] : &_aux_soln;
    _sys_to_nonghost_and_ghost_soln.emplace(
        sys.number(),
        std::make_pair(nonghost_soln,
                       NumericVector<Number>::build(nonghost_soln->comm()).release()));
  }
 
  ConstNodeRange node_range(_ref_mesh.getMesh().nodes_begin(), _ref_mesh.getMesh().nodes_end());
 
  for (auto & [sys_num, var_num_and_direction] : _sys_to_var_num_and_direction)
  {
    auto & sys = es.get_system(sys_num);
    AllNodesSendListThread send_list(
        this->_fe_problem, _ref_mesh, var_num_and_direction.first, sys);
    Threads::parallel_reduce(node_range, send_list, this->_fe_problem.numThreads());
    send_list.unique();
    auto & [soln, ghost_soln] = libmesh_map_find(_sys_to_nonghost_and_ghost_soln, sys_num);
    ghost_soln->init(
        soln->size(), soln->local_size(), send_list.send_list(), true, libMesh::GHOSTED);
    soln->localize(*ghost_soln, send_list.send_list());
  }
 
  _has_displacement = false;
}

Referenced by UpdateDisplacedMeshThread().

join()

void DisplacedProblem::UpdateDisplacedMeshThread::join ( const UpdateDisplacedMeshThread &  y )

inline

Definition at line 420 of file DisplacedProblem.h.

    {
      if (y._has_displacement)
        _has_displacement = true;
    }

keepGoing()

virtual bool ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::keepGoing ( )

inlinevirtualinherited

Whether or not the loop should continue.

Returns

true to keep going, false to stop.

Definition at line 69 of file ThreadedNodeLoop.h.

{ return !_fe_problem.hasException(); }

onNode() [1/2]

void DisplacedProblem::UpdateDisplacedMeshThread::onNode ( NodeRange::const_iterator &  nd )

overridevirtual

Definition at line 1504 of file DisplacedProblem.C.

{
  Node & displaced_node = *(*nd);
 
  Node & reference_node = _ref_mesh.nodeRef(displaced_node.id());
 
  for (auto & [sys_num, var_num_and_direction] : _sys_to_var_num_and_direction)
  {
    auto & var_numbers = var_num_and_direction.first;
    auto & directions = var_num_and_direction.second;
    for (const auto i : index_range(var_numbers))
    {
      const auto direction = directions[i];
      if (reference_node.n_dofs(sys_num, var_numbers[i]) > 0)
      {
        Real coord = reference_node(direction) +
                     (*libmesh_map_find(_sys_to_nonghost_and_ghost_soln, sys_num).second)(
                         reference_node.dof_number(sys_num, var_numbers[i], 0));
        // A non-finite displacement (e.g. after a failed linear solve) would corrupt every
        // downstream geometric operation. Throw so the solve can be stopped and the step cut.
        if (!std::isfinite(coord))
          throw MooseException("Non-finite displaced coordinate in direction ",
                               direction,
                               " at node ",
                               displaced_node.id(),
                               ".");
        if (displaced_node(direction) != coord)
        {
          displaced_node(direction) = coord;
          _has_displacement = true;
        }
      }
    }
  }
}

onNode() [2/2]

void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::onNode ( NodeRange::const_iterator &  node_it )

virtualinherited

Called for each node.

Definition at line 43 of file ThreadedNodeLoop.h.

{
}

operator()()

void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::operator() ( const NodeRange &  range )

inherited

Definition at line 28 of file ThreadedNodeLoop.h.

{
  try
  {
    ParallelUniqueId puid;
    _tid = puid.id;
 
    pre();
    printGeneralExecutionInformation();
 
    for (IteratorType nd = range.begin(); nd != range.end(); ++nd)
    {
      if (!keepGoing())
        break;
 
      onNode(nd);
 
      postNode(nd);
    }
 
    post();
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
}

post()

void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::post ( )

virtualinherited

Called after the node range loop.

Definition at line 38 of file ThreadedNodeLoop.h.

{
}

postNode()

void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::postNode ( NodeRange::const_iterator &  node_it )

virtualinherited

Called after the node assembly is done (including surface assembling)

Parameters

node	- active node

Definition at line 50 of file ThreadedNodeLoop.h.

{
}

pre()

void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::pre ( )

virtualinherited

Called before the node range loop.

Definition at line 33 of file ThreadedNodeLoop.h.

{
}

printGeneralExecutionInformation()

virtual void ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::printGeneralExecutionInformation ( ) const

inlineprotectedvirtualinherited

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

Definition at line 76 of file ThreadedNodeLoop.h.

{}

Member Data Documentation

_aux_soln

const NumericVector<Number>& DisplacedProblem::UpdateDisplacedMeshThread::_aux_soln

protected

Solution vector of the auxliary system on the displaced problem.

Definition at line 448 of file DisplacedProblem.h.

_displaced_problem

DisplacedProblem& DisplacedProblem::UpdateDisplacedMeshThread::_displaced_problem

protected

Diplaced problem.

Definition at line 442 of file DisplacedProblem.h.

_fe_problem

FEProblemBase& ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::_fe_problem

protectedinherited

Definition at line 72 of file ThreadedNodeLoop.h.

_has_displacement

bool DisplacedProblem::UpdateDisplacedMeshThread::_has_displacement

private

A flag to be set by operator() for indicating whether the displaced mesh is indeed modified.

Definition at line 464 of file DisplacedProblem.h.

Referenced by hasDisplacement(), and join().

_nl_soln

const std::vector<const NumericVector<Number> *>& DisplacedProblem::UpdateDisplacedMeshThread::_nl_soln

protected

Solution vectors of the nonlinear systems on the displaced problem.

Definition at line 446 of file DisplacedProblem.h.

_ref_mesh

MooseMesh& DisplacedProblem::UpdateDisplacedMeshThread::_ref_mesh

protected

Original mesh.

Definition at line 444 of file DisplacedProblem.h.

Referenced by hasDisplacement().

_sys_to_nonghost_and_ghost_soln

std::map<unsigned int, std::pair<const NumericVector<Number> *, std::shared_ptr<NumericVector<Number> > > > DisplacedProblem::UpdateDisplacedMeshThread::_sys_to_nonghost_and_ghost_soln

protected

Definition at line 455 of file DisplacedProblem.h.

_sys_to_var_num_and_direction

std::map<unsigned int, std::pair<std::vector<unsigned int>, std::vector<unsigned int> > > DisplacedProblem::UpdateDisplacedMeshThread::_sys_to_var_num_and_direction

private

To locate the system numbers, variable numbers of all displacement variables.

Definition at line 460 of file DisplacedProblem.h.

_tid

THREAD_ID ThreadedNodeLoop< NodeRange , NodeRange::const_iterator >::_tid

protectedinherited

Definition at line 73 of file ThreadedNodeLoop.h.

---

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

• include/problems/DisplacedProblem.h
• src/problems/DisplacedProblem.C