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

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