PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent Class Reference

Computes the advective flux of fluid of given phase and component. More...

#include <PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.h>

Inheritance diagram for PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent:

Public Member Functions
	PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent (const InputParameters &parameters)
const std::map< dof_id_type, std::vector< Real > > &	getdFluxOut_dvars (unsigned node_id) const
	Returns d(flux_out)/d(porous_flow_variables. More...
virtual void	meshChanged () override
Real	getFluxOut (dof_id_type node_i) const
	Returns the flux out of lobal node id. More...
const std::map< dof_id_type, Real > &	getdFluxOutdu (dof_id_type node_i) const
	Returns r where r[j] = d(flux out of global node i)/du(global node j) used in Jacobian computations. More...
const std::map< dof_id_type, std::map< dof_id_type, Real > > &	getdFluxOutdKjk (dof_id_type node_i) const
	Returns r where r[j] = d(flux out of global node i)/dK[global node j][global node k] used in Jacobian computations. More...
unsigned	getValence (dof_id_type node_i, dof_id_type node_j) const
	Returns the valence of the i-j edge. More...

Protected Types
enum	FluxLimiterTypeEnum {   FluxLimiterTypeEnum::MinMod, FluxLimiterTypeEnum::VanLeer, FluxLimiterTypeEnum::MC, FluxLimiterTypeEnum::superbee,   FluxLimiterTypeEnum::None }
	Determines Flux Limiter type (Page 135 of Kuzmin and Turek) "None" means that limitFlux=0 always, which implies zero antidiffusion will be added. More...
enum	PQPlusMinusEnum { PQPlusMinusEnum::PPlus, PQPlusMinusEnum::PMinus, PQPlusMinusEnum::QPlus, PQPlusMinusEnum::QMinus }
	Signals to the PQPlusMinus method what should be computed. More...

Protected Member Functions
virtual Real	computeU (unsigned i) const override
	Computes the value of u at the local node id of the current element (_current_elem) More...
virtual Real	computedU_dvar (unsigned i, unsigned pvar) const override
	Compute d(u)/d(porous_flow_variable) More...
virtual void	timestepSetup () override
virtual void	initialize () override
virtual void	execute () override
virtual void	finalize () override
virtual void	threadJoin (const UserObject &uo) override
virtual Real	computeVelocity (unsigned i, unsigned j, unsigned qp) const override
	Computes the transfer velocity between current node i and current node j at the current qp in the current element (_current_elem). More...
virtual void	executeOnElement (dof_id_type global_i, dof_id_type global_j, unsigned local_i, unsigned local_j, unsigned qp) override
	This is called by multiple times in execute() in a double loop over _current_elem's nodes (local_i and local_j) nested in a loop over each of _current_elem's quadpoints (qp). More...
const std::vector< Real > &	getdU_dvar (dof_id_type node_i) const
	Returns _du_dvar[node_i] which is the set of derivatives d(u)/d(porous_flow_variable) This will have been computed during execute() by computedU_dvar() More...
bool	getdU_dvarComputedByThread (dof_id_type node_i) const
	Returns _du_dvar_computed_by_thread[node_i] This is initialized to false in initialize() and potentially set to true during execute() More...
const std::map< dof_id_type, std::vector< Real > > &	getdK_dvar (dof_id_type node_i, dof_id_type node_j) const
	Returns, r, where r[global node k][a] = d(K[node_i][node_j])/d(porous_flow_variable[global node k][porous_flow_variable a]) param node_i global node id param node_j global node id. More...
void	limitFlux (Real a, Real b, Real &limited, Real &dlimited_db) const
	flux limiter, L, on Page 135 of Kuzmin and Turek More...
Real	rPlus (dof_id_type node_i, std::map< dof_id_type, Real > &dlimited_du, std::map< dof_id_type, Real > &dlimited_dk) const
	Returns the value of R_{i}^{+}, Eqn (49) of KT. More...
Real	rMinus (dof_id_type node_i, std::map< dof_id_type, Real > &dlimited_du, std::map< dof_id_type, Real > &dlimited_dk) const
	Returns the value of R_{i}^{-}, Eqn (49) of KT. More...
Real	getKij (dof_id_type node_i, dof_id_type node_j) const
	Returns the value of k_ij as computed by KT Eqns (18)-(20). More...
Real	PQPlusMinus (dof_id_type node_i, const PQPlusMinusEnum pq_plus_minus, std::map< dof_id_type, Real > &derivs, std::map< dof_id_type, Real > &dpq_dk) const
	Returns the value of P_{i}^{+}, P_{i}^{-}, Q_{i}^{+} or Q_{i}^{-} (depending on pq_plus_minus) which are defined in Eqns (47) and (48) of KT. More...
void	zeroedConnection (std::map< dof_id_type, Real > &the_map, dof_id_type node_i) const
	Clears the_map, then, using _kij, constructs the_map so that the_map[node_id] = 0.0 for all node_id connected with node_i. More...
Real	getUnodal (dof_id_type node_i) const
	Returns the value of u at the global id node_i. More...
bool	getUnodalComputedByThread (dof_id_type node_i) const
	Returns the value of _u_nodal_computed_by_thread at the global id node_i. More...

Protected Attributes
const MaterialProperty< std::vector< Real > > &	_relative_permeability
	Relative permeability of each phase. More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_drelative_permeability_dvar
	Derivative of relative permeability of each phase wrt PorousFlow variables. More...
const unsigned int	_fluid_component
	The fluid component. More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_mass_fractions
	Mass fraction of each component in each phase. More...
const MaterialProperty< std::vector< std::vector< std::vector< Real > > > > &	_dmass_fractions_dvar
	Derivative of the mass fraction of each component in each phase wrt PorousFlow variables. More...
const bool	_multiply_by_density
	Whether to multiply the flux by the fluid density. More...
const MaterialProperty< std::vector< Real > > *const	_fluid_density_node
	Fluid density for each phase (at the node) More...
const MaterialProperty< std::vector< std::vector< Real > > > *const	_dfluid_density_node_dvar
	Derivative of the fluid density for each phase wrt PorousFlow variables (at the node) More...
const MaterialProperty< std::vector< Real > > &	_fluid_viscosity
	Viscosity of each component in each phase. More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_dfluid_viscosity_dvar
	Derivative of the fluid viscosity for each phase wrt PorousFlow variables. More...
const PorousFlowDictator &	_dictator
	PorousFlowDictator UserObject. More...
const unsigned	_num_vars
	Number of PorousFlow variables. More...
const RealVectorValue	_gravity
	Gravity. More...
const unsigned int	_phase
	The phase. More...
const MaterialProperty< RealTensorValue > &	_permeability
	Permeability of porous material. More...
const MaterialProperty< std::vector< RealTensorValue > > &	_dpermeability_dvar
	d(permeabiity)/d(PorousFlow variable) More...
const MaterialProperty< std::vector< std::vector< RealTensorValue > > > &	_dpermeability_dgradvar
	d(permeabiity)/d(grad(PorousFlow variable)) More...
const MaterialProperty< std::vector< Real > > &	_fluid_density_qp
	Fluid density for each phase (at the qp) More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_dfluid_density_qp_dvar
	Derivative of the fluid density for each phase wrt PorousFlow variables (at the qp) More...
const MaterialProperty< std::vector< RealGradient > > &	_grad_p
	Gradient of the pore pressure in each phase. More...
const MaterialProperty< std::vector< std::vector< Real > > > &	_dgrad_p_dgrad_var
	Derivative of Grad porepressure in each phase wrt grad(PorousFlow variables) More...
const MaterialProperty< std::vector< std::vector< RealGradient > > > &	_dgrad_p_dvar
	Derivative of Grad porepressure in each phase wrt PorousFlow variables. More...
const FEType	_fe_type
	FEType to use. More...
const VariablePhiValue &	_phi
	Kuzmin-Turek shape function. More...
const VariablePhiGradient &	_grad_phi
	grad(Kuzmin-Turek shape function) More...
std::map< dof_id_type, std::vector< Real > >	_du_dvar
	_du_dvar[i][a] = d(u[global node i])/d(porous_flow_variable[a]) More...
std::map< dof_id_type, bool >	_du_dvar_computed_by_thread
	Whether _du_dvar has been computed by the local thread. More...
std::map< dof_id_type, std::map< dof_id_type, std::map< dof_id_type, std::vector< Real > > > >	_dkij_dvar
	_dkij_dvar[i][j][k][a] = d(K[global node i][global node j])/d(porous_flow_variable[global_node k][porous_flow_variable a]) More...
std::map< dof_id_type, std::map< dof_id_type, std::vector< Real > > >	_dflux_out_dvars
	_dflux_out_dvars[i][j][pvar] = d(flux_out[global node i])/d(porous_flow_variable pvar at global node j) More...
bool	_resizing_needed
	whether _kij, etc, need to be sized appropriately (and valence recomputed) at the start of the timestep More...
enum AdvectiveFluxCalculatorBase::FluxLimiterTypeEnum	_flux_limiter_type
std::map< dof_id_type, std::map< dof_id_type, Real > >	_kij
	Kuzmin-Turek K_ij matrix. More...
std::map< dof_id_type, Real >	_flux_out
	_flux_out[i] = flux of "heat" from node i More...
std::map< dof_id_type, std::map< dof_id_type, Real > >	_dflux_out_du
	_dflux_out_du[i][j] = d(flux_out[i])/d(u[j]). Here j must be connected to i, or to a node that is connected to i. More...
std::map< dof_id_type, std::map< dof_id_type, std::map< dof_id_type, Real > > >	_dflux_out_dKjk
	_dflux_out_dKjk[i][j][k] = d(flux_out[i])/d(K[j][k]). Here j must be connected to i (this does include j = i), and k must be connected to j (this does include k = i and k = j) More...
std::map< std::pair< dof_id_type, dof_id_type >, unsigned >	_valence
	_valence[(i, j)] = number of times, in a loop over elements seen by this processor (viz, including ghost elements) and are part of the block-restricted blocks of this UserObject, that the i-j edge is encountered More...
std::map< dof_id_type, Real >	_u_nodal
	_u_nodal[i] = value of _u at global node number i More...
std::map< dof_id_type, bool >	_u_nodal_computed_by_thread
	_u_nodal_computed_by_thread[i] = true if _u_nodal[i] has been computed in execute() by the thread on this processor More...

Detailed Description

Computes the advective flux of fluid of given phase and component.

Hence this UserObject is relevant to multi-phase, multi-component situations. Explicitly, the UserObject computes (mass_fraction * density * relative_permeability / viscosity) * (- permeability * (grad(P) - density * gravity))

Definition at line 27 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.h.

Member Enumeration Documentation

FluxLimiterTypeEnum

enum AdvectiveFluxCalculatorBase::FluxLimiterTypeEnum

strongprotectedinherited

Determines Flux Limiter type (Page 135 of Kuzmin and Turek) "None" means that limitFlux=0 always, which implies zero antidiffusion will be added.

Enumerator
MinMod
VanLeer
MC
superbee
None

Definition at line 162 of file AdvectiveFluxCalculatorBase.h.

{ MinMod, VanLeer, MC, superbee, None } _flux_limiter_type;

PQPlusMinusEnum

enum AdvectiveFluxCalculatorBase::PQPlusMinusEnum

strongprotectedinherited

Signals to the PQPlusMinus method what should be computed.

Enumerator
PPlus
PMinus
QPlus
QMinus

Definition at line 193 of file AdvectiveFluxCalculatorBase.h.

  {
    PPlus,
    PMinus,
    QPlus,
    QMinus
  };

Constructor & Destructor Documentation

PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent()

PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent::PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent

(

const InputParameters &

parameters

)

Definition at line 27 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.C.

  : PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent(parameters),
    _relative_permeability(
        getMaterialProperty<std::vector<Real>>("PorousFlow_relative_permeability_nodal")),
    _drelative_permeability_dvar(getMaterialProperty<std::vector<std::vector<Real>>>(
        "dPorousFlow_relative_permeability_nodal_dvar"))
{
}

Member Function Documentation

computedU_dvar()

Real PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent::computedU_dvar ( unsigned  i, unsigned  pvar  ) const

overrideprotectedvirtual

Compute d(u)/d(porous_flow_variable)

Parameters

i	node number of the current element
pvar	porous flow variable number

Reimplemented from PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent.

Definition at line 44 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.C.

{
  Real du = _drelative_permeability_dvar[i][_phase][pvar] *
            PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computeU(i);
  du += _relative_permeability[i][_phase] *
        PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computedU_dvar(i, pvar);
  return du;
}

computeU()

Real PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent::computeU ( unsigned  i ) const

overrideprotectedvirtual

Computes the value of u at the local node id of the current element (_current_elem)

Parameters

i	local node id of the current element

Reimplemented from PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent.

Definition at line 37 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.C.

{
  return _relative_permeability[i][_phase] *
         PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computeU(i);
}

computeVelocity()

Real PorousFlowAdvectiveFluxCalculatorBase::computeVelocity ( unsigned  i, unsigned  j, unsigned  qp  ) const

overrideprotectedvirtualinherited

Computes the transfer velocity between current node i and current node j at the current qp in the current element (_current_elem).

For instance, (_grad_phi[i][qp] * _velocity) * _phi[j][qp];

Parameters

i	node number in the current element
j	node number in the current element
qp	quadpoint number in the current element

Implements AdvectiveFluxCalculatorBase.

Definition at line 91 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  // The following is but one choice for PorousFlow situations
  // If you change this, you will probably have to change
  // - the derivative in executeOnElement
  // - computeU
  // - coputedU_dvar
  return -_grad_phi[i][qp] *
         (_permeability[qp] * (_grad_p[qp][_phase] - _fluid_density_qp[qp][_phase] * _gravity)) *
         _phi[j][qp];
}

