INSFVRhieChowInterpolatorSegregated.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 "FaceCenteredMapFunctor.h"
#include "VectorComponentFunctor.h"
#include <unordered_map>
#include <set>
#include <unordered_set>

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

class INSFVRhieChowInterpolatorSegregated : public RhieChowInterpolatorBase
{
public:
  static InputParameters validParams();
  INSFVRhieChowInterpolatorSegregated(const InputParameters & params);

  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;

  void initFaceVelocities();
  void computeFaceVelocity();
  void computeCellVelocity();

  void addToA(const libMesh::Elem * /*elem*/,
              unsigned int /*component*/,
              const ADReal & /*value*/) override
  {
    mooseError(
        "addToA function is not implemented for the RhieChow interpolation in segregated solvers.");
  }

  void meshChanged() override;
  void initialize() override;
  void execute() override {}
  void finalize() override {}

  bool segregated() const override { return true; };

  void linkMomentumSystem(std::vector<NonlinearSystemBase *> momentum_systems,
                          const std::vector<unsigned int> & momentum_system_numbers,
                          const TagID pressure_gradient_tag);

  void computeHbyA(bool verbose);

protected:
  void populateHbyA(const std::vector<std::unique_ptr<NumericVector<Number>>> & raw_hbya,
                    const std::vector<unsigned int> & var_nums);
  FaceCenteredMapFunctor<RealVectorValue, std::unordered_map<dof_id_type, RealVectorValue>> _HbyA;

  std::vector<std::unique_ptr<NumericVector<Number>>> _HbyA_raw;

  CellCenteredMapFunctor<RealVectorValue, std::unordered_map<dof_id_type, RealVectorValue>> _Ainv;

  std::unique_ptr<PiecewiseByBlockLambdaFunctor<ADRealVectorValue>> _vel;

  FaceCenteredMapFunctor<RealVectorValue, std::unordered_map<dof_id_type, RealVectorValue>>
      _face_velocity;

  std::vector<NonlinearSystemBase *> _momentum_systems;

  std::vector<unsigned int> _momentum_system_numbers;

  std::vector<libMesh::NonlinearImplicitSystem *> _momentum_implicit_systems;

  TagID _pressure_gradient_tag;
};