RhieChowInterpolatorBase.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 "RhieChowFaceFluxProvider.h"
#include "TaggingInterface.h"
#include "INSFVPressureVariable.h"
#include "ADReal.h"
#include "ADFunctorInterface.h"
#include "INSFVPressureVariable.h"
#include "libmesh/vector_value.h"
#include "libmesh/id_types.h"
#include "libmesh/stored_range.h"

class MooseMesh;
class INSFVVelocityVariable;
class INSFVPressureVariable;
namespace libMesh
{
class Elem;
class MeshBase;
}

class RhieChowInterpolatorBase : public RhieChowFaceFluxProvider,
                                 public TaggingInterface,
                                 public ADFunctorInterface
{
public:
  static InputParameters validParams();
  RhieChowInterpolatorBase(const InputParameters & params);

  virtual void addToA(const libMesh::Elem * elem, unsigned int component, const ADReal & value) = 0;

  virtual VectorValue<ADReal> getVelocity(const Moose::FV::InterpMethod m,
                                          const FaceInfo & fi,
                                          const Moose::StateArg & time,
                                          const THREAD_ID tid,
                                          bool subtract_mesh_velocity) const = 0;

  virtual Real getVolumetricFaceFlux(const Moose::FV::InterpMethod m,
                                     const FaceInfo & fi,
                                     const Moose::StateArg & time,
                                     const THREAD_ID tid,
                                     bool subtract_mesh_velocity) const override;

  Moose::FV::InterpMethod velocityInterpolationMethod() const { return _velocity_interp_method; }

  virtual void ghostADataOnBoundary(const BoundaryID /*boundary_id*/) {}

  const INSFVPressureVariable & pressure(THREAD_ID tid) const;

  const INSFVVelocityVariable * vel() const { return _u; }

  virtual bool segregated() const = 0;

protected:
  virtual const Moose::FunctorBase<ADReal> & epsilon(THREAD_ID tid) const;

  template <typename Container>
  void fillContainer(const std::string & var_name, Container & container);

  template <typename VarType>
  void checkBlocks(const VarType & var) const;

  MooseMesh & _moose_mesh;

  const libMesh::MeshBase & _mesh;

  const unsigned int _dim;

  INSFVPressureVariable * const _p;

  INSFVVelocityVariable * const _u;

  INSFVVelocityVariable * const _v;

  INSFVVelocityVariable * const _w;

  std::vector<MooseVariableFVReal *> _ps;

  std::vector<MooseVariableFVReal *> _us;

  std::vector<MooseVariableFVReal *> _vs;

  std::vector<MooseVariableFVReal *> _ws;

  std::vector<unsigned int> _var_numbers;

  SystemBase & _sys;

  Moose::FV::InterpMethod _velocity_interp_method;

  const bool _displaced;

private:
  const Moose::ConstantFunctor<ADReal> _unity_functor{1};
};

inline const Moose::FunctorBase<ADReal> &
RhieChowInterpolatorBase::epsilon(THREAD_ID) const
{
  return _unity_functor;
}

inline const INSFVPressureVariable &
RhieChowInterpolatorBase::pressure(const THREAD_ID tid) const
{
  mooseAssert(tid < _ps.size(), "Attempt to access out-of-bounds in pressure variable container");
  return *static_cast<INSFVPressureVariable *>(_ps[tid]);
}

template <typename Container>
void
RhieChowInterpolatorBase::fillContainer(const std::string & name, Container & container)
{
  typedef typename Container::value_type ContainedType;
  for (const auto tid : make_range(libMesh::n_threads()))
  {
    auto * const var = static_cast<ContainedType>(
        &UserObject::_subproblem.getVariable(tid, getParam<VariableName>(name)));
    container[tid] = var;
  }
}

template <typename VarType>
void
RhieChowInterpolatorBase::checkBlocks(const VarType & var) const
{
  const auto & var_blocks = var.blockIDs();
  const auto & uo_blocks = blockIDs();

  // Error if this UO has any blocks that the variable does not
  std::set<SubdomainID> uo_blocks_minus_var_blocks;
  std::set_difference(uo_blocks.begin(),
                      uo_blocks.end(),
                      var_blocks.begin(),
                      var_blocks.end(),
                      std::inserter(uo_blocks_minus_var_blocks, uo_blocks_minus_var_blocks.end()));
  if (uo_blocks_minus_var_blocks.size() > 0)
    mooseError("Block restriction of interpolator user object '",
               this->name(),
               "' (",
               Moose::stringify(blocks()),
               ") includes blocks not in the block restriction of variable '",
               var.name(),
               "' (",
               Moose::stringify(var.blocks()),
               ")");

  // Get the blocks in the variable but not this UO
  std::set<SubdomainID> var_blocks_minus_uo_blocks;
  std::set_difference(var_blocks.begin(),
                      var_blocks.end(),
                      uo_blocks.begin(),
                      uo_blocks.end(),
                      std::inserter(var_blocks_minus_uo_blocks, var_blocks_minus_uo_blocks.end()));

  // For each block in the variable but not this UO, error if there is connection
  // to any blocks on the UO.
  for (auto & block_id : var_blocks_minus_uo_blocks)
  {
    const auto connected_blocks = _moose_mesh.getBlockConnectedBlocks(block_id);
    std::set<SubdomainID> connected_blocks_on_uo;
    std::set_intersection(connected_blocks.begin(),
                          connected_blocks.end(),
                          uo_blocks.begin(),
                          uo_blocks.end(),
                          std::inserter(connected_blocks_on_uo, connected_blocks_on_uo.end()));
    if (connected_blocks_on_uo.size() > 0)
      mooseError("Block restriction of interpolator user object '",
                 this->name(),
                 "' (",
                 Moose::stringify(uo_blocks),
                 ") doesn't match the block restriction of variable '",
                 var.name(),
                 "' (",
                 Moose::stringify(var_blocks),
                 ")");
  }
}