execute()

void PorousFlowAdvectiveFluxCalculatorBase::execute ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 187 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  AdvectiveFluxCalculatorBase::execute();

  // compute d(U)/d(porous_flow_variables) for nodes in _current_elem and for this
  // execution thread.  In threadJoin all these computations get gathered
  // using _du_dvar_computed_by_thread
  for (unsigned i = 0; i < _current_elem->n_nodes(); ++i)
  {
    const dof_id_type node_i = _current_elem->node_id(i);
    if (_du_dvar_computed_by_thread[node_i])
      continue;
    for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
      _du_dvar[node_i][pvar] = computedU_dvar(i, pvar);
    _du_dvar_computed_by_thread[node_i] = true;
  }
}

executeOnElement()

void PorousFlowAdvectiveFluxCalculatorBase::executeOnElement ( dof_id_type  global_i, dof_id_type  global_j, unsigned  local_i, unsigned  local_j, unsigned  qp  )

overrideprotectedvirtualinherited

This is called by multiple times in execute() in a double loop over _current_elem's nodes (local_i and local_j) nested in a loop over each of _current_elem's quadpoints (qp).

It is used to compute _kij and its derivatives

Parameters

global_i	global node id corresponding to the local node local_i
global_j	global node id corresponding to the local node local_j
local_i	local node number of the _current_elem
local_j	local node number of the _current_elem
qp	quadpoint number of the _current_elem

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 104 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  AdvectiveFluxCalculatorBase::executeOnElement(global_i, global_j, local_i, local_j, qp);

  // compute d(Kij)/d(porous_flow_variables)
  for (unsigned local_k = 0; local_k < _current_elem->n_nodes(); ++local_k)
  {
    const dof_id_type global_k = _current_elem->node_id(local_k);
    for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
    {
      RealVectorValue deriv = _dpermeability_dvar[qp][pvar] * _phi[local_k][qp] *
                              (_grad_p[qp][_phase] - _fluid_density_qp[qp][_phase] * _gravity);
      for (unsigned i = 0; i < LIBMESH_DIM; ++i)
        deriv += _dpermeability_dgradvar[qp][i][pvar] * _grad_phi[local_k][qp](i) *
                 (_grad_p[qp][_phase] - _fluid_density_qp[qp][_phase] * _gravity);
      deriv += _permeability[qp] *
               (_grad_phi[local_k][qp] * _dgrad_p_dgrad_var[qp][_phase][pvar] -
                _phi[local_k][qp] * _dfluid_density_qp_dvar[qp][_phase][pvar] * _gravity);
      deriv += _permeability[qp] * (_dgrad_p_dvar[qp][_phase][pvar] * _phi[local_k][qp]);
      _dkij_dvar[global_i][global_j][global_k][pvar] +=
          _JxW[qp] * _coord[qp] * (-_grad_phi[local_i][qp] * deriv * _phi[local_j][qp]);
    }
  }
}

