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	setupMortarMaterials ()
	Setup step for materials that needs to be re-done if subdomains change.
void	mortarSetup (const AutomaticMortarGeneration &amg) override
	Called by the MortarInterfaceWarehouse whenever amg's mortar segment mesh coverage has changed, so that this object may refresh any state (e.g.
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.

Protected Attributes
MortarInterfaceWarehouse &	_mortar_warehouse
	The warehouse this object is registered with for mortar setup notifications.
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.
std::deque< MaterialBase * >	_secondary_boundary_mats
	A container that holds the boundary materials that will need to be reinit'd on the secondary face.

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

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 30 of file ComputeMortarFunctor.C.

  : MortarExecutorInterface(fe_problem),
    _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());
 
  setupMortarMaterials();
}

Member Function Documentation

mortarSetup()

void ComputeMortarFunctor::mortarSetup ( const AutomaticMortarGeneration &  amg )

overridevirtual

Called by the MortarInterfaceWarehouse whenever amg's mortar segment mesh coverage has changed, so that this object may refresh any state (e.g.

material dependency lists) that depends on which subdomains/boundaries the mortar segment mesh currently touches.

Implements MortarExecutorInterface.

Definition at line 52 of file ComputeMortarFunctor.C.

{
  // We may be registered with a warehouse that owns multiple interfaces; only react to the one
  // we actually consume.
  if (&amg == &_amg)
    setupMortarMaterials();
}

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 73 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 (MooseException & e)
    {
      _fe_problem.setException(e.what());
    }
    catch (MetaPhysicL::LogicError & e)
    {
      moose::translateMetaPhysicLError(e);
    }
    catch (std::exception & e)
    {
      if (!strstr(e.what(), "Jacobian") && !strstr(e.what(), "singular") &&
          !strstr(e.what(), "det != 0"))
        throw;
 
      _fe_problem.setException(
          "We caught a libMesh degeneracy exception in ComputeMortarFunctor:\n" +
          std::string(e.what()));
    }
  }
  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{});
}

setupMortarMaterials()

void ComputeMortarFunctor::setupMortarMaterials

(

)

Setup step for materials that needs to be re-done if subdomains change.

Definition at line 61 of file ComputeMortarFunctor.C.

{
  Moose::Mortar::setupMortarMaterials(_mortar_constraints,
                                      _fe_problem,
                                      _amg,
                                      /*thread id*/ 0,
                                      _secondary_ip_sub_to_mats,
                                      _primary_ip_sub_to_mats,
                                      _secondary_boundary_mats);
}

Referenced by ComputeMortarFunctor(), and mortarSetup().

Member Data Documentation

_amg

const AutomaticMortarGeneration& ComputeMortarFunctor::_amg

private

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

Definition at line 64 of file ComputeMortarFunctor.h.

Referenced by mortarSetup(), operator()(), and setupMortarMaterials().

_assembly

Assembly& ComputeMortarFunctor::_assembly

private

A reference to the assembly object.

Definition at line 78 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 75 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 72 of file ComputeMortarFunctor.h.

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

_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 61 of file ComputeMortarFunctor.h.

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

_mortar_warehouse

MortarInterfaceWarehouse& MortarExecutorInterface::_mortar_warehouse

protectedinherited

The warehouse this object is registered with for mortar setup notifications.

Definition at line 69 of file MortarExecutorInterface.h.

Referenced by MortarExecutorInterface::MortarExecutorInterface(), MortarExecutorInterface::MortarExecutorInterface(), and MortarUserObjectThread::~MortarUserObjectThread().

_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 85 of file MortarExecutorInterface.h.

Referenced by MortarUserObjectThread::mortarSetup(), MortarUserObjectThread::operator()(), operator()(), and setupMortarMaterials().

_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 89 of file MortarExecutorInterface.h.

Referenced by MortarUserObjectThread::mortarSetup(), MortarUserObjectThread::operator()(), operator()(), and setupMortarMaterials().

_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 81 of file MortarExecutorInterface.h.

Referenced by MortarUserObjectThread::mortarSetup(), MortarUserObjectThread::operator()(), operator()(), and setupMortarMaterials().

_subproblem

SubProblem& ComputeMortarFunctor::_subproblem

private

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

Definition at line 67 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