PorousFlowActionBase.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 "Action.h"
#include "PorousFlowDependencies.h"
#include "MooseEnum.h"
 
#include "libmesh/vector_value.h"
 
class PorousFlowActionBase : public Action, public PorousFlowDependencies
{
public:
  static InputParameters validParams();
 
  PorousFlowActionBase(const InputParameters & params);
 
  virtual void act() override;
 
  using Action::addRelationshipManagers;
  virtual void addRelationshipManagers(Moose::RelationshipManagerType when_type) override;
 
protected:
  std::vector<std::string> _included_objects;
 
  const std::string _dictator_name;
 
  std::vector<SubdomainName> _subdomain_names;
 
  const bool _subdomain_names_set;
 
  const unsigned int _num_aqueous_equilibrium;
 
  const unsigned int _num_aqueous_kinetic;
 
  const RealVectorValue _gravity;
 
  const std::vector<VariableName> _mass_fraction_vars;
 
  const unsigned _num_mass_fraction_vars;
 
  const std::vector<VariableName> _temperature_var;
 
  const std::vector<VariableName> & _displacements;
 
  const unsigned _ndisp;
 
  std::vector<VariableName> _coupled_displacements;
 
  const MooseEnum _flux_limiter_type;
 
  const enum class StabilizationEnum { None, Full, KT } _stabilization;
 
  const bool _strain_at_nearest_qp;
 
  Moose::CoordinateSystemType _coord_system;
 
  bool _transient;
 
  virtual void addDictator() = 0;
 
  virtual void addUserObjects();
 
  virtual void addAuxObjects();
 
  virtual void addKernels();
 
  virtual void addMaterialDependencies();
 
  virtual void addMaterials();
 
  void addSaturationAux(unsigned phase);
 
  void addDarcyAux(const RealVectorValue & gravity);
 
  void addStressAux();
 
  void addTemperatureMaterial(bool at_nodes);
 
  void addMassFractionMaterial(bool at_nodes);
 
  void addEffectiveFluidPressureMaterial(bool at_nodes);
 
  void addNearestQpMaterial();
 
  void addVolumetricStrainMaterial(const std::vector<VariableName> & displacements,
                                   const std::string & base_name);
 
  void addSingleComponentFluidMaterial(bool at_nodes,
                                       unsigned phase,
                                       bool compute_density_and_viscosity,
                                       bool compute_internal_energy,
                                       bool compute_enthalpy,
                                       const UserObjectName & fp,
                                       const MooseEnum & temperature_unit,
                                       const MooseEnum & pressure_unit,
                                       const MooseEnum & time_unit);
 
  void addBrineMaterial(const VariableName xnacl,
                        bool at_nodes,
                        unsigned phase,
                        bool compute_density_and_viscosity,
                        bool compute_internal_energy,
                        bool compute_enthalpy,
                        const MooseEnum & temperature_unit);
 
  void addRelativePermeabilityConst(bool at_nodes, unsigned phase, Real kr);
 
  void
  addRelativePermeabilityCorey(bool at_nodes, unsigned phase, Real n, Real s_res, Real sum_s_res);
 
  void
  addRelativePermeabilityFLAC(bool at_nodes, unsigned phase, Real m, Real s_res, Real sum_s_res);
 
  void addCapillaryPressureVG(Real m, Real alpha, std::string userobject_name, Real sat_lr = 0.0);
 
  void addAdvectiveFluxCalculatorSaturated(unsigned phase,
                                           bool multiply_by_density,
                                           std::string userobject_name);
 
  void addAdvectiveFluxCalculatorUnsaturated(unsigned phase,
                                             bool multiply_by_density,
                                             std::string userobject_name);
 
  void addAdvectiveFluxCalculatorSaturatedHeat(unsigned phase,
                                               bool multiply_by_density,
                                               std::string userobject_name);
 
  void addAdvectiveFluxCalculatorUnsaturatedHeat(unsigned phase,
                                                 bool multiply_by_density,
                                                 std::string userobject_name);
 
  void addAdvectiveFluxCalculatorSaturatedMultiComponent(unsigned phase,
                                                         unsigned fluid_component,
                                                         bool multiply_by_density,
                                                         std::string userobject_name);
 
  void addAdvectiveFluxCalculatorUnsaturatedMultiComponent(unsigned phase,
                                                           unsigned fluid_component,
                                                           bool multiply_by_density,
                                                           std::string userobject_name);
};