finalize()

void PorousFlowAdvectiveFluxCalculatorBase::finalize ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 284 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  AdvectiveFluxCalculatorBase::finalize();

  // compute d(flux_out)/d(porous flow variable)
  for (auto & nodes : _kij)
  {
    const dof_id_type node_i = nodes.first;
    _dflux_out_dvars[node_i].clear();

    const std::map<dof_id_type, Real> dflux_out_du =
        AdvectiveFluxCalculatorBase::getdFluxOutdu(node_i);
    for (const auto & node_du : dflux_out_du)
    {
      const dof_id_type j = node_du.first;
      const Real dflux_out_du_j = node_du.second;
      _dflux_out_dvars[node_i][j] = getdU_dvar(j);
      for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
        _dflux_out_dvars[node_i][j][pvar] *= dflux_out_du_j;
    }

    // _dflux_out_dvars is now sized correctly, because getdFluxOutdu(i) contains all nodes
    // connected to i and all nodes connected to nodes connected to i.  The
    // getdFluxOutdKij contains no extra nodes, so just += the dflux/dK terms
    const std::map<dof_id_type, std::map<dof_id_type, Real>> dflux_out_dKjk =
        AdvectiveFluxCalculatorBase::getdFluxOutdKjk(node_i);
    for (const auto & nodes : dflux_out_dKjk)
    {
      const dof_id_type j = nodes.first;
      for (const auto & node_du : nodes.second)
      {
        const dof_id_type k = node_du.first;
        const Real dflux_out_dK_jk = node_du.second;
        const std::map<dof_id_type, std::vector<Real>> dkj_dvarl = getdK_dvar(j, k);
        for (const auto & nodel_deriv : dkj_dvarl)
        {
          const dof_id_type l = nodel_deriv.first;
          for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
            _dflux_out_dvars[node_i][l][pvar] += dflux_out_dK_jk * nodel_deriv.second[pvar];
        }
      }
    }
  }
}

getdFluxOut_dvars()

const std::map< dof_id_type, std::vector< Real > > & PorousFlowAdvectiveFluxCalculatorBase::getdFluxOut_dvars ( unsigned  node_id ) const

inherited

