GhostAllPointNeighbors.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

// App includes
#include "GhostAllPointNeighbors.h"
#include "Executioner.h"
#include "FEProblemBase.h"
#include "MooseApp.h"
#include "GhostLowerDElems.h"
#include "GhostHigherDLowerDPointNeighbors.h"

// libMesh includes
#include "libmesh/elem.h"
#include "libmesh/mesh_base.h"
#include "libmesh/boundary_info.h"

registerMooseObject("MooseApp", GhostAllPointNeighbors);

using namespace libMesh;

InputParameters
GhostAllPointNeighbors::validParams()
{
  InputParameters params = RelationshipManager::validParams();
  params.set<bool>("attach_geometric_early") = false;
  return params;
}

GhostAllPointNeighbors::GhostAllPointNeighbors(const InputParameters & params)
  : RelationshipManager(params)
{
}

GhostAllPointNeighbors::GhostAllPointNeighbors(const GhostAllPointNeighbors & other)
  : RelationshipManager(other)
{
}

std::string
GhostAllPointNeighbors::getInfo() const
{
  std::ostringstream oss;
  oss << "GhostAllPointNeighbors";
  return oss.str();
}

void
GhostAllPointNeighbors::operator()(const MeshBase::const_element_iterator & range_begin,
                                   const MeshBase::const_element_iterator & range_end,
                                   const processor_id_type p,
                                   map_type & coupled_elements)
{
  mooseAssert(_moose_mesh,
              "The MOOSE mesh must be non-null in order for this relationship manager to work.");
  const auto & node_to_elem_map = _moose_mesh->nodeToElemMap();

  static const CouplingMatrix * const null_mat = nullptr;
  std::unordered_set<dof_id_type> visited_nodes;

  for (const Elem * const elem : as_range(range_begin, range_end))
    for (const auto & node : elem->node_ref_range())
    {
      // We want to ghost the point neighbors if the node hasn't been partitioned yet
      // (e.g. we don't know what processes it will be) or if its processor id matches our
      // processes's id
      const auto node_pid = node.processor_id();
      if (node_pid == p || node_pid == DofObject::invalid_processor_id)
      {
        const auto [_, inserted] = visited_nodes.insert(node.id());
        if (!inserted)
          // We've already considered this node
          continue;

        const auto & elem_node_neighbors = libmesh_map_find(node_to_elem_map, node.id());
        for (const auto elem_id : elem_node_neighbors)
        {
          const Elem * const elem_node_neighbor = _mesh->elem_ptr(elem_id);
          if (elem_node_neighbor->processor_id() != p)
            coupled_elements.emplace(elem_node_neighbor, null_mat);
        }
      }
    }
}

bool
GhostAllPointNeighbors::operator>=(const RelationshipManager & other) const
{
  return dynamic_cast<const GhostAllPointNeighbors *>(&other) ||
         dynamic_cast<const GhostLowerDElems *>(&other) ||
         dynamic_cast<const GhostHigherDLowerDPointNeighbors *>(&other);
}

std::unique_ptr<GhostingFunctor>
GhostAllPointNeighbors::clone() const
{
  return _app.getFactory().copyConstruct(*this);
}