INSFVRhieChowInterpolator.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 "RhieChowInterpolatorBase.h"
#include "CellCenteredMapFunctor.h"
#include "VectorComponentFunctor.h"
#include "VectorCompositeFunctor.h"
 
#include <unordered_map>
#include <set>
#include <unordered_set>
 
class MooseMesh;
class INSFVVelocityVariable;
class INSFVPressureVariable;
namespace libMesh
{
class Elem;
class MeshBase;
}
 
class INSFVRhieChowInterpolator : public RhieChowInterpolatorBase
{
public:
  static InputParameters uniqueParams();
 
  static std::vector<std::string> listOfCommonParams();
 
  static InputParameters validParams();
  INSFVRhieChowInterpolator(const InputParameters & params);
 
  virtual void
  addToA(const libMesh::Elem * elem, unsigned int component, const ADReal & value) override;
 
  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 override;
 
  virtual void initialSetup() override;
  virtual void meshChanged() override;
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
 
  virtual bool segregated() const override { return false; };
 
  virtual void ghostADataOnBoundary(const BoundaryID boundary_id) override;
 
  void pullAllNonlocal() { _pull_all_nonlocal = true; }
 
  bool velocitySkewCorrection(THREAD_ID tid) const;
 
  bool pressureSkewCorrection(THREAD_ID tid) const;
 
protected:
  void insfvSetup();
 
  std::vector<std::unique_ptr<PiecewiseByBlockLambdaFunctor<ADRealVectorValue>>> _vel;
 
  std::vector<MooseVariableField<Real> *> _disp_xs;
 
  std::vector<MooseVariableField<Real> *> _disp_ys;
 
  std::vector<MooseVariableField<Real> *> _disp_zs;
 
  std::vector<std::unique_ptr<Moose::VectorCompositeFunctor<ADReal>>> _disps;
 
  std::unique_ptr<ConstElemRange> _elem_range;
 
  CellCenteredMapFunctor<ADRealVectorValue, std::unordered_map<dof_id_type, ADRealVectorValue>> _a;
 
  Moose::VectorComponentFunctor<ADReal> _ax;
 
  Moose::VectorComponentFunctor<ADReal> _ay;
 
  Moose::VectorComponentFunctor<ADReal> _az;
 
  const unsigned int _momentum_sys_number;
 
private:
  void fillARead();
 
  bool needAComputation() const;
 
  std::unordered_set<const Elem *> _elements_to_push_pull;
 
  const VectorValue<ADReal> _example;
 
  Threads::spin_mutex _a_mutex;
 
  std::vector<const Moose::FunctorBase<VectorValue<ADReal>> *> _a_read;
 
  std::vector<std::unique_ptr<Moose::FunctorBase<VectorValue<ADReal>>>> _a_aux;
 
  bool _a_data_provided;
 
  bool _pull_all_nonlocal;
 
  const bool & _bool_correct_vf;
 
  const MooseEnum _volume_force_correction_method;
 
  const std::vector<MooseFunctorName> * _volumetric_force_functors;
 
  std::vector<const Moose::Functor<Real> *> _volumetric_force;
 
  Real _baseline_volume_force;
 
  const Moose::ConstantFunctor<ADReal> _zero_functor{0};
};
 
inline void
INSFVRhieChowInterpolator::addToA(const Elem * const elem,
                                  const unsigned int component,
                                  const ADReal & value)
{
  Threads::spin_mutex::scoped_lock lock(_a_mutex);
 
  if (elem->processor_id() != this->processor_id())
    _elements_to_push_pull.insert(elem);
 
  _a[elem->id()](component) += value;
}
 
inline bool
INSFVRhieChowInterpolator::needAComputation() const
{
  // We dont check for "a"s being in another nonlinear system here, only being auxiliary
  return !_a_data_provided && _velocity_interp_method == Moose::FV::InterpMethod::RhieChow;
}
 
inline bool
INSFVRhieChowInterpolator::velocitySkewCorrection(const THREAD_ID tid) const
{
  const auto * const u = _us[tid];
  return (u->faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage);
}
 
inline bool
INSFVRhieChowInterpolator::pressureSkewCorrection(const THREAD_ID tid) const
{
  const auto * const p = _ps[tid];
  return (p->faceInterpolationMethod() == Moose::FV::InterpMethod::SkewCorrectedAverage);
}