Returns d(flux_out)/d(porous_flow_variables.

Parameters

[in]

node_id

global node id

Returns

deriv[j][pvar] = d(flux_out[node_id])/d(porous_flow_variable pvar at global node j)

Definition at line 274 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowFluxLimitedTVDAdvection::computeJacobian().

{
  const auto & row_find = _dflux_out_dvars.find(node_id);
  if (row_find == _dflux_out_dvars.end())
    mooseError("PorousFlowAdvectiveFluxCalculatorBase UserObject " + name() +
               " _dflux_out_dvars does not contain node " + Moose::stringify(node_id));
  return row_find->second;
}

getdFluxOutdKjk()

const std::map< dof_id_type, std::map< dof_id_type, Real > > & AdvectiveFluxCalculatorBase::getdFluxOutdKjk ( dof_id_type  node_i ) const

inherited

Returns r where r[j] = d(flux out of global node i)/dK[global node j][global node k] used in Jacobian computations.

Parameters

node_i

global id of node

Returns

the derivatives (after applying the KT procedure)

Definition at line 723 of file AdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

{
  const auto & row_find = _dflux_out_dKjk.find(node_i);
  if (row_find == _dflux_out_dKjk.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " _dflux_out_dKjk does not contain node " + Moose::stringify(node_i));
  return row_find->second;
}

getdFluxOutdu()

const std::map< dof_id_type, Real > & AdvectiveFluxCalculatorBase::getdFluxOutdu ( dof_id_type  node_i ) const

inherited

Returns r where r[j] = d(flux out of global node i)/du(global node j) used in Jacobian computations.

Parameters

node_i

global id of node

Returns

the derivatives (after applying the KT procedure)

Definition at line 713 of file AdvectiveFluxCalculatorBase.C.

Referenced by FluxLimitedTVDAdvection::computeJacobian(), and PorousFlowAdvectiveFluxCalculatorBase::finalize().

{
  const auto & row_find = _dflux_out_du.find(node_i);
  if (row_find == _dflux_out_du.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " _dflux_out_du does not contain node " + Moose::stringify(node_i));
  return row_find->second;
}

getdK_dvar()

const std::map< dof_id_type, std::vector< Real > > & PorousFlowAdvectiveFluxCalculatorBase::getdK_dvar ( dof_id_type  node_i, dof_id_type  node_j  ) const

protectedinherited

Returns, r, where r[global node k][a] = d(K[node_i][node_j])/d(porous_flow_variable[global node k][porous_flow_variable a]) param node_i global node id param node_j global node id.

Definition at line 257 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

{
  const auto & row_find = _dkij_dvar.find(node_i);
  if (row_find == _dkij_dvar.end())
    mooseError("PorousFlowAdvectiveFluxCalculatorBase UserObject " + name() +
               " _dkij_dvar does not contain node " + Moose::stringify(node_i));
  const std::map<dof_id_type, std::map<dof_id_type, std::vector<Real>>> & dkij_dvar_row =
      row_find->second;
  const auto & column_find = dkij_dvar_row.find(node_j);
  if (column_find == dkij_dvar_row.end())
    mooseError("PorousFlowAdvectiveFluxCalculatorBase UserObject " + name() +
               " _dkij_dvar on row " + Moose::stringify(node_i) + " does not contain node " +
               Moose::stringify(node_j));
  return column_find->second;
}

getdU_dvar()

const std::vector< Real > & PorousFlowAdvectiveFluxCalculatorBase::getdU_dvar ( dof_id_type  node_i ) const

protectedinherited

Returns _du_dvar[node_i] which is the set of derivatives d(u)/d(porous_flow_variable) This will have been computed during execute() by computedU_dvar()

Parameters

node_i

global node id

Definition at line 237 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

{
  const auto & node_du = _du_dvar.find(node_i);
  if (node_du == _du_dvar.end())
    mooseError("PorousFlowAdvectiveFluxCalculatorBase UserObject " + name() +
               " _du_dvar does not contain node " + Moose::stringify(node_i));
  return node_du->second;
}

getdU_dvarComputedByThread()

bool PorousFlowAdvectiveFluxCalculatorBase::getdU_dvarComputedByThread ( dof_id_type  node_i ) const

protectedinherited

Returns _du_dvar_computed_by_thread[node_i] This is initialized to false in initialize() and potentially set to true during execute()

Parameters

node_i

global node id

Definition at line 247 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::threadJoin().

{
  const auto & node_du = _du_dvar_computed_by_thread.find(node_i);
  if (node_du == _du_dvar_computed_by_thread.end())
    mooseError("PorousFlowAdvectiveFluxCalculatorBase UserObject " + name() +
               " _du_dvar_computed_by_thread does not contain node " + Moose::stringify(node_i));
  return node_du->second;
}

getFluxOut()

Real AdvectiveFluxCalculatorBase::getFluxOut ( dof_id_type  node_i ) const

inherited

Returns the flux out of lobal node id.

Parameters

node_i

id of node

Returns

advective flux out of node after applying the KT procedure

Definition at line 733 of file AdvectiveFluxCalculatorBase.C.

Referenced by FluxLimitedTVDAdvection::computeResidual(), and PorousFlowFluxLimitedTVDAdvection::computeResidual().

{
  const auto & entry_find = _flux_out.find(node_i);
  if (entry_find == _flux_out.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " _flux_out does not contain node " + Moose::stringify(node_i));
  return entry_find->second;
}

getKij()

Real AdvectiveFluxCalculatorBase::getKij ( dof_id_type  node_i, dof_id_type  node_j  ) const

protectedinherited

Returns the value of k_ij as computed by KT Eqns (18)-(20).

Parameters

node_i	id of i^th node
node_j	id of j^th node

Returns

k_ij of KT

Definition at line 696 of file AdvectiveFluxCalculatorBase.C.

{

  const auto & row_find = _kij.find(node_i);
  if (row_find == _kij.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() + " Kij does not contain node " +
               Moose::stringify(node_i));
  const std::map<dof_id_type, Real> & kij_row = row_find->second;
  const auto & entry_find = kij_row.find(node_j);
  if (entry_find == kij_row.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() + " Kij on row " +
               Moose::stringify(node_i) + " does not contain node " + Moose::stringify(node_j));

  return entry_find->second;
}

getUnodal()

Real AdvectiveFluxCalculatorBase::getUnodal ( dof_id_type  node_i ) const

protectedinherited

Returns the value of u at the global id node_i.

This is _u_nodal[node_i] that has been computed by computeU during execute()

Parameters

node_i

global node id

Definition at line 853 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), and AdvectiveFluxCalculatorBase::PQPlusMinus().

{
  const auto & node_u = _u_nodal.find(node_i);
  if (node_u == _u_nodal.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " _u_nodal does not contain node " + Moose::stringify(node_i));
  return node_u->second;
}

getUnodalComputedByThread()

bool AdvectiveFluxCalculatorBase::getUnodalComputedByThread ( dof_id_type  node_i ) const

protectedinherited

Returns the value of _u_nodal_computed_by_thread at the global id node_i.

This will have been initialized to false in initialize() and potentially set true during execute()

Parameters

node_i

global node id

Definition at line 863 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::threadJoin().

{
  const auto & node_u = _u_nodal_computed_by_thread.find(node_i);
  if (node_u == _u_nodal_computed_by_thread.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " _u_nodal_computed_by_thread does not contain node " + Moose::stringify(node_i));
  return node_u->second;
}

getValence()

unsigned AdvectiveFluxCalculatorBase::getValence ( dof_id_type  node_i, dof_id_type  node_j  ) const

inherited

Returns the valence of the i-j edge.

Valence is the number of times the edge is encountered in a loop over elements (that have appropriate subdomain_id, if the user has employed the "blocks=" parameter) seen by this processor (including ghosted elements)

Parameters

node_i	id of i^th node
node_j	id of j^th node

Returns

valence of the i-j edge

Definition at line 743 of file AdvectiveFluxCalculatorBase.C.

Referenced by FluxLimitedTVDAdvection::computeJacobian(), PorousFlowFluxLimitedTVDAdvection::computeJacobian(), FluxLimitedTVDAdvection::computeResidual(), and PorousFlowFluxLimitedTVDAdvection::computeResidual().

{
  const std::pair<dof_id_type, dof_id_type> i_j(node_i, node_j);
  const auto & entry_find = _valence.find(i_j);
  if (entry_find == _valence.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() +
               " Valence does not contain node-pair " + Moose::stringify(node_i) + " to " +
               Moose::stringify(node_j));
  return entry_find->second;
}

initialize()

void PorousFlowAdvectiveFluxCalculatorBase::initialize ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 175 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  AdvectiveFluxCalculatorBase::initialize();
  for (const auto & nodes : _kij)
    _du_dvar_computed_by_thread[nodes.first] = false;
  for (auto & i_and_jmap : _dkij_dvar)
    for (auto & j_and_kmap : i_and_jmap.second)
      for (auto & k_and_derivs : j_and_kmap.second)
        k_and_derivs.second = std::vector<Real>(_num_vars, 0.0);
}

limitFlux()

void AdvectiveFluxCalculatorBase::limitFlux ( Real  a, Real  b, Real &  limited, Real &  dlimited_db  ) const

protectedinherited

flux limiter, L, on Page 135 of Kuzmin and Turek

Parameters

a	KT's "a" parameter
b	KT's "b" parameter
limited[out]	The value of the flux limiter, L
dlimited_db[out]	The derivative dL/db

Definition at line 596 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::rMinus(), and AdvectiveFluxCalculatorBase::rPlus().

