MooseFunctorArguments.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 <tuple>
 
#include "Limiter.h"
#include "FaceInfo.h"
#include "MooseTypes.h"
#include "libmesh/elem.h"
#include "libmesh/point.h"
#include "libmesh/quadrature.h"
 
#include <set>
 
namespace Moose
{
struct ElemArg
{
  const libMesh::Elem * elem;
  bool correct_skewness;
 
  Point getPoint() const { return elem->vertex_average(); }
 
  friend bool operator<(const ElemArg & l, const ElemArg & r)
  {
    return std::make_tuple(l.elem, l.correct_skewness) <
           std::make_tuple(r.elem, r.correct_skewness);
  }
};
 
struct ElemPointArg
{
  const libMesh::Elem * elem;
  libMesh::Point point;
  bool correct_skewness;
 
  Point getPoint() const { return point; }
 
  friend bool operator<(const ElemPointArg & l, const ElemPointArg & r)
  {
    return std::make_tuple(l.elem, l.point, l.correct_skewness) <
           std::make_tuple(r.elem, r.point, r.correct_skewness);
  }
 
  ElemArg makeElem() const { return {elem, correct_skewness}; }
};
 
struct ElemSideQpArg
{
  const libMesh::Elem * elem;
 
  unsigned int side;
 
  unsigned int qp;
 
  const libMesh::QBase * qrule;
 
  Point point;
 
  Point getPoint() const { return point; }
};
 
struct StateArg
{
  StateArg(bool) = delete;
 
  StateArg(unsigned int state_in) : state(state_in), iteration_type(SolutionIterationType::Time) {}
 
  StateArg(unsigned int state_in, SolutionIterationType iteration_type_in)
    : state(state_in), iteration_type(iteration_type_in)
  {
  }
 
  bool operator==(const StateArg & other) const
  {
    return state == other.state && iteration_type == other.iteration_type;
  }
 
  unsigned int state;
 
  SolutionIterationType iteration_type;
 
private:
  StateArg() : state(0), iteration_type(SolutionIterationType::Time) {}
 
  friend StateArg currentState();
};
 
inline StateArg
currentState()
{
  return {};
}
 
inline StateArg
oldState()
{
  return {(unsigned int)1};
}
 
inline StateArg
previousNonlinearState()
{
  return {(unsigned int)1, SolutionIterationType::Nonlinear};
}
 
inline StateArg
previousMultiAppFixedPointState()
{
  return {(unsigned int)1, SolutionIterationType::MultiAppFixedPoint};
}
 
inline StateArg
previousMultiSystemFixedPointState()
{
  return {(unsigned int)1, SolutionIterationType::MultiSystemFixedPoint};
}
 
struct FaceArg
{
  const FaceInfo * fi;
 
  Moose::FV::LimiterType limiter_type;
 
  bool elem_is_upwind;
 
  bool correct_skewness;
 
  const libMesh::Elem * face_side;
 
  const Moose::StateArg * state_limiter;
 
  libMesh::Point getPoint() const { return fi->faceCentroid(); }
 
  ElemArg makeElem() const { return {&fi->elem(), correct_skewness}; }
 
  ElemArg makeNeighbor() const { return {fi->neighborPtr(), correct_skewness}; }
 
  friend bool operator<(const FaceArg & l, const FaceArg & r)
  {
    return std::make_tuple(
               l.fi, l.limiter_type, l.elem_is_upwind, l.correct_skewness, l.face_side) <
           std::make_tuple(r.fi, r.limiter_type, r.elem_is_upwind, r.correct_skewness, r.face_side);
  }
};
 
struct NodeArg
{
  const libMesh::Node * node;
 
  const std::set<SubdomainID> * subdomain_ids;
 
  libMesh::Point getPoint() const { return *node; }
 
  static const std::set<SubdomainID> undefined_subdomain_connection;
 
  friend bool operator<(const NodeArg & l, const NodeArg & r)
  {
    return std::make_tuple(l.node, l.subdomain_ids) < std::make_tuple(r.node, r.subdomain_ids);
  }
};
 
struct ElemQpArg
{
  const libMesh::Elem * elem;
 
  unsigned int qp;
 
  const libMesh::QBase * qrule;
 
  libMesh::Point point;
 
  libMesh::Point getPoint() const { return point; }
 
  friend bool operator<(const ElemQpArg & l, const ElemQpArg & r)
  {
    return std::make_tuple(l.elem, l.qp, l.qrule, l.point) <
           std::make_tuple(r.elem, r.qp, r.qrule, r.point);
  }
};
}