ProxyRelationshipManager.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 "ProxyRelationshipManager.h"
#include "MooseApp.h"

#include "libmesh/system.h"
#include "libmesh/elem.h"
#include "libmesh/dof_map.h"

using namespace libMesh;

registerMooseObject("MooseApp", ProxyRelationshipManager);

InputParameters
ProxyRelationshipManager::validParams()
{
  InputParameters params = RelationshipManager::validParams();

  params.addRequiredParam<System *>("other_system",
                                    "The libMesh system to mirror the ghosting from");

  return params;
}

ProxyRelationshipManager::ProxyRelationshipManager(const InputParameters & parameters)
  : RelationshipManager(parameters), _other_system(getCheckedPointerParam<System *>("other_system"))
{
}

ProxyRelationshipManager::ProxyRelationshipManager(const ProxyRelationshipManager & others)
  : RelationshipManager(others), _other_system(others._other_system)
{
}

void
ProxyRelationshipManager::operator()(const MeshBase::const_element_iterator & /*range_begin*/,
                                     const MeshBase::const_element_iterator & /*range_end*/,
                                     processor_id_type p,
                                     map_type & coupled_elements)
{
  auto & other_mesh = _other_system->get_mesh();

  auto other_elements_begin = other_mesh.active_local_elements_begin();
  auto other_elements_end = other_mesh.active_local_elements_end();

  map_type other_coupled_elements;

  // If we're geometric - run all the geometric ghosting functors from the other system
  if (isType(Moose::RelationshipManagerType::GEOMETRIC))
  {
    auto gf_it = other_mesh.ghosting_functors_begin();
    const auto gf_end = other_mesh.ghosting_functors_end();

    for (; gf_it != gf_end; ++gf_it)
      if (!dynamic_cast<ProxyRelationshipManager *>(*gf_it)) // Don't recurse!
        (*(*gf_it))(other_elements_begin, other_elements_end, p, other_coupled_elements);
  }

  // If we're algebraic - run all the algebraic ghosting functors from the other system
  if (isType(Moose::RelationshipManagerType::ALGEBRAIC))
  {
    auto gf_it = _other_system->get_dof_map().algebraic_ghosting_functors_begin();
    const auto gf_end = _other_system->get_dof_map().algebraic_ghosting_functors_end();

    for (; gf_it != gf_end; ++gf_it)
      if (!dynamic_cast<ProxyRelationshipManager *>(*gf_it)) // Don't recurse!
        (*(*gf_it))(other_elements_begin, other_elements_end, p, other_coupled_elements);
  }

  // Build unique_id to elem map
  std::map<dof_id_type, const Elem *> unique_id_to_elem_map;

  for (auto elem_it = _moose_mesh->getMesh().active_elements_begin();
       elem_it != _moose_mesh->getMesh().active_elements_end();
       ++elem_it)
    unique_id_to_elem_map[(*elem_it)->unique_id()] = *elem_it;

  // Now translate those back into elements in this system
  for (auto other_coupled_it = other_coupled_elements.begin();
       other_coupled_it != other_coupled_elements.end();
       ++other_coupled_it)
  {
    auto other_system_elem = other_coupled_it->first;

    auto unique_id_to_elem_map_it = unique_id_to_elem_map.find(other_system_elem->unique_id());
    mooseAssert(unique_id_to_elem_map_it != unique_id_to_elem_map.end(), "no matching unique id");

    coupled_elements.emplace(unique_id_to_elem_map_it->second, other_coupled_it->second);
  }
}

std::string
ProxyRelationshipManager::getInfo() const
{
  std::string info = std::string("Proxy for ") + _other_system->name();

  if (useDisplacedMesh())
    info = info + " on displaced";

  return info;
}

bool
ProxyRelationshipManager::operator>=(const RelationshipManager & /*rhs*/) const
{
  // There isn't a need to determine these because only the correct ones will be added
  return false;
}

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