{
  limited = 0.0;
  dlimited_db = 0.0;
  if (_flux_limiter_type == FluxLimiterTypeEnum::None)
    return;

  if ((a >= 0.0 && b <= 0.0) || (a <= 0.0 && b >= 0.0))
    return;
  const Real s = (a > 0.0 ? 1.0 : -1.0);

  const Real lal = std::abs(a);
  const Real lbl = std::abs(b);
  const Real dlbl = (b >= 0.0 ? 1.0 : -1.0); // d(lbl)/db
  switch (_flux_limiter_type)
  {
    case FluxLimiterTypeEnum::MinMod:
    {
      if (lal <= lbl)
      {
        limited = s * lal;
        dlimited_db = 0.0;
      }
      else
      {
        limited = s * lbl;
        dlimited_db = s * dlbl;
      }
      return;
    }
    case FluxLimiterTypeEnum::VanLeer:
    {
      limited = s * 2 * lal * lbl / (lal + lbl);
      dlimited_db = s * 2 * lal * (dlbl / (lal + lbl) - lbl * dlbl / std::pow(lal + lbl, 2));
      return;
    }
    case FluxLimiterTypeEnum::MC:
    {
      const Real av = 0.5 * std::abs(a + b);
      if (2 * lal <= av && lal <= lbl)
      {
        // 2 * lal is the smallest
        limited = s * 2.0 * lal;
        dlimited_db = 0.0;
      }
      else if (2 * lbl <= av && lbl <= lal)
      {
        // 2 * lbl is the smallest
        limited = s * 2.0 * lbl;
        dlimited_db = s * 2.0 * dlbl;
      }
      else
      {
        // av is the smallest
        limited = s * av;
        // if (a>0 and b>0) then d(av)/db = 0.5 = 0.5 * dlbl
        // if (a<0 and b<0) then d(av)/db = -0.5 = 0.5 * dlbl
        // if a and b have different sign then limited=0, above
        dlimited_db = s * 0.5 * dlbl;
      }
      return;
    }
    case FluxLimiterTypeEnum::superbee:
    {
      const Real term1 = std::min(2.0 * lal, lbl);
      const Real term2 = std::min(lal, 2.0 * lbl);
      if (term1 >= term2)
      {
        if (2.0 * lal <= lbl)
        {
          limited = s * 2 * lal;
          dlimited_db = 0.0;
        }
        else
        {
          limited = s * lbl;
          dlimited_db = s * dlbl;
        }
      }
      else
      {
        if (lal <= 2.0 * lbl)
        {
          limited = s * lal;
          dlimited_db = 0.0;
        }
        else
        {
          limited = s * 2.0 * lbl;
          dlimited_db = s * 2.0 * dlbl;
        }
      }
      return;
    }
    default:
      return;
  }
}

meshChanged()

void AdvectiveFluxCalculatorBase::meshChanged ( )

overridevirtualinherited

Definition at line 149 of file AdvectiveFluxCalculatorBase.C.

{
  ElementUserObject::meshChanged();

  // Signal that _kij, _valence, etc need to be rebuilt
  _resizing_needed = true;
}

PQPlusMinus()

Real AdvectiveFluxCalculatorBase::PQPlusMinus ( dof_id_type  node_i, const PQPlusMinusEnum  pq_plus_minus, std::map< dof_id_type, Real > &  derivs, std::map< dof_id_type, Real > &  dpq_dk  ) const

protectedinherited

Returns the value of P_{i}^{+}, P_{i}^{-}, Q_{i}^{+} or Q_{i}^{-} (depending on pq_plus_minus) which are defined in Eqns (47) and (48) of KT.

Parameters

node_i	global nodal id
pq_plus_minus	indicates whether P_{i}^{+}, P_{i}^{-}, Q_{i}^{+} or Q_{i}^{-} should be returned
derivs[out]	derivs[j] = d(result)/d(u[global node j])
dpq_dk[out]	dpq_dk[j] = d(result)/d(K[node_i][global node j]). Recall that d(result)/d(K[l][m]) are zero unless l=node_i

Definition at line 768 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::rMinus(), and AdvectiveFluxCalculatorBase::rPlus().

{
  // Find the value of u at node_i
  const Real u_i = getUnodal(node_i);

  // We're going to sum over all nodes connected with node_i
  // These nodes are found in _kij[node_i]
  const auto & row_find = _kij.find(node_i);
  if (row_find == _kij.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() + " Kij does not contain node " +
               Moose::stringify(node_i));
  const std::map<dof_id_type, Real> nodej_and_kij = row_find->second;

  // Initialize the results
  Real result = 0.0;
  zeroedConnection(derivs, node_i);
  zeroedConnection(dpqdk, node_i);

  // Sum over all nodes connected with node_i.
  for (const auto & nk : nodej_and_kij)
  {
    const dof_id_type node_j = nk.first;
    const Real kentry = nk.second;

    // Find the value of u at node_j
    const Real u_j = getUnodal(node_j);
    const Real ujminusi = u_j - u_i;

    // Evaluate the i-j contribution to the result
    switch (pq_plus_minus)
    {
      case PQPlusMinusEnum::PPlus:
      {
        if (ujminusi < 0.0 && kentry < 0.0)
        {
          result += kentry * ujminusi;
          derivs[node_j] += kentry;
          derivs[node_i] -= kentry;
          dpqdk[node_j] += ujminusi;
        }
        break;
      }
      case PQPlusMinusEnum::PMinus:
      {
        if (ujminusi > 0.0 && kentry < 0.0)
        {
          result += kentry * ujminusi;
          derivs[node_j] += kentry;
          derivs[node_i] -= kentry;
          dpqdk[node_j] += ujminusi;
        }
        break;
      }
      case PQPlusMinusEnum::QPlus:
      {
        if (ujminusi > 0.0 && kentry > 0.0)
        {
          result += kentry * ujminusi;
          derivs[node_j] += kentry;
          derivs[node_i] -= kentry;
          dpqdk[node_j] += ujminusi;
        }
        break;
      }
      case PQPlusMinusEnum::QMinus:
      {
        if (ujminusi < 0.0 && kentry > 0.0)
        {
          result += kentry * ujminusi;
          derivs[node_j] += kentry;
          derivs[node_i] -= kentry;
          dpqdk[node_j] += ujminusi;
        }
        break;
      }
    }
  }

  return result;
}

rMinus()

Real AdvectiveFluxCalculatorBase::rMinus ( dof_id_type  node_i, std::map< dof_id_type, Real > &  dlimited_du, std::map< dof_id_type, Real > &  dlimited_dk  ) const

protectedinherited

Returns the value of R_{i}^{-}, Eqn (49) of KT.

Parameters

node_i	nodal id
dlimited_du[out]	dlimited_du[node_id] = d(R_{i}^{-})/du[node_id]
dlimited_dk[out]	dlimited_dk[node_id] = d(R_{i}^{-})/d(K[i][node_id]). Derivatives w.r.t. K[l][m] with l!=i are zero

Definition at line 561 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize().

