Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "GhostingUserObject.h"
      11             : #include "NonlinearSystemBase.h"
      12             : #include "MooseMesh.h"
      13             : 
      14             : registerMooseObject("MooseApp", GhostingUserObject);
      15             : 
      16             : namespace
      17             : {
      18             : constexpr unsigned int GEOMETRIC_MAP_IDX = 0;
      19             : constexpr unsigned int ALGEBRAIC_MAP_IDX = 1;
      20             : }
      21             : 
      22             : InputParameters
      23       14463 : GhostingUserObject::validParams()
      24             : {
      25       14463 :   InputParameters params = GeneralUserObject::validParams();
      26             : 
      27       14463 :   params.addParam<std::vector<processor_id_type>>("pids", "The PID(s) to see the ghosting for");
      28             : 
      29             :   // No need to set or override this flag, this object is triggered by meshChanged events
      30       28926 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL};
      31             : 
      32       14463 :   params.addClassDescription("Creates ghosting maps that can be queried by external objects.");
      33       14463 :   return params;
      34       14463 : }
      35             : 
      36          99 : GhostingUserObject::GhostingUserObject(const InputParameters & parameters)
      37             :   : GeneralUserObject(parameters),
      38          99 :     _mesh(_subproblem.mesh()),
      39         198 :     _nl(_fe_problem.getNonlinearSystemBase(_sys.number()))
      40             : {
      41          99 :   _maps.resize(2); // Geometric and Algebraic maps
      42             : 
      43          99 :   if (parameters.isParamValid("pids"))
      44           0 :     _pids = getParam<std::vector<processor_id_type>>("pids");
      45             :   else
      46             :   {
      47             :     // If a PIDs vector is not passed, generate patterns for all processors
      48          99 :     _pids.resize(_app.n_processors());
      49          99 :     std::iota(_pids.begin(), _pids.end(), 0);
      50             :   }
      51          99 : }
      52             : 
      53             : void
      54          99 : GhostingUserObject::initialSetup()
      55             : {
      56          99 :   meshChanged();
      57          99 : }
      58             : 
      59             : void
      60          99 : GhostingUserObject::meshChanged()
      61             : {
      62             :   // Clear the maps before rebuilding
      63         297 :   for (auto & map_ref : _maps)
      64         198 :     for (auto pid_map_pair : map_ref)
      65           0 :       pid_map_pair.second.clear();
      66             : 
      67         492 :   for (auto pid : _pids)
      68             :   {
      69         393 :     auto begin_elem = _mesh.getMesh().active_pid_elements_begin(pid);
      70         393 :     const auto end_elem = _mesh.getMesh().active_pid_elements_end(pid);
      71             : 
      72             :     // Loop over all the geometric ghosting functors and build up a map of elements that are ghosted
      73             :     // for each PID
      74         393 :     libMesh::GhostingFunctor::map_type geometric_elems;
      75         786 :     for (auto & gf : as_range(_mesh.getMesh().ghosting_functors_begin(),
      76        3665 :                               _mesh.getMesh().ghosting_functors_end()))
      77        2486 :       (*gf)(begin_elem, end_elem, pid, geometric_elems);
      78         393 :     _maps[GEOMETRIC_MAP_IDX].emplace(pid, geometric_elems);
      79             : 
      80             :     // Loop over all the algebraic ghosting functors and build up a map of elements that are ghosted
      81             :     // for each PID
      82         393 :     libMesh::GhostingFunctor::map_type algebraic_elems;
      83         786 :     for (auto & gf : as_range(_nl.dofMap().algebraic_ghosting_functors_begin(),
      84        1837 :                               _nl.dofMap().algebraic_ghosting_functors_end()))
      85         658 :       (*gf)(begin_elem, end_elem, pid, algebraic_elems);
      86         393 :     for (auto & gf :
      87        1563 :          as_range(_nl.dofMap().coupling_functors_begin(), _nl.dofMap().coupling_functors_end()))
      88         777 :       (*gf)(begin_elem, end_elem, pid, algebraic_elems);
      89         393 :     _maps[ALGEBRAIC_MAP_IDX].emplace(pid, algebraic_elems);
      90         393 :   }
      91          99 : }
      92             : 
      93             : Real
      94       25712 : GhostingUserObject::getElementalValue(const Elem * elem,
      95             :                                       Moose::RelationshipManagerType rm_type,
      96             :                                       processor_id_type pid) const
      97             : {
      98       25712 :   unsigned int map_idx = (rm_type == Moose::RelationshipManagerType::GEOMETRIC ? GEOMETRIC_MAP_IDX
      99             :                                                                                : ALGEBRAIC_MAP_IDX);
     100             : 
     101       25712 :   auto map_it = _maps[map_idx].find(pid);
     102       25712 :   if (map_it == _maps[map_idx].end())
     103           0 :     mooseError("No entry in the ghosting map for processor ID: ", pid);
     104             : 
     105       25712 :   auto map_ref = map_it->second;
     106       25712 :   if (map_ref.find(elem) != map_ref.end())
     107        3130 :     return 1.;
     108             :   else
     109       22582 :     return 0.;
     110       25712 : }