WCNSFVFlowPhysicsBase.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 "NavierStokesPhysicsBase.h"
#include "WCNSFVTurbulencePhysicsBase.h"
 
#define registerWCNSFVFlowPhysicsBaseTasks(app_name, derived_name)                                 \
  registerPhysicsBaseTasks(app_name, derived_name);                                                \
  registerMooseAction(app_name, derived_name, "add_geometric_rm");                                 \
  registerMooseAction(app_name, derived_name, "add_variables_physics");                            \
  registerMooseAction(app_name, derived_name, "add_ics_physics");                                  \
  registerMooseAction(app_name, derived_name, "add_materials_physics");                            \
  registerMooseAction(app_name, derived_name, "add_user_object");                                  \
  registerMooseAction(app_name, derived_name, "add_postprocessor");                                \
  registerMooseAction(app_name, derived_name, "add_corrector");                                    \
  registerMooseAction(app_name, derived_name, "get_turbulence_physics")
 
class WCNSFVFlowPhysicsBase : public NavierStokesPhysicsBase
{
public:
  static InputParameters validParams();
 
  WCNSFVFlowPhysicsBase(const InputParameters & parameters);
 
  bool hasFlowEquations() const { return _has_flow_equations; }
  bool addAxisymmetricViscousSourceEnabled() const { return _add_rz_viscous_source; }
  bool includeSymmetrizedViscousStress() const { return _include_symmetrized_viscous_stress; }
  bool includeIsotropicStress() const { return _include_isotropic_viscous_stress; }
 
  const std::vector<std::string> & getVelocityNames() const { return _velocity_names; }
  const NonlinearVariableName & getPressureName() const { return _pressure_name; }
  const NonlinearVariableName & getFluidTemperatureName() const { return _fluid_temperature_name; }
  MooseFunctorName getPorosityFunctorName(const bool smoothed) const;
 
  // Getters to interact with other WCNSFVPhysics classes
  const MooseEnum & compressibility() const { return _compressibility; }
  bool porousMediumTreatment() const { return _porous_medium_treatment; }
  RealVectorValue gravityVector() const { return getParam<RealVectorValue>("gravity"); }
  const MooseFunctorName & densityName() const { return _density_name; }
  const MooseFunctorName & dynamicViscosityName() const { return _dynamic_viscosity_name; }
  const MooseEnum & getVelocityFaceInterpolationMethod() const { return _velocity_interpolation; }
  const MooseEnum & getMomentumAdvectionFaceInterpolationMethod() const
  {
    return _momentum_advection_interpolation;
  }
  const MooseEnum & getMomentumFaceInterpolationMethod() const
  {
    return _momentum_face_interpolation;
  }
  const std::vector<BoundaryName> & getInletBoundaries() const { return _inlet_boundaries; }
  const std::vector<BoundaryName> & getOutletBoundaries() const { return _outlet_boundaries; }
  const std::vector<BoundaryName> & getWallBoundaries() const { return _wall_boundaries; }
  const std::vector<BoundaryName> & getHydraulicSeparators() const { return _hydraulic_separators; }
  NS::MomentumInletTypes inletBoundaryType(const BoundaryName & boundary_name) const
  {
    return NS::MomentumInletTypes(
        static_cast<int>(libmesh_map_find(_momentum_inlet_types, boundary_name)));
  }
  const std::vector<Point> & getFluxInletDirections() const { return _flux_inlet_directions; }
  const std::vector<PostprocessorName> & getFluxInletPPs() const { return _flux_inlet_pps; }
  virtual MooseFunctorName getLinearFrictionCoefName() const = 0;
  const UserObjectName & rhieChowUOName() const;
  unsigned short getNumberAlgebraicGhostingLayersNeeded() const override;
 
protected:
  virtual void initializePhysicsAdditional() override;
  virtual void actOnAdditionalTasks() override;
  virtual void addSolverVariables() override = 0;
  virtual void addInitialConditions() override;
  virtual void addFVKernels() override = 0;
  virtual void addFVBCs() override;
  virtual void addMaterials() override;
  virtual void addUserObjects() override = 0;
  virtual void addPostprocessors() override;
 