{
  zeroedConnection(dlimited_du, node_i);
  zeroedConnection(dlimited_dk, node_i);
  if (_flux_limiter_type == FluxLimiterTypeEnum::None)
    return 0.0;
  std::map<dof_id_type, Real> dp_du;
  std::map<dof_id_type, Real> dp_dk;
  const Real p = PQPlusMinus(node_i, PQPlusMinusEnum::PMinus, dp_du, dp_dk);
  if (p == 0.0)
    // Comment after Eqn (49): if P=0 then there's no antidiffusion, so no need to remove it
    return 1.0;
  std::map<dof_id_type, Real> dq_du;
  std::map<dof_id_type, Real> dq_dk;
  const Real q = PQPlusMinus(node_i, PQPlusMinusEnum::QMinus, dq_du, dq_dk);
  const Real r = q / p;
  std::map<dof_id_type, Real> dr_du;
  for (const auto & node_deriv : dp_du)
    dr_du[node_deriv.first] = dq_du[node_deriv.first] / p - q * node_deriv.second / std::pow(p, 2);
  std::map<dof_id_type, Real> dr_dk;
  for (const auto & node_deriv : dp_dk)
    dr_dk[node_deriv.first] = dq_dk[node_deriv.first] / p - q * node_deriv.second / std::pow(p, 2);
  Real limited;
  Real dlimited_dr;
  limitFlux(1.0, r, limited, dlimited_dr);
  for (const auto & node_deriv : dr_du)
    dlimited_du[node_deriv.first] = dlimited_dr * node_deriv.second;
  for (const auto & node_deriv : dr_dk)
    dlimited_dk[node_deriv.first] = dlimited_dr * node_deriv.second;
  return limited;
}

rPlus()

Real AdvectiveFluxCalculatorBase::rPlus ( dof_id_type  node_i, std::map< dof_id_type, Real > &  dlimited_du, std::map< dof_id_type, Real > &  dlimited_dk  ) const

protectedinherited

Returns the value of R_{i}^{+}, Eqn (49) of KT.

Parameters

node_i	nodal id
dlimited_du[out]	dlimited_du[node_id] = d(R_{i}^{+})/du[node_id] (Here node_id is a global node id)
dlimited_dk[out]	dlimited_dk[node_id] = d(R_{i}^{+})/d(K[i][node_id]). Derivatives w.r.t. K[l][m] with l!=i are zero

Definition at line 526 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize().

{
  zeroedConnection(dlimited_du, node_i);
  zeroedConnection(dlimited_dk, node_i);
  if (_flux_limiter_type == FluxLimiterTypeEnum::None)
    return 0.0;
  std::map<dof_id_type, Real> dp_du;
  std::map<dof_id_type, Real> dp_dk;
  const Real p = PQPlusMinus(node_i, PQPlusMinusEnum::PPlus, dp_du, dp_dk);
  if (p == 0.0)
    // Comment after Eqn (49): if P=0 then there's no antidiffusion, so no need to remove it
    return 1.0;
  std::map<dof_id_type, Real> dq_du;
  std::map<dof_id_type, Real> dq_dk;
  const Real q = PQPlusMinus(node_i, PQPlusMinusEnum::QPlus, dq_du, dq_dk);
  const Real r = q / p;
  std::map<dof_id_type, Real> dr_du;
  for (const auto & node_deriv : dp_du)
    dr_du[node_deriv.first] = dq_du[node_deriv.first] / p - q * node_deriv.second / std::pow(p, 2);
  std::map<dof_id_type, Real> dr_dk;
  for (const auto & node_deriv : dp_dk)
    dr_dk[node_deriv.first] = dq_dk[node_deriv.first] / p - q * node_deriv.second / std::pow(p, 2);
  Real limited;
  Real dlimited_dr;
  limitFlux(1.0, r, limited, dlimited_dr);
  for (const auto & node_deriv : dr_du)
    dlimited_du[node_deriv.first] = dlimited_dr * node_deriv.second;
  for (const auto & node_deriv : dr_dk)
    dlimited_dk[node_deriv.first] = dlimited_dr * node_deriv.second;
  return limited;
}

threadJoin()

void PorousFlowAdvectiveFluxCalculatorBase::threadJoin ( const UserObject &  uo )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 206 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  AdvectiveFluxCalculatorBase::threadJoin(uo);
  const PorousFlowAdvectiveFluxCalculatorBase & pfafc =
      static_cast<const PorousFlowAdvectiveFluxCalculatorBase &>(uo);
  // add the values of _dkij_dvar computed by different threads
  for (const auto & i_and_jmap : pfafc._dkij_dvar)
  {
    const dof_id_type i = i_and_jmap.first;
    for (const auto & j_and_kmap : i_and_jmap.second)
    {
      const dof_id_type j = j_and_kmap.first;
      for (const auto & k_and_derivs : j_and_kmap.second)
      {
        const dof_id_type k = k_and_derivs.first;
        const std::vector<Real> derivs = k_and_derivs.second;
        for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
          _dkij_dvar[i][j][k][pvar] += derivs[pvar];
      }
    }
  }
  // gather the values of _du_dvar computed by different threads
  for (const auto & node_du : pfafc._du_dvar)
  {
    const dof_id_type i = node_du.first;
    if (!_du_dvar_computed_by_thread[i] && pfafc.getdU_dvarComputedByThread(i))
      _du_dvar[i] = node_du.second;
  }
}

timestepSetup()

void PorousFlowAdvectiveFluxCalculatorBase::timestepSetup ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 131 of file PorousFlowAdvectiveFluxCalculatorBase.C.

{
  const bool resizing_was_needed =
      _resizing_needed; // _resizing_needed gets set to false at the end of
                        // AdvectiveFluxCalculatorBase::timestepSetup()
  AdvectiveFluxCalculatorBase::timestepSetup();

  // clear and appropriately size all the derivative info
  // d(U)/d(porous_flow_variables) and
  // d(Kij)/d(porous_flow_variables) and
  // d(flux_out)/d(porous_flow_variables)
  if (resizing_was_needed)
  {
    _du_dvar.clear();
    _du_dvar_computed_by_thread.clear();
    _dflux_out_dvars.clear();
    for (const auto & nodes : _kij)
    {
      const dof_id_type node_i = nodes.first;
      _du_dvar[node_i] = std::vector<Real>(_num_vars, 0.0);
      _du_dvar_computed_by_thread[node_i] = false;
      _dflux_out_dvars[node_i] = {};
    }

    _dkij_dvar.clear();
    for (const auto & nodes : _kij)
    {
      const dof_id_type node_i = nodes.first;
      _dkij_dvar[node_i] = {};
      for (const auto & neighbours_i : nodes.second)
      {
        const dof_id_type node_j = neighbours_i.first;
        _dkij_dvar[node_i][node_j] = {};
        for (const auto & also_neighbours_i : nodes.second)
        {
          const dof_id_type node_k = also_neighbours_i.first;
          _dkij_dvar[node_i][node_j][node_k] = std::vector<Real>(_num_vars, 0.0);
        }
      }
    }
  }
}

zeroedConnection()

void AdvectiveFluxCalculatorBase::zeroedConnection ( std::map< dof_id_type, Real > &  the_map, dof_id_type  node_i  ) const

