FaceInfo.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 "MooseTypes.h"
#include "ElemInfo.h"
#include "MooseError.h"
 
#include "libmesh/vector_value.h"
#include "libmesh/remote_elem.h"
#include "libmesh/elem_side_builder.h"
 
#include <map>
#include <set>
#include <memory>
 
class MooseMesh;
namespace libMesh
{
class Elem;
class Node;
}
 
class FaceInfo
{
public:
  FaceInfo(const ElemInfo * elem_info,
           unsigned int side,
           const dof_id_type id,
           libMesh::ElemSideBuilder & side_builder);
 
  enum class VarFaceNeighbors
  {
    BOTH,
    NEITHER,
    ELEM,
    NEIGHBOR
  };
 
  dof_id_type id() const { return _id; }
 
  Real faceArea() const { return _face_area; }
 
  Real & faceCoord() { return _face_coord; }
  Real faceCoord() const { return _face_coord; }
 
  const Point & normal() const { return _normal; }
 
  const Point & faceCentroid() const { return _face_centroid; }
 
  Point skewnessCorrectionVector() const;
 
  const Elem & elem() const { return *(_elem_info->elem()); }
  const Elem * elemPtr() const { return _elem_info->elem(); }
  const Elem & neighbor() const;
  const Elem * neighborPtr() const { return _neighbor_info ? _neighbor_info->elem() : nullptr; }
  const ElemInfo * elemInfo() const { return _elem_info; }
  const ElemInfo * neighborInfo() const { return _neighbor_info; }
 
  const Point & elemCentroid() const { return _elem_info->centroid(); }
  const Point & neighborCentroid() const;
 
  SubdomainID elemSubdomainID() const { return _elem_info->subdomain_id(); }
  SubdomainID neighborSubdomainID() const;
 
  unsigned int elemSideID() const { return _elem_side_id; }
  unsigned int neighborSideID() const { return _neighbor_side_id; }
 
  VarFaceNeighbors faceType(const std::pair<unsigned int, unsigned int> & var_sys) const;
  VarFaceNeighbors & faceType(const std::pair<unsigned int, unsigned int> & var_sys);
 
  const std::set<BoundaryID> & boundaryIDs() const { return _boundary_ids; }
 
  std::set<BoundaryID> & boundaryIDs() { return _boundary_ids; }
 
  Real elemVolume() const { return _elem_info->volume(); }
 
  Real neighborVolume() const;
 
  Real gC() const { return _gc; }
 
  const Point & dCN() const { return _d_cn; }
 
  Real dCNMag() const { return _d_cn_mag; }
 
  const Point & eCN() const { return _e_cn; }
 
  processor_id_type processor_id() const { return _processor_id; }
 
  void computeInternalCoefficients(const ElemInfo * const neighbor_info);
 
  void computeBoundaryCoefficients();
 
private:
  std::vector<std::vector<VarFaceNeighbors>> & faceType() { return _face_types_by_var; }
 
  const ElemInfo * const _elem_info;
  const ElemInfo * _neighbor_info;
 
  const dof_id_type _id;
 
  Real _face_coord = 0;
  Point _normal;
 
  const processor_id_type _processor_id;
 
  const unsigned int _elem_side_id;
  unsigned int _neighbor_side_id;
 
  Real _face_area;
  Point _face_centroid;
 
  Point _d_cn;
  Point _e_cn;
 
  Real _d_cn_mag;
 
  Real _gc;
 
  std::vector<std::vector<VarFaceNeighbors>> _face_types_by_var;
 
  std::set<BoundaryID> _boundary_ids;
 
  friend MooseMesh;
};
 
inline const Elem &
FaceInfo::neighbor() const
{
  mooseAssert(_neighbor_info,
              "FaceInfo object 'const Elem & neighbor()' is called but neighbor element pointer "
              "is null. This occurs for faces at the domain boundary");
  return *(_neighbor_info->elem());
}
 
inline FaceInfo::VarFaceNeighbors
FaceInfo::faceType(const std::pair<unsigned int, unsigned int> & var_sys) const
{
  mooseAssert(var_sys.second < _face_types_by_var.size(), "System number out of bounds!");
  mooseAssert(var_sys.first < _face_types_by_var[var_sys.second].size(),
              "Variable number out of bounds!");
  return _face_types_by_var[var_sys.second][var_sys.first];
}
 
inline FaceInfo::VarFaceNeighbors &
FaceInfo::faceType(const std::pair<unsigned int, unsigned int> & var_sys)
{
  mooseAssert(var_sys.second < _face_types_by_var.size(), "System number out of bounds!");
  mooseAssert(var_sys.first < _face_types_by_var[var_sys.second].size(),
              "Variable number out of bounds!");
  return _face_types_by_var[var_sys.second][var_sys.first];
}
 
inline const Point &
FaceInfo::neighborCentroid() const
{
  mooseAssert(_neighbor_info,
              "The neighbor is not defined on this faceInfo! A possible explanation is that the "
              "face is a (physical/processor) boundary face.");
  return _neighbor_info->centroid();
}
 
inline SubdomainID
FaceInfo::neighborSubdomainID() const
{
  return _neighbor_info ? _neighbor_info->subdomain_id() : Moose::INVALID_BLOCK_ID;
}
 
inline Real
FaceInfo::neighborVolume() const
{
  mooseAssert(_neighbor_info,
              "The neighbor is not defined on this faceInfo! A possible explanation is that the "
              "face is a (physical/processor) boundary face.");
  return _neighbor_info->volume();
}