AdvectiveFluxCalculatorBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "ElementUserObject.h"
#include "PorousFlowConnectedNodes.h"
 
class AdvectiveFluxCalculatorBase;
 
template <>
InputParameters validParams<AdvectiveFluxCalculatorBase>();
 
class AdvectiveFluxCalculatorBase : public ElementUserObject
{
public:
  AdvectiveFluxCalculatorBase(const InputParameters & parameters);
 
  virtual void timestepSetup() override;
 
  virtual void meshChanged() override;
 
  virtual void initialize() override;
 
  virtual void threadJoin(const UserObject & uo) override;
 
  virtual void finalize() override;
 
  virtual void execute() override;
 
  virtual void executeOnElement(
      dof_id_type global_i, dof_id_type global_j, unsigned local_i, unsigned local_j, unsigned qp);
 
  Real getFluxOut(dof_id_type node_i) const;
 
  const std::map<dof_id_type, Real> & getdFluxOutdu(dof_id_type node_i) const;
 
  const std::vector<std::vector<Real>> & getdFluxOutdKjk(dof_id_type node_i) const;
 
  unsigned getValence(dof_id_type node_i) const;
 
protected:
  virtual void buildCommLists();
 
  virtual void exchangeGhostedInfo();
 
  virtual Real computeVelocity(unsigned i, unsigned j, unsigned qp) const = 0;
 
  virtual Real computeU(unsigned i) const = 0;
 
  bool _resizing_needed;
 
  void limitFlux(Real a, Real b, Real & limited, Real & dlimited_db) const;
 
  Real rPlus(dof_id_type sequential_i,
             std::vector<Real> & dlimited_du,
             std::vector<Real> & dlimited_dk) const;
 
  Real rMinus(dof_id_type sequential_i,
              std::vector<Real> & dlimited_du,
              std::vector<Real> & dlimited_dk) const;
 
  const enum class FluxLimiterTypeEnum { MinMod, VanLeer, MC, superbee, None } _flux_limiter_type;
 
  std::vector<std::vector<Real>> _kij;
 
  std::vector<Real> _flux_out;
 
  std::vector<std::map<dof_id_type, Real>> _dflux_out_du;
 
  std::vector<std::vector<std::vector<Real>>> _dflux_out_dKjk;
 
  std::vector<unsigned> _valence;
 
  std::vector<Real> _u_nodal;
 
  std::vector<bool> _u_nodal_computed_by_thread;
 
  PorousFlowConnectedNodes _connections;
 
  std::size_t _number_of_nodes;
 
  processor_id_type _my_pid;
 
  std::map<processor_id_type, std::vector<dof_id_type>> _nodes_to_receive;
 
  std::map<processor_id_type, std::vector<dof_id_type>> _nodes_to_send;
 
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, dof_id_type>>> _pairs_to_receive;
 
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, dof_id_type>>> _pairs_to_send;
 
  const Real _allowable_MB_wastage;
 
  enum class PQPlusMinusEnum
  {
    PPlus,
    PMinus,
    QPlus,
    QMinus
  };
 
  Real PQPlusMinus(dof_id_type sequential_i,
                   const PQPlusMinusEnum pq_plus_minus,
                   std::vector<Real> & derivs,
                   std::vector<Real> & dpq_dk) const;
 
  void zeroedConnection(std::map<dof_id_type, Real> & the_map, dof_id_type node_i) const;
 
  std::vector<std::vector<Real>> _dij;
  std::vector<std::vector<Real>> _dDij_dKij;
  std::vector<std::vector<Real>> _dDij_dKji;
  std::vector<std::vector<Real>> _dDii_dKij;
  std::vector<std::vector<Real>> _dDii_dKji;
 
  std::vector<std::vector<Real>> _lij;
  std::vector<Real> _rP;
  std::vector<Real> _rM;
 
  std::vector<std::vector<Real>> _drP;
  std::vector<std::vector<Real>> _drM;
  std::vector<std::vector<Real>> _drP_dk;
  std::vector<std::vector<Real>> _drM_dk;
 
  std::vector<std::vector<Real>> _fa;
  std::vector<std::vector<std::map<dof_id_type, Real>>> _dfa;
  std::vector<std::vector<std::vector<Real>>> _dFij_dKik;
  std::vector<std::vector<std::vector<Real>>> _dFij_dKjk;
};