FluxLimitedTVDAdvection Class Reference

Advection of the variable with velocity set in the AdvectiveFluxCalculator. More...

#include <FluxLimitedTVDAdvection.h>

Inheritance diagram for FluxLimitedTVDAdvection:

Public Member Functions
	FluxLimitedTVDAdvection (const InputParameters &parameters)

Protected Member Functions
virtual Real	computeQpResidual () override
virtual void	computeResidual () override
virtual void	computeJacobian () override

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

Detailed Description

Advection of the variable with velocity set in the AdvectiveFluxCalculator.

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

Use the quantities built and cached by AdvectiveFluxCalculator to build the residual and Jacobian contributions corresponding to Kuzmin and Turek's stabilized advection

Definition at line 32 of file FluxLimitedTVDAdvection.h.

Constructor & Destructor Documentation

FluxLimitedTVDAdvection()

FluxLimitedTVDAdvection::FluxLimitedTVDAdvection

(

const InputParameters &

parameters

)

Definition at line 28 of file FluxLimitedTVDAdvection.C.

  : Kernel(parameters),
    _fluo(getUserObject<AdvectiveFluxCalculatorBase>("advective_flux_calculator"))
{
}

Member Function Documentation

computeJacobian()

void FluxLimitedTVDAdvection::computeJacobian ( )

overrideprotectedvirtual

Definition at line 65 of file FluxLimitedTVDAdvection.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, Real> derivs = _fluo.getdFluxOutdu(node_id_i);
 
    // now build up the dof numbers of all the "j" nodes and the derivative matrix
    // d(residual_i)/d(u_j)
    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 at node j:
      jdof_indices[j] =
          _mesh.getMesh().node_ref(node_id_j).dof_number(_sys.number(), _var.number(), 0);
      // derivative must be divided by valence, otherwise the loop over elements will multiple-count
      deriv_matrix(0, j) = node_j_deriv.second / valence;
      j++;
    }
    // Add the result to the system's Jacobian matrix
    _assembly.cacheJacobianBlock(deriv_matrix, idof_indices, jdof_indices, _var.scalingFactor());
  }
}

computeQpResidual()

Real FluxLimitedTVDAdvection::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 35 of file FluxLimitedTVDAdvection.C.

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

computeResidual()

void FluxLimitedTVDAdvection::computeResidual ( )

overrideprotectedvirtual

Definition at line 42 of file FluxLimitedTVDAdvection.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());
  }
}

Member Data Documentation

_fluo

const AdvectiveFluxCalculatorBase& FluxLimitedTVDAdvection::_fluo

protected

The user object that computes Kuzmin and Turek's K_ij, R+ and R-, etc quantities.

Definition at line 43 of file FluxLimitedTVDAdvection.h.

Referenced by computeJacobian(), and computeResidual().

---

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

• porous_flow/include/kernels/FluxLimitedTVDAdvection.h
• porous_flow/src/kernels/FluxLimitedTVDAdvection.C