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
previousFixedPointState()
{
  return {(unsigned int)1, SolutionIterationType::FixedPoint};
}

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

struct ElemQpArg
{
  const libMesh::Elem * elem;

  unsigned int qp;

  const libMesh::QBase * qrule;

  libMesh::Point point;

  libMesh::Point getPoint() const { return point; }
};
}