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::vector< std::vector< Real > > &	getdFluxOutdKjk (dof_id_type node_i) const
	Returns r where r[j][k] = d(flux out of global node i)/dK[connected node j][connected node k] used in Jacobian computations. More...

unsigned	getValence (dof_id_type node_i) const
	Returns the valence of the global node i Valence is the number of times the node 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) 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::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]) 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 sequential_i, std::vector< Real > &dlimited_du, std::vector< Real > &dlimited_dk) const
	Returns the value of R_{i}^{+}, Eqn (49) of KT. More...

Real	rMinus (dof_id_type sequential_i, std::vector< Real > &dlimited_du, std::vector< Real > &dlimited_dk) const
	Returns the value of R_{i}^{-}, Eqn (49) of KT. More...

Real	PQPlusMinus (dof_id_type sequential_i, const PQPlusMinusEnum pq_plus_minus, std::vector< Real > &derivs, std::vector< 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...

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::vector< std::vector< Real > >	_du_dvar
	_du_dvar[sequential_i][a] = d(u[global version of sequential node i])/d(porous_flow_variable[a]) More...

std::vector< bool >	_du_dvar_computed_by_thread
	Whether _du_dvar has been computed by the local thread. More...

std::vector< std::vector< std::map< dof_id_type, std::vector< Real > > > >	_dkij_dvar
	_dkij_dvar[sequential_i][j][global_k][a] = d(K[sequential_i][j])/d(porous_flow_variable[global_k][porous_flow_variable a]) Here j is the j^th connection to sequential node sequential_i, and node k must be connected to node i More...

std::vector< std::map< dof_id_type, std::vector< Real > > >	_dflux_out_dvars
	_dflux_out_dvars[sequential_i][global_j][pvar] = d(flux_out[global version of sequential_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::vector< std::vector< Real > >	_kij
	Kuzmin-Turek K_ij matrix. More...

std::vector< Real >	_flux_out
	_flux_out[i] = flux of "heat" from sequential node i More...

std::vector< std::map< dof_id_type, Real > >	_dflux_out_du
	_dflux_out_du[i][j] = d(flux_out[i])/d(u[j]). More...

std::vector< std::vector< std::vector< Real > > >	_dflux_out_dKjk
	_dflux_out_dKjk[sequential_i][j][k] = d(flux_out[sequential_i])/d(K[j][k]). More...

std::vector< unsigned >	_valence
	_valence[i] = 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 sequential node i is encountered More...

std::vector< Real >	_u_nodal
	_u_nodal[i] = value of _u at sequential node number i More...

std::vector< 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...

PorousFlowConnectedNodes	_connections
	Holds the sequential and global nodal IDs, and info regarding mesh connections between them. More...

std::size_t	_number_of_nodes
	Number of nodes held by the _connections object. 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 154 of file AdvectiveFluxCalculatorBase.h.

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

AdvectiveFluxCalculatorBase::_flux_limiter_type

enum AdvectiveFluxCalculatorBase::FluxLimiterTypeEnum _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 195 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
   // - computedU_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 182 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 global_i = _current_elem->node_id(i);
     const dof_id_type sequential_i = _connections.sequentialID(global_i);
     if (_du_dvar_computed_by_thread[sequential_i])
       continue;
     for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
       _du_dvar[sequential_i][pvar] = computedU_dvar(i, pvar);
     _du_dvar_computed_by_thread[sequential_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);
   const dof_id_type sequential_i = _connections.sequentialID(global_i);
   const unsigned j = _connections.indexOfGlobalConnection(global_i, global_j);
 
   // 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[sequential_i][j][global_k][pvar] +=
           _JxW[qp] * _coord[qp] * (-_grad_phi[local_i][qp] * deriv * _phi[local_j][qp]);
     }
   }
 }

◆ finalize()

void PorousFlowAdvectiveFluxCalculatorBase::finalize ( )

overrideprotectedvirtualinherited

