GhostPrimaryFace.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "GhostPrimaryFace.h"
#include "MooseApp.h"
#include "libmesh/boundary_info.h"
#include "libmesh/elem.h"
 
#include <sstream>
 
registerMooseObject("MooseApp", GhostPrimaryFace);
 
using namespace libMesh;
 
InputParameters
GhostPrimaryFace::validParams()
{
  InputParameters params = RelationshipManager::validParams();
  params.addRequiredParam<BoundaryName>("primary_boundary",
                                        "The name of the primary boundary sideset.");
  params.addRequiredParam<BoundaryName>("secondary_boundary",
                                        "The name of the secondary boundary sideset.");
  params.addRequiredParam<bool>("enabled", "Whether this relationship manager should ghost.");
  params.addClassDescription(
      "Ghosts full-dimensional elements with sides on the primary boundary to processors that own "
      "full-dimensional elements with sides on the secondary boundary.");
  return params;
}
 
GhostPrimaryFace::GhostPrimaryFace(const InputParameters & params)
  : RelationshipManager(params),
    _primary_boundary_name(getParam<BoundaryName>("primary_boundary")),
    _secondary_boundary_name(getParam<BoundaryName>("secondary_boundary")),
    _enabled(getParam<bool>("enabled"))
{
}
 
GhostPrimaryFace::GhostPrimaryFace(const GhostPrimaryFace & other)
  : RelationshipManager(other),
    _primary_boundary_name(other._primary_boundary_name),
    _secondary_boundary_name(other._secondary_boundary_name),
    _enabled(other._enabled)
{
}
 
void
GhostPrimaryFace::internalInitWithMesh(const MeshBase &)
{
}
 
std::string
GhostPrimaryFace::getInfo() const
{
  std::ostringstream oss;
  oss << "GhostPrimaryFace" << (_enabled ? "" : " (disabled)");
  return oss.str();
}
 
bool
GhostPrimaryFace::hasSecondaryBoundaryFace(const MeshBase::const_element_iterator & range_begin,
                                           const MeshBase::const_element_iterator & range_end,
                                           const BoundaryID secondary_boundary_id,
                                           const bool generating_mesh) const
{
  const auto mesh_dim = _mesh->mesh_dimension();
  const BoundaryInfo & binfo = _mesh->get_boundary_info();
 
  for (const Elem * const elem : as_range(range_begin, range_end))
  {
    if (elem->dim() != mesh_dim)
      continue;
 
    if (generating_mesh)
    {
      // Boundary ids may not exist yet while generating the mesh, so treat any
      // full-dimensional boundary element as being on the requested boundary.
      if (elem->on_boundary())
        return true;
    }
    else
      for (const auto side : elem->side_index_range())
        if (binfo.has_boundary_id(elem, side, secondary_boundary_id))
          return true;
  }
 
  return false;
}
 
void
GhostPrimaryFace::operator()(const MeshBase::const_element_iterator & range_begin,
                             const MeshBase::const_element_iterator & range_end,
                             const processor_id_type p,
                             map_type & coupled_elements)
{
  if (!_enabled)
    return;
 
  const bool generating_mesh = !_moose_mesh->getMeshPtr();
  const auto primary_boundary_id = generating_mesh
                                       ? Moose::INVALID_BOUNDARY_ID
                                       : _moose_mesh->getBoundaryID(_primary_boundary_name);
  const auto secondary_boundary_id = generating_mesh
                                         ? Moose::INVALID_BOUNDARY_ID
                                         : _moose_mesh->getBoundaryID(_secondary_boundary_name);
 
  if (!hasSecondaryBoundaryFace(range_begin, range_end, secondary_boundary_id, generating_mesh))
    return;
 
  const auto mesh_dim = _mesh->mesh_dimension();
  const BoundaryInfo & binfo = _mesh->get_boundary_info();
 
  for (const Elem * const elem : _mesh->active_element_ptr_range())
  {
    if (elem->processor_id() == p || elem->dim() != mesh_dim)
      continue;
 
    if (generating_mesh)
    {
      // Boundary ids may not exist yet while generating the mesh, so ghost any
      // full-dimensional boundary element.
      if (elem->on_boundary())
        coupled_elements.emplace(elem, _null_mat);
    }
    else
      for (const auto side : elem->side_index_range())
        if (binfo.has_boundary_id(elem, side, primary_boundary_id))
        {
          coupled_elements.emplace(elem, _null_mat);
          break;
        }
  }
}
 
bool
GhostPrimaryFace::operator>=(const RelationshipManager & other) const
{
  const auto * const primary_face = dynamic_cast<const GhostPrimaryFace *>(&other);
  if (!primary_face || !baseGreaterEqual(*primary_face))
    return false;
 
  // An enabled instance subsumes an otherwise compatible disabled instance, which adds no
  // ghosting entries.
  if (_enabled && !primary_face->_enabled)
    return true;
 
  // A disabled instance only subsumes another disabled instance.
  if (!_enabled)
    return !primary_face->_enabled;
 
  // Once both are enabled, the two instances must ghost the same boundary pair on the same
  // mesh to cover the same elements.
  return primary_face->_enabled && _use_displaced_mesh == primary_face->_use_displaced_mesh &&
         _primary_boundary_name == primary_face->_primary_boundary_name &&
         _secondary_boundary_name == primary_face->_secondary_boundary_name;
}
 
std::unique_ptr<GhostingFunctor>
GhostPrimaryFace::clone() const
{
  return _app.getFactory().copyConstruct(*this);
}