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