PorousFlowFluidMass Class Reference

Postprocessor produces the mass of a given fluid component in a region. More...

#include <PorousFlowFluidMass.h>

Inheritance diagram for PorousFlowFluidMass:

Public Member Functions
	PorousFlowFluidMass (const InputParameters &parameters)

Protected Member Functions
virtual Real	computeIntegral () override
virtual Real	computeQpIntegral () override

Protected Attributes
const PorousFlowDictator &	_dictator
	PorousFlowDictator UserObject. More...
const unsigned int	_fluid_component
	The fluid component index that this Postprocessor applies to. More...
std::vector< unsigned int >	_phase_index
	The phase indices that this Postprocessor is restricted to. More...
const MaterialProperty< Real > &	_porosity
	Porosity. More...
const MaterialProperty< std::vector< Real > > &	_fluid_density
	Phase density (kg/m^3) More...
const MaterialProperty< std::vector< Real > > &	_fluid_saturation
	Phase saturation (-) More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_mass_fraction
	Mass fraction of each fluid component in each phase. More...
const Real	_saturation_threshold
	Saturation threshold - only fluid mass at saturations below this are calculated. More...
MooseVariable *const	_var
	The variable for the corresponding PorousFlowMassTimeDerivative Kernel: this provides test functions. More...

Detailed Description

Postprocessor produces the mass of a given fluid component in a region.

Definition at line 23 of file PorousFlowFluidMass.h.

Constructor & Destructor Documentation

PorousFlowFluidMass()

PorousFlowFluidMass::PorousFlowFluidMass

(

const InputParameters &

parameters

)

Definition at line 50 of file PorousFlowFluidMass.C.

  : ElementIntegralPostprocessor(parameters),
 
    _dictator(getUserObject<PorousFlowDictator>("PorousFlowDictator")),
    _fluid_component(getParam<unsigned int>("fluid_component")),
    _phase_index(getParam<std::vector<unsigned int>>("phase")),
    _porosity(getMaterialProperty<Real>("PorousFlow_porosity_nodal")),
    _fluid_density(getMaterialProperty<std::vector<Real>>("PorousFlow_fluid_phase_density_nodal")),
    _fluid_saturation(getMaterialProperty<std::vector<Real>>("PorousFlow_saturation_nodal")),
    _mass_fraction(
        getMaterialProperty<std::vector<std::vector<Real>>>("PorousFlow_mass_frac_nodal")),
    _saturation_threshold(getParam<Real>("saturation_threshold")),
    _var(getParam<unsigned>("kernel_variable_number") < _dictator.numVariables()
             ? &_fe_problem.getStandardVariable(
                   _tid,
                   _dictator
                       .getCoupledStandardMooseVars()[getParam<unsigned>("kernel_variable_number")]
                       ->name())
             : nullptr)
{
  const unsigned int num_phases = _dictator.numPhases();
  const unsigned int num_components = _dictator.numComponents();
 
  // Check that the number of components entered is not greater than the total number of components
  if (_fluid_component >= num_components)
    paramError(
        "fluid_component",
        "The Dictator proclaims that the number of components in this simulation is ",
        num_components,
        " whereas you have used a component index of ",
        _fluid_component,
        ". Remember that indexing starts at 0. The Dictator does not take such mistakes lightly.");
 
  // Check that the number of phases entered is not more than the total possible phases
  if (_phase_index.size() > num_phases)
    paramError("phase",
               "The Dictator decrees that the number of phases in this simulation is ",
               num_phases,
               " but you have entered ",
               _phase_index.size(),
               " phases.");
 
  // Check that kernel_variable_number is OK
  if (getParam<unsigned>("kernel_variable_number") >= _dictator.numVariables())
    paramError("kernel_variable_number",
               "The Dictator pronounces that the number of PorousFlow variables is ",
               _dictator.numVariables(),
               ", however you have used ",
               getParam<unsigned>("kernel_variable_number"),
               ". This is an error");
 
  // Now that we know kernel_variable_number is OK, _var must be OK,
  // so ensure that reinit is called on _var:
  addMooseVariableDependency(_var);
 
  // Also check that the phase indices entered are not greater than the number of phases
  // to avoid a segfault. Note that the input parser takes care of negative inputs so we
  // don't need to guard against them
  if (!_phase_index.empty())
  {
    unsigned int max_phase_num = *std::max_element(_phase_index.begin(), _phase_index.end());
    if (max_phase_num > num_phases - 1)
      paramError("phase",
                 "The Dictator proclaims that the phase index ",
                 max_phase_num,
                 " is greater than the largest phase index possible, which is ",
                 num_phases - 1);
  }
 
  // Using saturation_threshold only makes sense for a specific phase_index
  if (_saturation_threshold < 1.0 && _phase_index.size() != 1)
    paramError("saturation_threshold",
               "A single phase_index must be entered when prescribing a saturation_threshold");
 
  // If _phase_index is empty, create vector of all phase numbers to calculate mass over all phases
  if (_phase_index.empty())
    for (unsigned int i = 0; i < num_phases; ++i)
      _phase_index.push_back(i);
}

