FVUtils.h

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
 
#pragma once
 
#include "MooseMesh.h"
#include "MooseError.h"
#include "MooseMeshUtils.h"
#include "FaceInfo.h"
#include "libmesh/elem.h"
 
#include <tuple>
 
template <typename>
class MooseVariableFV;
 
template <typename>
class MooseLinearVariableFV;
 
namespace Moose
{
namespace FV
{
 
bool elemHasFaceInfo(const Elem & elem, const Elem * const neighbor);
 
template <typename ActionFunctor>
void
loopOverElemFaceInfo(const Elem & elem,
                     const MooseMesh & mesh,
                     ActionFunctor & act,
                     const Moose::CoordinateSystemType coord_type,
                     const unsigned int rz_radial_coord = libMesh::invalid_uint)
{
  mooseAssert(elem.active(), "We should never call this method with an inactive element");
 
  for (const auto side : elem.side_index_range())
  {
    const Elem * const candidate_neighbor = elem.neighbor_ptr(side);
 
    bool elem_has_info = elemHasFaceInfo(elem, candidate_neighbor);
 
    std::set<const Elem *> neighbors;
 
    const bool inactive_neighbor_detected =
        candidate_neighbor ? !candidate_neighbor->active() : false;
 
    // See MooseMesh::buildFaceInfo for corresponding checks/additions of FaceInfo
    if (inactive_neighbor_detected)
    {
      // We must be next to an element that has been refined
      mooseAssert(candidate_neighbor->has_children(), "We should have children");
 
      const auto candidate_neighbor_side = candidate_neighbor->which_neighbor_am_i(&elem);
 
      for (const auto child_num : make_range(candidate_neighbor->n_children()))
        if (candidate_neighbor->is_child_on_side(child_num, candidate_neighbor_side))
        {
          const Elem * const child = candidate_neighbor->child_ptr(child_num);
          mooseAssert(child->level() - elem.level() == 1, "The math doesn't work out here.");
          mooseAssert(child->has_neighbor(&elem), "Elem should be a neighbor of this child.");
          mooseAssert(child->active(),
                      "We shouldn't have greater than a face mismatch level of one");
          neighbors.insert(child);
        }
    }
    else
      neighbors.insert(candidate_neighbor);
 
    for (const Elem * const neighbor : neighbors)
    {
      const FaceInfo * const fi =
          elem_has_info ? mesh.faceInfo(&elem, side)
                        : mesh.faceInfo(neighbor, neighbor->which_neighbor_am_i(&elem));
 
      mooseAssert(fi, "We should have found a FaceInfo");
      mooseAssert(elem_has_info ? &elem == &fi->elem() : &elem == fi->neighborPtr(),
                  "Doesn't seem like we understand how this FaceInfo thing is working");
      if (neighbor)
      {
        mooseAssert(neighbor != libMesh::remote_elem,
                    "Remote element detected. This indicates that you have insufficient geometric "
                    "ghosting. Please contact your application developers.");
        mooseAssert(elem_has_info ? neighbor == fi->neighborPtr() : neighbor == &fi->elem(),
                    "Doesn't seem like we understand how this FaceInfo thing is working");
      }
 
      const Point elem_normal = elem_has_info ? fi->normal() : Point(-fi->normal());
 
      Real coord;
      MooseMeshUtils::coordTransformFactor(fi->faceCentroid(), coord, coord_type, rz_radial_coord);
 
      const Point surface_vector = elem_normal * fi->faceArea() * coord;
 
      act(elem, neighbor, fi, surface_vector, coord, elem_has_info);
    }
  }
}
 
template <typename FVVar>
std::tuple<const Elem *, const Elem *, bool>
determineElemOneAndTwo(const FaceInfo & fi, const FVVar & var)
{
  auto ft = fi.faceType(std::make_pair(var.number(), var.sys().number()));
  mooseAssert(ft == FaceInfo::VarFaceNeighbors::BOTH
                  ? var.hasBlocks(fi.elem().subdomain_id()) && fi.neighborPtr() &&
                        var.hasBlocks(fi.neighborPtr()->subdomain_id())
                  : true,
              "Finite volume variable " << var.name()
                                        << " does not exist on both sides of the face despite "
                                           "what the FaceInfo is telling us.");
  mooseAssert(ft == FaceInfo::VarFaceNeighbors::ELEM
                  ? var.hasBlocks(fi.elem().subdomain_id()) &&
                        (!fi.neighborPtr() || !var.hasBlocks(fi.neighborPtr()->subdomain_id()))
                  : true,
              "Finite volume variable " << var.name()
                                        << " does not exist on or only on the elem side of the "
                                           "face despite what the FaceInfo is telling us.");
  mooseAssert(ft == FaceInfo::VarFaceNeighbors::NEIGHBOR
                  ? fi.neighborPtr() && var.hasBlocks(fi.neighborPtr()->subdomain_id()) &&
                        !var.hasBlocks(fi.elem().subdomain_id())
                  : true,
              "Finite volume variable " << var.name()
                                        << " does not exist on or only on the neighbor side of the "
                                           "face despite what the FaceInfo is telling us.");
 
  const bool one_is_elem =
      ft == FaceInfo::VarFaceNeighbors::BOTH || ft == FaceInfo::VarFaceNeighbors::ELEM;
  const Elem * const elem_one = one_is_elem ? &fi.elem() : fi.neighborPtr();
  mooseAssert(elem_one, "This elem should be non-null!");
  const Elem * const elem_two = one_is_elem ? fi.neighborPtr() : &fi.elem();
 
  return std::make_tuple(elem_one, elem_two, one_is_elem);
}
}
}