ComputeMortarFunctor Class Reference

#include <ComputeMortarFunctor.h>

Inheritance diagram for ComputeMortarFunctor:

Public Member Functions
	ComputeMortarFunctor (const std::vector< std::shared_ptr< MortarConstraintBase >> &mortar_constraints, const AutomaticMortarGeneration &amg, SubProblem &subproblem, FEProblemBase &fe_problem, bool displaced, Assembly &assembly)
void	operator() (Moose::ComputeType compute_type, const std::set< TagID > &vector_tag_ids, const std::set< TagID > &matrix_tag_ids)
	Loops over the mortar segment mesh and computes the residual/Jacobian. More...

Protected Attributes
Materials for Mortar
These containers hold the materials whose properties are required by a given set of consumers. Note that these containers will also hold materials that may not provide properties explicitly needed by the consumers but do provided properties that are dependencies of the materials that do provide properties needed by the consumers
std::map< SubdomainID, std::deque< MaterialBase * > >	_secondary_ip_sub_to_mats
std::map< SubdomainID, std::deque< MaterialBase * > >	_primary_ip_sub_to_mats
	A map from primary interior parent subdomain IDs to the block materials that will need to reinit'd on the primary face. More...
std::deque< MaterialBase * >	_secondary_boundary_mats
	A container that holds the boundary materials that will need to be reinit'd on the secondary face. More...

Private Attributes
std::vector< MortarConstraintBase * >	_mortar_constraints
	The mortar constraints to loop over when on each element. More...
const AutomaticMortarGeneration &	_amg
	Automatic mortar generation (amg) object providing the mortar mesh to loop over. More...
SubProblem &	_subproblem
	A reference to the SubProblem object for reiniting lower-dimensional element quantities. More...
FEProblemBase &	_fe_problem
	A reference to the FEProblemBase object for reiniting higher-dimensional element and neighbor element quantities. More...
const bool	_displaced
	Whether the mortar constraints are operating on the displaced mesh. More...
Assembly &	_assembly
	A reference to the assembly object. More...

Detailed Description

Definition at line 33 of file ComputeMortarFunctor.h.

Constructor & Destructor Documentation

ComputeMortarFunctor()

ComputeMortarFunctor::ComputeMortarFunctor	(	const std::vector< std::shared_ptr< MortarConstraintBase >> &	mortar_constraints,
		const AutomaticMortarGeneration &	amg,
		SubProblem &	subproblem,
		FEProblemBase &	fe_problem,
		bool	displaced,
		Assembly &	assembly
	)

Definition at line 27 of file ComputeMortarFunctor.C.

  : _amg(amg),
    _subproblem(subproblem),
    _fe_problem(fe_problem),
    _displaced(displaced),
    _assembly(assembly)
{
  // Construct the mortar constraints we will later loop over
  for (auto mc : mortar_constraints)
    _mortar_constraints.push_back(mc.get());

  Moose::Mortar::setupMortarMaterials(_mortar_constraints,
                                      _fe_problem,
                                      _amg,
                                      0,
                                      _secondary_ip_sub_to_mats,
                                      _primary_ip_sub_to_mats,
                                      _secondary_boundary_mats);
}

Member Function Documentation

operator()()

void ComputeMortarFunctor::operator()	(	Moose::ComputeType	compute_type,
		const std::set< TagID > &	vector_tag_ids,
		const std::set< TagID > &	matrix_tag_ids
	)

Loops over the mortar segment mesh and computes the residual/Jacobian.

Definition at line 54 of file ComputeMortarFunctor.C.