protectedinherited

Clears the_map, then, using _kij, constructs the_map so that the_map[node_id] = 0.0 for all node_id connected with node_i.

Parameters

[out]	the_map	the map to be zeroed appropriately
[in]	node_i	nodal id

Definition at line 755 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::PQPlusMinus(), AdvectiveFluxCalculatorBase::rMinus(), AdvectiveFluxCalculatorBase::rPlus(), and AdvectiveFluxCalculatorBase::timestepSetup().

{
  the_map.clear();
  const auto & row_find = _kij.find(node_i);
  if (row_find == _kij.end())
    mooseError("AdvectiveFluxCalculatorBase UserObject " + name() + " Kij does not contain node " +
               Moose::stringify(node_i));
  for (const auto & nk : row_find->second)
    the_map[nk.first] = 0.0;
}

Member Data Documentation

_dfluid_density_node_dvar

const MaterialProperty<std::vector<std::vector<Real> > >* const PorousFlowAdvectiveFluxCalculatorSaturated::_dfluid_density_node_dvar

protectedinherited

Derivative of the fluid density for each phase wrt PorousFlow variables (at the node)

Definition at line 42 of file PorousFlowAdvectiveFluxCalculatorSaturated.h.

_dfluid_density_qp_dvar

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowAdvectiveFluxCalculatorBase::_dfluid_density_qp_dvar

protectedinherited

Derivative of the fluid density for each phase wrt PorousFlow variables (at the qp)

Definition at line 113 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_dfluid_viscosity_dvar

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowAdvectiveFluxCalculatorSaturated::_dfluid_viscosity_dvar

protectedinherited

Derivative of the fluid viscosity for each phase wrt PorousFlow variables.

Definition at line 48 of file PorousFlowAdvectiveFluxCalculatorSaturated.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturated::computedU_dvar().

_dflux_out_dKjk

std::map<dof_id_type, std::map<dof_id_type, std::map<dof_id_type, Real> > > AdvectiveFluxCalculatorBase::_dflux_out_dKjk

protectedinherited

_dflux_out_dKjk[i][j][k] = d(flux_out[i])/d(K[j][k]). Here j must be connected to i (this does include j = i), and k must be connected to j (this does include k = i and k = j)

Definition at line 179 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::getdFluxOutdKjk(), and AdvectiveFluxCalculatorBase::timestepSetup().

_dflux_out_du

std::map<dof_id_type, std::map<dof_id_type, Real> > AdvectiveFluxCalculatorBase::_dflux_out_du

protectedinherited

_dflux_out_du[i][j] = d(flux_out[i])/d(u[j]). Here j must be connected to i, or to a node that is connected to i.

Definition at line 176 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::getdFluxOutdu(), and AdvectiveFluxCalculatorBase::timestepSetup().

_dflux_out_dvars

std::map<dof_id_type, std::map<dof_id_type, std::vector<Real> > > PorousFlowAdvectiveFluxCalculatorBase::_dflux_out_dvars

protectedinherited

_dflux_out_dvars[i][j][pvar] = d(flux_out[global node i])/d(porous_flow_variable pvar at global node j)

