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();
}