  virtual void addMomentumTimeKernels() = 0;
  virtual void addMomentumPressureKernels() = 0;
  virtual void addMomentumGravityKernels() = 0;
  virtual void addMomentumFrictionKernels() = 0;
  virtual void addMomentumBoussinesqKernels() = 0;
  void addAxisymmetricViscousSource();
  virtual void addAxisymmetricViscousSourceKernel(const std::vector<SubdomainName> & /*rz_blocks*/,
                                                  unsigned int /*radial_index*/)
  {
  }
 
  virtual void addInletBC() = 0;
  virtual void addOutletBC() = 0;
  virtual void addWallsBC() = 0;
  virtual void addSeparatorBC() = 0;
 
  virtual bool hasForchheimerFriction() const = 0;
 
  void addPorousMediumSpeedMaterial();
  void addNonPorousMediumSpeedMaterial();
  void addFluidPropertiesFunctorMaterial();
 
  virtual void addRhieChowUserObjects() = 0;
 
  VariableName getFlowVariableName(const std::string & default_name) const;
 
  bool hasTurbulencePhysics() const
  {
    if (_turbulence_physics)
      return _turbulence_physics->hasTurbulenceModel();
    else
      return false;
  }
 
  const WCNSFVTurbulencePhysicsBase * getCoupledTurbulencePhysics() const;
 
  std::vector<SubdomainName> getAxisymmetricRZBlocks() const;
 
  const TagName _pressure_tag = "p_tag";
 
  const bool _has_flow_equations;
  const bool _add_rz_viscous_source;
 
  const MooseEnum _compressibility;
  const bool _solve_for_dynamic_pressure;
 
  const bool _porous_medium_treatment;
  const MooseFunctorName _porosity_name;
  MooseFunctorName _flow_porosity_functor_name;
 
  const std::vector<std::string> _velocity_names;
  const NonlinearVariableName _pressure_name;
  const NonlinearVariableName _fluid_temperature_name;
 
  const MooseFunctorName _density_name;
  const MooseFunctorName _density_gravity_name;
  const MooseFunctorName _dynamic_viscosity_name;
  const bool _include_symmetrized_viscous_stress;
  const bool _include_isotropic_viscous_stress;
 
  UserObjectName _rc_uo_name;
  const MooseEnum _velocity_interpolation;
  const MooseEnum _momentum_advection_interpolation;
  const MooseEnum _momentum_face_interpolation;
 
  const WCNSFVTurbulencePhysicsBase * _turbulence_physics;
 
  std::vector<std::vector<SubdomainName>> _friction_blocks;
  std::vector<std::vector<std::string>> _friction_types;
  std::vector<std::vector<std::string>> _friction_coeffs;
 
  const std::vector<BoundaryName> _inlet_boundaries;
  const std::vector<BoundaryName> _outlet_boundaries;
  const std::vector<BoundaryName> _wall_boundaries;
  const std::vector<BoundaryName> _hydraulic_separators;
 
  std::map<BoundaryName, MooseEnum> _momentum_inlet_types;
  std::map<BoundaryName, MooseEnum> _momentum_outlet_types;
  std::map<BoundaryName, MooseEnum> _momentum_wall_types;
 
  std::vector<PostprocessorName> _flux_inlet_pps;
  std::vector<Point> _flux_inlet_directions;
 
  std::map<BoundaryName, std::vector<MooseFunctorName>> _momentum_inlet_functors;
  std::map<BoundaryName, MooseFunctorName> _pressure_functors;
  std::map<BoundaryName, std::vector<MooseFunctorName>> _momentum_wall_functors;
 
  friend class WCNSFVTurbulencePhysics;
};