Definition at line 143 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize(), PorousFlowAdvectiveFluxCalculatorBase::getdFluxOut_dvars(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_dgrad_p_dgrad_var

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowAdvectiveFluxCalculatorBase::_dgrad_p_dgrad_var

protectedinherited

Derivative of Grad porepressure in each phase wrt grad(PorousFlow variables)

Definition at line 119 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_dgrad_p_dvar

const MaterialProperty<std::vector<std::vector<RealGradient> > >& PorousFlowAdvectiveFluxCalculatorBase::_dgrad_p_dvar

protectedinherited

Derivative of Grad porepressure in each phase wrt PorousFlow variables.

Definition at line 122 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_dictator

const PorousFlowDictator& PorousFlowAdvectiveFluxCalculatorBase::_dictator

protectedinherited

PorousFlowDictator UserObject.

Definition at line 89 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent().

_dkij_dvar

std::map<dof_id_type, std::map<dof_id_type, std::map<dof_id_type, std::vector<Real> > > > PorousFlowAdvectiveFluxCalculatorBase::_dkij_dvar

protectedinherited

_dkij_dvar[i][j][k][a] = d(K[global node i][global node j])/d(porous_flow_variable[global_node k][porous_flow_variable a])

Definition at line 140 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement(), PorousFlowAdvectiveFluxCalculatorBase::getdK_dvar(), PorousFlowAdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_dmass_fractions_dvar

const MaterialProperty<std::vector<std::vector<std::vector<Real> > > >& PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::_dmass_fractions_dvar

protectedinherited

Derivative of the mass fraction of each component in each phase wrt PorousFlow variables.

Definition at line 43 of file PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computedU_dvar().

_dpermeability_dgradvar

const MaterialProperty<std::vector<std::vector<RealTensorValue> > >& PorousFlowAdvectiveFluxCalculatorBase::_dpermeability_dgradvar

protectedinherited

d(permeabiity)/d(grad(PorousFlow variable))

Definition at line 107 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_dpermeability_dvar

const MaterialProperty<std::vector<RealTensorValue> >& PorousFlowAdvectiveFluxCalculatorBase::_dpermeability_dvar

protectedinherited

d(permeabiity)/d(PorousFlow variable)

Definition at line 104 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_drelative_permeability_dvar

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent::_drelative_permeability_dvar

protected

Derivative of relative permeability of each phase wrt PorousFlow variables.

Definition at line 42 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.h.

Referenced by computedU_dvar().

_du_dvar

std::map<dof_id_type, std::vector<Real> > PorousFlowAdvectiveFluxCalculatorBase::_du_dvar

protectedinherited

_du_dvar[i][a] = d(u[global node i])/d(porous_flow_variable[a])

Definition at line 134 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::execute(), PorousFlowAdvectiveFluxCalculatorBase::getdU_dvar(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_du_dvar_computed_by_thread

std::map<dof_id_type, bool> PorousFlowAdvectiveFluxCalculatorBase::_du_dvar_computed_by_thread

protectedinherited

Whether _du_dvar has been computed by the local thread.

Definition at line 137 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::execute(), PorousFlowAdvectiveFluxCalculatorBase::getdU_dvarComputedByThread(), PorousFlowAdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_fe_type

const FEType PorousFlowAdvectiveFluxCalculatorBase::_fe_type

protectedinherited

FEType to use.

Definition at line 125 of file PorousFlowAdvectiveFluxCalculatorBase.h.

_fluid_component

const unsigned int PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::_fluid_component

protectedinherited

The fluid component.

Definition at line 37 of file PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computedU_dvar(), PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computeU(), and PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent().

_fluid_density_node

const MaterialProperty<std::vector<Real> >* const PorousFlowAdvectiveFluxCalculatorSaturated::_fluid_density_node

protectedinherited

Fluid density for each phase (at the node)

Definition at line 39 of file PorousFlowAdvectiveFluxCalculatorSaturated.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturated::computeU().

_fluid_density_qp

const MaterialProperty<std::vector<Real> >& PorousFlowAdvectiveFluxCalculatorBase::_fluid_density_qp

protectedinherited

Fluid density for each phase (at the qp)

Definition at line 110 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_fluid_viscosity

const MaterialProperty<std::vector<Real> >& PorousFlowAdvectiveFluxCalculatorSaturated::_fluid_viscosity

protectedinherited

Viscosity of each component in each phase.

Definition at line 45 of file PorousFlowAdvectiveFluxCalculatorSaturated.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturated::computedU_dvar(), and PorousFlowAdvectiveFluxCalculatorSaturated::computeU().

_flux_limiter_type

enum AdvectiveFluxCalculatorBase::FluxLimiterTypeEnum AdvectiveFluxCalculatorBase::_flux_limiter_type

protectedinherited

Referenced by AdvectiveFluxCalculatorBase::limitFlux(), AdvectiveFluxCalculatorBase::rMinus(), and AdvectiveFluxCalculatorBase::rPlus().

_flux_out

std::map<dof_id_type, Real> AdvectiveFluxCalculatorBase::_flux_out

protectedinherited

_flux_out[i] = flux of "heat" from node i

Definition at line 173 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::getFluxOut(), and AdvectiveFluxCalculatorBase::timestepSetup().

_grad_p

const MaterialProperty<std::vector<RealGradient> >& PorousFlowAdvectiveFluxCalculatorBase::_grad_p

protectedinherited

Gradient of the pore pressure in each phase.

Definition at line 116 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_grad_phi

const VariablePhiGradient& PorousFlowAdvectiveFluxCalculatorBase::_grad_phi

protectedinherited

grad(Kuzmin-Turek shape function)

Definition at line 131 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_gravity

const RealVectorValue PorousFlowAdvectiveFluxCalculatorBase::_gravity

protectedinherited

Gravity.

Definition at line 95 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_kij

std::map<dof_id_type, std::map<dof_id_type, Real> > AdvectiveFluxCalculatorBase::_kij

protectedinherited

Kuzmin-Turek K_ij matrix.

Along with R+ and R-, this is the key quantity computed by this UserObject. _kij[i][j] = k_ij corresponding to the i-j node pair. Because it explicitly holds info which nodes are paired with which other nodes, it is also used to perform: given a node_id, loop over all neighbouring nodes. This occurs in the computation of R+ and R-.

Definition at line 170 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::executeOnElement(), AdvectiveFluxCalculatorBase::finalize(), PorousFlowAdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::getKij(), AdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::initialize(), AdvectiveFluxCalculatorBase::PQPlusMinus(), AdvectiveFluxCalculatorBase::threadJoin(), AdvectiveFluxCalculatorBase::timestepSetup(), PorousFlowAdvectiveFluxCalculatorBase::timestepSetup(), and AdvectiveFluxCalculatorBase::zeroedConnection().

_mass_fractions

const MaterialProperty<std::vector<std::vector<Real> > >& PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::_mass_fractions

protectedinherited

Mass fraction of each component in each phase.

Definition at line 40 of file PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computedU_dvar(), and PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computeU().

_multiply_by_density

const bool PorousFlowAdvectiveFluxCalculatorSaturated::_multiply_by_density

protectedinherited

Whether to multiply the flux by the fluid density.

Definition at line 36 of file PorousFlowAdvectiveFluxCalculatorSaturated.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturated::computedU_dvar(), and PorousFlowAdvectiveFluxCalculatorSaturated::computeU().

_num_vars

const unsigned PorousFlowAdvectiveFluxCalculatorBase::_num_vars

protectedinherited

Number of PorousFlow variables.

Definition at line 92 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::execute(), PorousFlowAdvectiveFluxCalculatorBase::executeOnElement(), PorousFlowAdvectiveFluxCalculatorBase::finalize(), PorousFlowAdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_permeability

const MaterialProperty<RealTensorValue>& PorousFlowAdvectiveFluxCalculatorBase::_permeability

protectedinherited

Permeability of porous material.

Definition at line 101 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_phase

const unsigned int PorousFlowAdvectiveFluxCalculatorBase::_phase

protectedinherited

The phase.

Definition at line 98 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorSaturated::computedU_dvar(), PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computedU_dvar(), PorousFlowAdvectiveFluxCalculatorSaturatedHeat::computedU_dvar(), PorousFlowAdvectiveFluxCalculatorUnsaturated::computedU_dvar(), computedU_dvar(), PorousFlowAdvectiveFluxCalculatorUnsaturatedHeat::computedU_dvar(), PorousFlowAdvectiveFluxCalculatorSaturated::computeU(), PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::computeU(), PorousFlowAdvectiveFluxCalculatorSaturatedHeat::computeU(), PorousFlowAdvectiveFluxCalculatorUnsaturated::computeU(), computeU(), PorousFlowAdvectiveFluxCalculatorUnsaturatedHeat::computeU(), PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_phi

const VariablePhiValue& PorousFlowAdvectiveFluxCalculatorBase::_phi

protectedinherited

Kuzmin-Turek shape function.

Definition at line 128 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::computeVelocity(), and PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

_relative_permeability

const MaterialProperty<std::vector<Real> >& PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent::_relative_permeability

protected

Relative permeability of each phase.

Definition at line 39 of file PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.h.

Referenced by computedU_dvar(), and computeU().

_resizing_needed

bool AdvectiveFluxCalculatorBase::_resizing_needed

protectedinherited

whether _kij, etc, need to be sized appropriately (and valence recomputed) at the start of the timestep

Definition at line 116 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::meshChanged(), AdvectiveFluxCalculatorBase::timestepSetup(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

_u_nodal

std::map<dof_id_type, Real> AdvectiveFluxCalculatorBase::_u_nodal

protectedinherited

_u_nodal[i] = value of _u at global node number i

Definition at line 187 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::execute(), AdvectiveFluxCalculatorBase::getUnodal(), AdvectiveFluxCalculatorBase::threadJoin(), and AdvectiveFluxCalculatorBase::timestepSetup().

_u_nodal_computed_by_thread

std::map<dof_id_type, bool> AdvectiveFluxCalculatorBase::_u_nodal_computed_by_thread

protectedinherited

_u_nodal_computed_by_thread[i] = true if _u_nodal[i] has been computed in execute() by the thread on this processor

Definition at line 190 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::execute(), AdvectiveFluxCalculatorBase::getUnodalComputedByThread(), AdvectiveFluxCalculatorBase::initialize(), AdvectiveFluxCalculatorBase::threadJoin(), and AdvectiveFluxCalculatorBase::timestepSetup().

_valence

std::map<std::pair<dof_id_type, dof_id_type>, unsigned> AdvectiveFluxCalculatorBase::_valence

protectedinherited

_valence[(i, j)] = number of times, in a loop over elements seen by this processor (viz, including ghost elements) and are part of the block-restricted blocks of this UserObject, that the i-j edge is encountered

Definition at line 184 of file AdvectiveFluxCalculatorBase.h.

Referenced by AdvectiveFluxCalculatorBase::getValence(), and AdvectiveFluxCalculatorBase::timestepSetup().

---

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

• porous_flow/include/userobjects/PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.h
• porous_flow/src/userobjects/PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent.C