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 : public ElementUserObject
{
public:
  static InputParameters validParams();

  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;
};