Advection of a quantity with velocity set in the PorousFlowAdvectiveFluxCalculator Depending on the PorousFlowAdvectiveFluxCalculator, the quantity may be either a fluid component in a fluid phase, or heat energy in a fluid phase. More...

#include <PorousFlowFluxLimitedTVDAdvection.h>

Inheritance diagram for PorousFlowFluxLimitedTVDAdvection:

[legend]

Public Member Functions
	PorousFlowFluxLimitedTVDAdvection (const InputParameters &parameters)

Protected Member Functions
virtual Real	computeQpResidual () override

virtual void	computeResidual () override

virtual void	computeJacobian () override

Protected Attributes
const PorousFlowDictator &	_dictator
	PorousFlowDictator UserObject. More...

const PorousFlowAdvectiveFluxCalculatorBase &	_fluo
	The user object that computes Kuzmin and Turek's K_ij, R+ and R-, etc quantities. More...

Detailed Description

Advection of a quantity with velocity set in the PorousFlowAdvectiveFluxCalculator Depending on the PorousFlowAdvectiveFluxCalculator, the quantity may be either a fluid component in a fluid phase, or heat energy in a fluid phase.

This implements the flux-limited TVD scheme detailed in D Kuzmin and S Turek "High-resolution FEM-TVD schemes based on a fully multidimensional flux limiter" Journal of Computational Physics 198 (2004) 131-158

This is a simple class: it simply uses the quantities built and cached by PorousFlowAdvectiveFluxCalculator to build the residual and Jacobian

Definition at line 33 of file PorousFlowFluxLimitedTVDAdvection.h.

Constructor & Destructor Documentation

◆ PorousFlowFluxLimitedTVDAdvection()

PorousFlowFluxLimitedTVDAdvection::PorousFlowFluxLimitedTVDAdvection ( const InputParameters & parameters )

Definition at line 33 of file PorousFlowFluxLimitedTVDAdvection.C.

   : Kernel(parameters),
     _dictator(getUserObject<PorousFlowDictator>("PorousFlowDictator")),
     _fluo(getUserObject<PorousFlowAdvectiveFluxCalculatorBase>("advective_flux_calculator"))
 {
 }

Member Function Documentation

◆ computeJacobian()

void PorousFlowFluxLimitedTVDAdvection::computeJacobian ( )

overrideprotectedvirtual

Definition at line 72 of file PorousFlowFluxLimitedTVDAdvection.C.

 {
   prepareMatrixTag(_assembly, _var.number(), _var.number());
   precalculateJacobian();
  
   // Run through the nodes of this element using "i", getting the Jacobian contributions
   // d(residual_i)/du(node_j) for all nodes j that can have a nonzero Jacobian contribution.  Some
   // of these node_j will live in this element, but some will live in other elements connected with
   // node "i", and some will live in the next layer of nodes (eg, in 1D residual_3 could have
   // contributions from node1, node2, node3, node4 and node5).
   for (unsigned i = 0; i < _current_elem->n_nodes(); ++i)
   {
     // global id of node "i"
     const dof_id_type node_id_i = _current_elem->node_id(i);
     // dof number of _var on node "i"
     std::vector<dof_id_type> idof_indices(
         1, _current_elem->node_ref(i).dof_number(_sys.number(), _var.number(), 0));
     // number of times node "i" is encountered in a sweep over elements
     const unsigned valence = _fluo.getValence(node_id_i);
  
     // retrieve the derivative information from _fluo
     const std::map<dof_id_type, std::vector<Real>> derivs = _fluo.getdFluxOut_dvars(node_id_i);
  
     // now build up the dof numbers of all the "j" nodes and the derivative matrix
     // d(residual_i)/d(var_j)
     for (unsigned pvar = 0; pvar < _dictator.numVariables(); ++pvar)
     {
       const unsigned varnum = _dictator.mooseVariableNum(pvar);
       std::vector<dof_id_type> jdof_indices(derivs.size());
       DenseMatrix<Number> deriv_matrix(1, derivs.size());
       unsigned j = 0;
       for (const auto & node_j_deriv : derivs)
       {
         // global id of j:
         const dof_id_type node_id_j = node_j_deriv.first;
         // dof of pvar at node j:
         jdof_indices[j] = _mesh.getMesh().node_ref(node_id_j).dof_number(_sys.number(), varnum, 0);
         // derivative must be divided by valence, otherwise the loop over elements will
         // multiple-count
         deriv_matrix(0, j) = node_j_deriv.second[pvar] / valence;
         j++;
       }
       // Add the result to the system's Jacobian matrix
       _assembly.cacheJacobianBlock(deriv_matrix, idof_indices, jdof_indices, _var.scalingFactor());
     }
   }
 }

◆ computeQpResidual()

Real PorousFlowFluxLimitedTVDAdvection::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 42 of file PorousFlowFluxLimitedTVDAdvection.C.

 {
   mooseError("PorousFlowFluxLimitedTVDAdvection::computeQpResidual() called\n");
   return 0.0;
 }

◆ computeResidual()

void PorousFlowFluxLimitedTVDAdvection::computeResidual ( )

overrideprotectedvirtual

Definition at line 49 of file PorousFlowFluxLimitedTVDAdvection.C.

 {
   prepareVectorTag(_assembly, _var.number());
   precalculateResidual();
  
   // get the residual contributions from _fluo
   for (unsigned i = 0; i < _current_elem->n_nodes(); ++i)
   {
     const dof_id_type node_id_i = _current_elem->node_id(i);
     _local_re(i) = _fluo.getFluxOut(node_id_i) / _fluo.getValence(node_id_i);
   }
  
   accumulateTaggedLocalResidual();
  
   if (_has_save_in)
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     for (unsigned int i = 0; i < _save_in.size(); i++)
       _save_in[i]->sys().solution().add_vector(_local_re, _save_in[i]->dofIndices());
   }
 }