Member Function Documentation

computeIntegral()

Real PorousFlowFluidMass::computeIntegral ( )

overrideprotectedvirtual

Definition at line 131 of file PorousFlowFluidMass.C.

{
  Real sum = 0;
 
  // The use of _test in the loops below mean that the
  // integral is exactly the same as the one computed
  // by the PorousFlowMassTimeDerivative Kernel.  Because that
  // Kernel is lumped, this Postprocessor also needs to
  // be lumped.  Hence the use of the "nodal" Material
  // Properties
  const VariableTestValue & test = _var->phi();
 
  for (unsigned node = 0; node < test.size(); ++node)
  {
    Real nodal_volume = 0.0;
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      nodal_volume += _JxW[_qp] * _coord[_qp] * test[node][_qp];
 
    Real mass = 0.0;
    for (auto ph : _phase_index)
    {
      if (_fluid_saturation[node][ph] <= _saturation_threshold)
        mass += _fluid_density[node][ph] * _fluid_saturation[node][ph] *
                _mass_fraction[node][ph][_fluid_component];
    }
    sum += nodal_volume * _porosity[node] * mass;
  }
 
  return sum;
}

computeQpIntegral()

Real PorousFlowFluidMass::computeQpIntegral ( )

overrideprotectedvirtual

Definition at line 163 of file PorousFlowFluidMass.C.

{
  return 0.0;
}

Member Data Documentation

_dictator

const PorousFlowDictator& PorousFlowFluidMass::_dictator

protected

PorousFlowDictator UserObject.

Definition at line 33 of file PorousFlowFluidMass.h.

Referenced by PorousFlowFluidMass().

_fluid_component

const unsigned int PorousFlowFluidMass::_fluid_component

protected

The fluid component index that this Postprocessor applies to.

Definition at line 35 of file PorousFlowFluidMass.h.

Referenced by computeIntegral(), and PorousFlowFluidMass().

_fluid_density

const MaterialProperty<std::vector<Real> >& PorousFlowFluidMass::_fluid_density

protected

Phase density (kg/m^3)

Definition at line 41 of file PorousFlowFluidMass.h.

Referenced by computeIntegral().

_fluid_saturation

const MaterialProperty<std::vector<Real> >& PorousFlowFluidMass::_fluid_saturation

protected

Phase saturation (-)

Definition at line 43 of file PorousFlowFluidMass.h.

Referenced by computeIntegral().

_mass_fraction

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowFluidMass::_mass_fraction

protected

Mass fraction of each fluid component in each phase.

Definition at line 45 of file PorousFlowFluidMass.h.

Referenced by computeIntegral().

_phase_index

std::vector<unsigned int> PorousFlowFluidMass::_phase_index

protected

The phase indices that this Postprocessor is restricted to.

Definition at line 37 of file PorousFlowFluidMass.h.

Referenced by computeIntegral(), and PorousFlowFluidMass().

_porosity

const MaterialProperty<Real>& PorousFlowFluidMass::_porosity

protected

Porosity.

Definition at line 39 of file PorousFlowFluidMass.h.

Referenced by computeIntegral().

_saturation_threshold

const Real PorousFlowFluidMass::_saturation_threshold

protected

Saturation threshold - only fluid mass at saturations below this are calculated.

Definition at line 47 of file PorousFlowFluidMass.h.

Referenced by computeIntegral(), and PorousFlowFluidMass().

_var

MooseVariable* const PorousFlowFluidMass::_var

protected

The variable for the corresponding PorousFlowMassTimeDerivative Kernel: this provides test functions.

Definition at line 49 of file PorousFlowFluidMass.h.

Referenced by computeIntegral(), and PorousFlowFluidMass().

---

The documentation for this class was generated from the following files:

• porous_flow/include/postprocessors/PorousFlowFluidMass.h
• porous_flow/src/postprocessors/PorousFlowFluidMass.C