{
  libmesh_parallel_only(_fe_problem.comm());

  unsigned int num_cached = 0;
  const auto & vector_tags = _fe_problem.getVectorTags(vector_tag_ids);

  const auto & secondary_elems_to_mortar_segments = _amg.secondariesToMortarSegments();
  typedef decltype(secondary_elems_to_mortar_segments.begin()) it_type;

  std::vector<it_type> iterators;
  for (auto it = secondary_elems_to_mortar_segments.begin();
       it != secondary_elems_to_mortar_segments.end();
       ++it)
  {
    auto * const secondary_elem = _subproblem.mesh().getMesh().query_elem_ptr(it->first);

    if (secondary_elem && secondary_elem->processor_id() == _subproblem.processor_id() &&
        !it->second.empty())
    {
      // This is local and the mortar segment set isn't empty, so include
      iterators.push_back(it);
      mooseAssert(secondary_elem->active(),
                  "We loop over active elements when building the mortar segment mesh, so we golly "
                  "well hope this is active.");
    }
  }

  auto act_functor = [this, &num_cached, compute_type, &vector_tags]()
  {
    ++num_cached;

    switch (compute_type)
    {
      case Moose::ComputeType::Residual:
      {
        for (auto * const mc : _mortar_constraints)
        {
          mc->setNormals();
          mc->computeResidual();
        }

        _assembly.cacheResidual(Assembly::GlobalDataKey{}, vector_tags);
        _assembly.cacheResidualNeighbor(Assembly::GlobalDataKey{}, vector_tags);
        _assembly.cacheResidualLower(Assembly::GlobalDataKey{}, vector_tags);

        if (num_cached % 20 == 0)
          _assembly.addCachedResiduals(Assembly::GlobalDataKey{}, vector_tags);

        break;
      }

      case Moose::ComputeType::Jacobian:
      {
        for (auto * const mc : _mortar_constraints)
        {
          mc->setNormals();
          mc->computeJacobian();
        }

        _assembly.cacheJacobianMortar(Assembly::GlobalDataKey{});

        if (num_cached % 20 == 0)
          _assembly.addCachedJacobian(Assembly::GlobalDataKey{});
        break;
      }

      case Moose::ComputeType::ResidualAndJacobian:
      {
        for (auto * const mc : _mortar_constraints)
        {
          mc->setNormals();
          mc->computeResidualAndJacobian();
        }

        _assembly.cacheResidual(Assembly::GlobalDataKey{}, vector_tags);
        _assembly.cacheResidualNeighbor(Assembly::GlobalDataKey{}, vector_tags);
        _assembly.cacheResidualLower(Assembly::GlobalDataKey{}, vector_tags);
        _assembly.cacheJacobianMortar(Assembly::GlobalDataKey{});

        if (num_cached % 20 == 0)
        {
          _assembly.addCachedResiduals(Assembly::GlobalDataKey{}, vector_tags);
          _assembly.addCachedJacobian(Assembly::GlobalDataKey{});
        }
        break;
      }
    }
  };

  PARALLEL_TRY
  {
    try
    {
      Moose::Mortar::loopOverMortarSegments(iterators,
                                            _assembly,
                                            _subproblem,
                                            _fe_problem,
                                            _amg,
                                            _displaced,
                                            _mortar_constraints,
                                            0,
                                            _secondary_ip_sub_to_mats,
                                            _primary_ip_sub_to_mats,
                                            _secondary_boundary_mats,
                                            act_functor,
                                            /*reinit_mortar_user_objects=*/true);
    }
    catch (libMesh::LogicError & e)
    {
      _fe_problem.setException("We caught a libMesh::LogicError: " + std::string(e.what()));
    }
    catch (MooseException & e)
    {
      _fe_problem.setException(e.what());
    }
    catch (MetaPhysicL::LogicError & e)
    {
      moose::translateMetaPhysicLError(e);
    }
  }
  PARALLEL_CATCH;

  // Call any post operations for our mortar constraints
  for (auto * const mc : _mortar_constraints)
  {
    if (_amg.incorrectEdgeDropping())
      mc->incorrectEdgeDroppingPost(_amg.getInactiveLMNodes());
    else
      mc->post();

    mc->zeroInactiveLMDofs(_amg.getInactiveLMNodes(), _amg.getInactiveLMElems());
  }

  // Make sure any remaining cached residuals/Jacobians get added
  if (_assembly.computingResidual())
    _assembly.addCachedResiduals(Assembly::GlobalDataKey{}, vector_tags);
  if (_assembly.computingJacobian())
    _assembly.addCachedJacobian(Assembly::GlobalDataKey{});
}

Member Data Documentation

_amg

const AutomaticMortarGeneration& ComputeMortarFunctor::_amg

private

Automatic mortar generation (amg) object providing the mortar mesh to loop over.

Definition at line 59 of file ComputeMortarFunctor.h.

Referenced by ComputeMortarFunctor(), and operator()().

_assembly

Assembly& ComputeMortarFunctor::_assembly

private

A reference to the assembly object.

Definition at line 73 of file ComputeMortarFunctor.h.

Referenced by operator()().

_displaced

const bool ComputeMortarFunctor::_displaced

private

Whether the mortar constraints are operating on the displaced mesh.

Definition at line 70 of file ComputeMortarFunctor.h.

Referenced by operator()().

_fe_problem

FEProblemBase& ComputeMortarFunctor::_fe_problem

private

A reference to the FEProblemBase object for reiniting higher-dimensional element and neighbor element quantities.

We use the FEProblemBase object for reiniting these because we may be using material properties from either undisplaced or displaced materials

Definition at line 67 of file ComputeMortarFunctor.h.

Referenced by ComputeMortarFunctor(), and operator()().

_mortar_constraints

std::vector<MortarConstraintBase *> ComputeMortarFunctor::_mortar_constraints

private

The mortar constraints to loop over when on each element.

These must be pointers to the base class otherwise the compiler will fail to compile when running std::vector<MortarConstraint0>::push_back(MortarConstraint1> or visa versa

Definition at line 56 of file ComputeMortarFunctor.h.

Referenced by ComputeMortarFunctor(), and operator()().

_primary_ip_sub_to_mats

std::map<SubdomainID, std::deque<MaterialBase *> > MortarExecutorInterface::_primary_ip_sub_to_mats

protectedinherited

A map from primary interior parent subdomain IDs to the block materials that will need to reinit'd on the primary face.

Definition at line 43 of file MortarExecutorInterface.h.

Referenced by ComputeMortarFunctor(), MortarUserObjectThread::MortarUserObjectThread(), MortarUserObjectThread::operator()(), and operator()().

_secondary_boundary_mats

std::deque<MaterialBase *> MortarExecutorInterface::_secondary_boundary_mats

protectedinherited

A container that holds the boundary materials that will need to be reinit'd on the secondary face.

Definition at line 47 of file MortarExecutorInterface.h.

Referenced by ComputeMortarFunctor(), MortarUserObjectThread::MortarUserObjectThread(), MortarUserObjectThread::operator()(), and operator()().

_secondary_ip_sub_to_mats

std::map<SubdomainID, std::deque<MaterialBase *> > MortarExecutorInterface::_secondary_ip_sub_to_mats

protectedinherited

A map from secondary interior parent subdomain IDs to the block materials that will need to reinit'd on the secondary face

Definition at line 39 of file MortarExecutorInterface.h.

Referenced by ComputeMortarFunctor(), MortarUserObjectThread::MortarUserObjectThread(), MortarUserObjectThread::operator()(), and operator()().

_subproblem

SubProblem& ComputeMortarFunctor::_subproblem

private

A reference to the SubProblem object for reiniting lower-dimensional element quantities.

Definition at line 62 of file ComputeMortarFunctor.h.

Referenced by operator()().

---

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

• include/loops/ComputeMortarFunctor.h
• src/loops/ComputeMortarFunctor.C