_dflux_out_dvars[sequential_i][global_j][pvar] = d(flux_out[global version of sequential_i])/d(porous_flow_variable pvar at global node j)

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 243 of file PorousFlowAdvectiveFluxCalculatorBase.C.

 {
   AdvectiveFluxCalculatorBase::finalize();
 
   // compute d(flux_out)/d(porous flow variable)
   for (const auto & node_i : _connections.globalIDs())
   {
     const dof_id_type sequential_i = _connections.sequentialID(node_i);
     _dflux_out_dvars[sequential_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[sequential_i][j] = _du_dvar[_connections.sequentialID(j)];
       for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
         _dflux_out_dvars[sequential_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::vector<std::vector<Real>> dflux_out_dKjk =
         AdvectiveFluxCalculatorBase::getdFluxOutdKjk(node_i);
     const std::vector<dof_id_type> con_i = _connections.globalConnectionsToGlobalID(node_i);
     for (std::size_t index_j = 0; index_j < con_i.size(); ++index_j)
     {
       const dof_id_type node_j = con_i[index_j];
       const std::vector<dof_id_type> con_j = _connections.globalConnectionsToGlobalID(node_j);
       for (std::size_t index_k = 0; index_k < con_j.size(); ++index_k)
       {
         const dof_id_type node_k = con_j[index_k];
         const Real dflux_out_dK_jk = dflux_out_dKjk[index_j][index_k];
         const std::map<dof_id_type, std::vector<Real>> dkj_dvarl = getdK_dvar(node_j, node_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[sequential_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 237 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowFluxLimitedTVDAdvection::computeJacobian().

 {
   return _dflux_out_dvars[_connections.sequentialID(node_id)];
 }

◆ getdFluxOutdKjk()

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

inherited

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

Parameters

node_i global id of node

Returns: the derivatives (after applying the KT procedure)

Definition at line 737 of file AdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

 {
   return _dflux_out_dKjk[_connections.sequentialID(node_i)];
 }

◆ 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 731 of file AdvectiveFluxCalculatorBase.C.

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

 {
   return _dflux_out_du[_connections.sequentialID(node_i)];
 }

◆ 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])

Parameters

node_i global node id param node_j global node id

Definition at line 229 of file PorousFlowAdvectiveFluxCalculatorBase.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

 {
   const dof_id_type sequential_i = _connections.sequentialID(node_i);
   const unsigned j = _connections.indexOfGlobalConnection(node_i, node_j);
   return _dkij_dvar[sequential_i][j];
 }

◆ 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 743 of file AdvectiveFluxCalculatorBase.C.

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

 {
   return _flux_out[_connections.sequentialID(node_i)];
 }

◆ getValence()

unsigned AdvectiveFluxCalculatorBase::getValence ( dof_id_type node_i ) const

inherited

Returns the valence of the global node i Valence is the number of times the node 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 gloal id of i^th node

Returns: valence of the node

Definition at line 749 of file AdvectiveFluxCalculatorBase.C.

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

 {
   return _valence[_connections.sequentialID(node_i)];
 }

◆ initialize()

void PorousFlowAdvectiveFluxCalculatorBase::initialize ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 165 of file PorousFlowAdvectiveFluxCalculatorBase.C.

 {
   AdvectiveFluxCalculatorBase::initialize();
   const std::size_t num_nodes = _connections.numNodes();
   _du_dvar_computed_by_thread.assign(num_nodes, false);
   for (dof_id_type sequential_i = 0; sequential_i < num_nodes; ++sequential_i)
   {
     const std::vector<dof_id_type> con_i =
         _connections.globalConnectionsToSequentialID(sequential_i);
     const std::size_t num_con_i = con_i.size();
     for (unsigned j = 0; j < num_con_i; ++j)
       for (const auto & global_neighbor_to_i : con_i)
         _dkij_dvar[sequential_i][j][global_neighbor_to_i] = 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 631 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	sequential_i,
		const PQPlusMinusEnum	pq_plus_minus,
		std::vector< Real > &	derivs,
		std::vector< 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

sequential_i	sequential 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[sequential_j]). Here sequential_j is the j^th connection to sequential_i
dpq_dk[out]	dpq_dk[j] = d(result)/d(K[node_i][j]). Here j indexes a connection to sequential_i. Recall that d(result)/d(K[l][m]) are zero unless l=sequential_i

Definition at line 764 of file AdvectiveFluxCalculatorBase.C.

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

 {
   // Find the value of u at sequential_i
   const Real u_i = _u_nodal[sequential_i];
 
   // Connections to sequential_i
   const std::vector<dof_id_type> con_i =
       _connections.sequentialConnectionsToSequentialID(sequential_i);
   const std::size_t num_con = con_i.size();
   // The neighbor number of sequential_i to sequential_i
   const unsigned i_index_i = _connections.indexOfSequentialConnection(sequential_i, sequential_i);
 
   // Initialize the results
   Real result = 0.0;
   derivs.assign(num_con, 0.0);
   dpqdk.assign(num_con, 0.0);
 
   // Sum over all nodes connected with node_i.
   for (std::size_t j = 0; j < num_con; ++j)
   {
     const dof_id_type sequential_j = con_i[j];
     if (sequential_j == sequential_i)
       continue;
     const Real kentry = _kij[sequential_i][j];
 
     // Find the value of u at node_j
     const Real u_j = _u_nodal[sequential_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[j] += kentry;
           derivs[i_index_i] -= kentry;
           dpqdk[j] += ujminusi;
         }
         break;
       }
       case PQPlusMinusEnum::PMinus:
       {
         if (ujminusi > 0.0 && kentry < 0.0)
         {
           result += kentry * ujminusi;
           derivs[j] += kentry;
           derivs[i_index_i] -= kentry;
           dpqdk[j] += ujminusi;
         }
         break;
       }
       case PQPlusMinusEnum::QPlus:
       {
         if (ujminusi > 0.0 && kentry > 0.0)
         {
           result += kentry * ujminusi;
           derivs[j] += kentry;
           derivs[i_index_i] -= kentry;
           dpqdk[j] += ujminusi;
         }
         break;
       }
       case PQPlusMinusEnum::QMinus:
       {
         if (ujminusi < 0.0 && kentry > 0.0)
         {
           result += kentry * ujminusi;
           derivs[j] += kentry;
           derivs[i_index_i] -= kentry;
           dpqdk[j] += ujminusi;
         }
         break;
       }
     }
   }
 
   return result;
 }

◆ rMinus()

Real AdvectiveFluxCalculatorBase::rMinus	(	dof_id_type	sequential_i,
		std::vector< Real > &	dlimited_du,
		std::vector< Real > &	dlimited_dk
	)		const

protectedinherited

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

Parameters

sequential_i	Sequential nodal ID
dlimited_du[out]	dlimited_du[j] = d(R_{sequential_i}^{-})/du[sequential_j]. Here sequential_j is the j^th connection to sequential_i
dlimited_dk[out]	dlimited_dk[j] = d(R_{sequential_i}^{-})/d(K[sequential_i][j]). Note Derivatives w.r.t. K[l][m] with l!=i are zero

Definition at line 595 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize().

 {
   const std::size_t num_con = _connections.sequentialConnectionsToSequentialID(sequential_i).size();
   dlimited_du.assign(num_con, 0.0);
   dlimited_dk.assign(num_con, 0.0);
   if (_flux_limiter_type == FluxLimiterTypeEnum::None)
     return 0.0;
   std::vector<Real> dp_du;
   std::vector<Real> dp_dk;
   const Real p = PQPlusMinus(sequential_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::vector<Real> dq_du;
   std::vector<Real> dq_dk;
   const Real q = PQPlusMinus(sequential_i, PQPlusMinusEnum::QMinus, dq_du, dq_dk);
 
   const Real r = q / p;
   Real limited;
   Real dlimited_dr;
   limitFlux(1.0, r, limited, dlimited_dr);
 
   const Real p2 = std::pow(p, 2);
   for (std::size_t j = 0; j < num_con; ++j)
   {
     const Real dr_du = dq_du[j] / p - q * dp_du[j] / p2;
     const Real dr_dk = dq_dk[j] / p - q * dp_dk[j] / p2;
     dlimited_du[j] = dlimited_dr * dr_du;
     dlimited_dk[j] = dlimited_dr * dr_dk;
   }
   return limited;
 }

◆ rPlus()

Real AdvectiveFluxCalculatorBase::rPlus	(	dof_id_type	sequential_i,
		std::vector< Real > &	dlimited_du,
		std::vector< 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[j] = d(R_{sequential_i}^{+})/du[sequential_j]. Here sequential_j is the j^th connection to sequential_i
dlimited_dk[out]	dlimited_dk[j] = d(R_{sequential_i}^{+})/d(K[sequential_i][j]). Note Derivatives w.r.t. K[l][m] with l!=i are zero

Definition at line 559 of file AdvectiveFluxCalculatorBase.C.

Referenced by AdvectiveFluxCalculatorBase::finalize().

 {
   const std::size_t num_con = _connections.sequentialConnectionsToSequentialID(sequential_i).size();
   dlimited_du.assign(num_con, 0.0);
   dlimited_dk.assign(num_con, 0.0);
   if (_flux_limiter_type == FluxLimiterTypeEnum::None)
     return 0.0;
   std::vector<Real> dp_du;
   std::vector<Real> dp_dk;
   const Real p = PQPlusMinus(sequential_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::vector<Real> dq_du;
   std::vector<Real> dq_dk;
   const Real q = PQPlusMinus(sequential_i, PQPlusMinusEnum::QPlus, dq_du, dq_dk);
 
   const Real r = q / p;
   Real limited;
   Real dlimited_dr;
   limitFlux(1.0, r, limited, dlimited_dr);
 
   const Real p2 = std::pow(p, 2);
   for (std::size_t j = 0; j < num_con; ++j)
   {
     const Real dr_du = dq_du[j] / p - q * dp_du[j] / p2;
     const Real dr_dk = dq_dk[j] / p - q * dp_dk[j] / p2;
     dlimited_du[j] = dlimited_dr * dr_du;
     dlimited_dk[j] = dlimited_dr * dr_dk;
   }
   return limited;
 }

◆ threadJoin()

void PorousFlowAdvectiveFluxCalculatorBase::threadJoin ( const UserObject & uo )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 202 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
   const std::size_t num_nodes = _connections.numNodes();
   for (dof_id_type sequential_i = 0; sequential_i < num_nodes; ++sequential_i)
   {
     const std::vector<dof_id_type> con_i =
         _connections.globalConnectionsToSequentialID(sequential_i);
     const std::size_t num_con_i = con_i.size();
     for (unsigned j = 0; j < num_con_i; ++j)
       for (const auto & global_derivs : pfafc._dkij_dvar[sequential_i][j])
         for (unsigned pvar = 0; pvar < _num_vars; ++pvar)
           _dkij_dvar[sequential_i][j][global_derivs.first][pvar] += global_derivs.second[pvar];
   }
 
   // gather the values of _du_dvar computed by different threads
   for (dof_id_type sequential_i = 0; sequential_i < _number_of_nodes; ++sequential_i)
     if (!_du_dvar_computed_by_thread[sequential_i] &&
         pfafc._du_dvar_computed_by_thread[sequential_i])
       _du_dvar[sequential_i] = pfafc._du_dvar[sequential_i];
 }

◆ timestepSetup()

void PorousFlowAdvectiveFluxCalculatorBase::timestepSetup ( )

overrideprotectedvirtualinherited

Reimplemented from AdvectiveFluxCalculatorBase.

Definition at line 133 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)
   {
     const std::size_t num_nodes = _connections.numNodes();
     _du_dvar.assign(num_nodes, std::vector<Real>(_num_vars, 0.0));
     _du_dvar_computed_by_thread.assign(num_nodes, false);
     _dflux_out_dvars.assign(num_nodes, std::map<dof_id_type, std::vector<Real>>());
     _dkij_dvar.resize(num_nodes);
     for (dof_id_type sequential_i = 0; sequential_i < num_nodes; ++sequential_i)
     {
       const std::vector<dof_id_type> con_i =
           _connections.globalConnectionsToSequentialID(sequential_i);
       const std::size_t num_con_i = con_i.size();
       _dkij_dvar[sequential_i].assign(num_con_i, std::map<dof_id_type, std::vector<Real>>());
       for (unsigned j = 0; j < num_con_i; ++j)
         for (const auto & global_neighbor_to_i : con_i)
           _dkij_dvar[sequential_i][j][global_neighbor_to_i] = 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::timestepSetup().

 {
   the_map.clear();
   for (const auto & node_j : _connections.globalConnectionsToGlobalID(node_i))
     the_map[node_j] = 0.0;
 }

Member Data Documentation

◆ _connections

PorousFlowConnectedNodes AdvectiveFluxCalculatorBase::_connections

protectedinherited

Holds the sequential and global nodal IDs, and info regarding mesh connections between them.

Definition at line 189 of file AdvectiveFluxCalculatorBase.h.

◆ _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 100 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::vector<std::vector<std::vector<Real> > > AdvectiveFluxCalculatorBase::_dflux_out_dKjk

protectedinherited

_dflux_out_dKjk[sequential_i][j][k] = d(flux_out[sequential_i])/d(K[j][k]).

Here sequential_i is a sequential node number according to the _connections object, and j represents the j^th node connected to i according to the _connections object, and k represents the k^th node connected to j according to the _connections object. Here j must be connected to i (this does include (the sequential version of j) == i), and k must be connected to j (this does include (the sequential version of k) = i and (the sequential version of k) == (sequential version of j)))

Definition at line 175 of file AdvectiveFluxCalculatorBase.h.

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

◆ _dflux_out_du

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

protectedinherited

_dflux_out_du[i][j] = d(flux_out[i])/d(u[j]).

Here i is a sequential node number according to the _connections object, and j (global ID) must be connected to i, or to a node that is connected to i.

Definition at line 168 of file AdvectiveFluxCalculatorBase.h.

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

◆ _dflux_out_dvars

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

protectedinherited

_dflux_out_dvars[sequential_i][global_j][pvar] = d(flux_out[global version of sequential_i])/d(porous_flow_variable pvar at global node j)

Definition at line 134 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 106 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 109 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::executeOnElement().

◆ _dictator

const PorousFlowDictator& PorousFlowAdvectiveFluxCalculatorBase::_dictator

protectedinherited

PorousFlowDictator UserObject.

Definition at line 76 of file PorousFlowAdvectiveFluxCalculatorBase.h.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::PorousFlowAdvectiveFluxCalculatorBase(), and PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent::PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent().

◆ _dkij_dvar

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

protectedinherited

_dkij_dvar[sequential_i][j][global_k][a] = d(K[sequential_i][j])/d(porous_flow_variable[global_k][porous_flow_variable a]) Here j is the j^th connection to sequential node sequential_i, and node k must be connected to node i

Definition at line 131 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 94 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 91 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::vector<std::vector<Real> > PorousFlowAdvectiveFluxCalculatorBase::_du_dvar

protectedinherited

_du_dvar[sequential_i][a] = d(u[global version of sequential node i])/d(porous_flow_variable[a])

Definition at line 121 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _du_dvar_computed_by_thread

std::vector<bool> PorousFlowAdvectiveFluxCalculatorBase::_du_dvar_computed_by_thread

protectedinherited

Whether _du_dvar has been computed by the local thread.

Definition at line 124 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _fe_type

const FEType PorousFlowAdvectiveFluxCalculatorBase::_fe_type

protectedinherited

FEType to use.

Definition at line 112 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 97 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::vector<Real> AdvectiveFluxCalculatorBase::_flux_out

protectedinherited

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

Definition at line 164 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 103 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 118 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _gravity

const RealVectorValue PorousFlowAdvectiveFluxCalculatorBase::_gravity

protectedinherited

Gravity.

Definition at line 82 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _kij

std::vector<std::vector<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. Here i is a sequential node numbers according to the _connections object, and j represents the j^th node connected to i according to the _connections object.

Definition at line 161 of file AdvectiveFluxCalculatorBase.h.

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

◆ _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 79 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _number_of_nodes

std::size_t AdvectiveFluxCalculatorBase::_number_of_nodes

protectedinherited

Number of nodes held by the _connections object.

Definition at line 192 of file AdvectiveFluxCalculatorBase.h.

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

◆ _permeability

const MaterialProperty<RealTensorValue>& PorousFlowAdvectiveFluxCalculatorBase::_permeability

protectedinherited

Permeability of porous material.

Definition at line 88 of file PorousFlowAdvectiveFluxCalculatorBase.h.

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

◆ _phase

const unsigned int PorousFlowAdvectiveFluxCalculatorBase::_phase

protectedinherited

The phase.

Definition at line 85 of file PorousFlowAdvectiveFluxCalculatorBase.h.

◆ _phi

const VariablePhiValue& PorousFlowAdvectiveFluxCalculatorBase::_phi

protectedinherited

Kuzmin-Turek shape function.

Definition at line 115 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 115 of file AdvectiveFluxCalculatorBase.h.

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

◆ _u_nodal

std::vector<Real> AdvectiveFluxCalculatorBase::_u_nodal

protectedinherited

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

Definition at line 183 of file AdvectiveFluxCalculatorBase.h.

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

◆ _u_nodal_computed_by_thread

std::vector<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 186 of file AdvectiveFluxCalculatorBase.h.

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

◆ _valence

std::vector<unsigned> AdvectiveFluxCalculatorBase::_valence

protectedinherited

_valence[i] = 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 sequential node i is encountered

Definition at line 180 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

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ FluxLimiterTypeEnum

◆ PQPlusMinusEnum

Constructor & Destructor Documentation

◆ PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent()

Member Function Documentation

◆ computedU_dvar()

◆ computeU()

◆ computeVelocity()

◆ execute()

◆ executeOnElement()

◆ finalize()

◆ getdFluxOut_dvars()

◆ getdFluxOutdKjk()

◆ getdFluxOutdu()

◆ getdK_dvar()

◆ getFluxOut()

◆ getValence()

◆ initialize()

◆ limitFlux()

◆ meshChanged()

◆ PQPlusMinus()

◆ rMinus()

◆ rPlus()

◆ threadJoin()

◆ timestepSetup()

◆ zeroedConnection()

Member Data Documentation

◆ _connections

◆ _dfluid_density_node_dvar

◆ _dfluid_density_qp_dvar

◆ _dfluid_viscosity_dvar

◆ _dflux_out_dKjk

◆ _dflux_out_du

◆ _dflux_out_dvars

◆ _dgrad_p_dgrad_var

◆ _dgrad_p_dvar

◆ _dictator

◆ _dkij_dvar

◆ _dmass_fractions_dvar

◆ _dpermeability_dgradvar

◆ _dpermeability_dvar

◆ _drelative_permeability_dvar

◆ _du_dvar

◆ _du_dvar_computed_by_thread

◆ _fe_type

◆ _fluid_component

◆ _fluid_density_node

◆ _fluid_density_qp

◆ _fluid_viscosity

◆ _flux_limiter_type

◆ _flux_out

◆ _grad_p

◆ _grad_phi

◆ _gravity

◆ _kij

◆ _mass_fractions

◆ _multiply_by_density

◆ _num_vars

◆ _number_of_nodes

◆ _permeability

◆ _phase

◆ _phi

◆ _relative_permeability

◆ _resizing_needed

◆ _u_nodal

◆ _u_nodal_computed_by_thread

◆ _valence