ScalarCoupleable.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "Moose.h"
 
// MOOSE includes
#include "MooseVariableBase.h"
 
// C++ includes
#include <unordered_map>
#include <string>
#include <vector>
 
// Forward declarations
class FEProblemBase;
class InputParameters;
class MooseObject;
class MooseVariableScalar;
 
class ScalarCoupleable
{
public:
  ScalarCoupleable(const MooseObject * moose_object);
 
#ifdef MOOSE_KOKKOS_ENABLED
  ScalarCoupleable(const ScalarCoupleable & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  const std::vector<MooseVariableScalar *> & getCoupledMooseScalarVars()
  {
    return _coupled_moose_scalar_vars;
  }
 
  const std::set<TagID> & getScalarVariableCoupleableVectorTags() const
  {
    return _sc_coupleable_vector_tags;
  }
 
  const std::set<TagID> & getScalarVariableCoupleableMatrixTags() const
  {
    return _sc_coupleable_matrix_tags;
  }
 
protected:
  bool isCoupledScalar(const std::string & var_name, unsigned int i = 0) const;
 
  unsigned int coupledScalarComponents(const std::string & var_name) const;
 
  unsigned int coupledScalar(const std::string & var_name, unsigned int comp = 0) const;
 
  libMesh::Order coupledScalarOrder(const std::string & var_name, unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarValue(const std::string & var_name,
                                           unsigned int comp = 0) const;
 
  const ADVariableValue & adCoupledScalarValue(const std::string & var_name,
                                               unsigned int comp = 0) const;
 
  template <bool is_ad>
  const GenericVariableValue<is_ad> & coupledGenericScalarValue(const std::string & var_name,
                                                                unsigned int comp = 0) const;
 
  const VariableValue &
  coupledVectorTagScalarValue(const std::string & var_name, TagID tag, unsigned int comp = 0) const;
 
  const VariableValue &
  coupledMatrixTagScalarValue(const std::string & var_name, TagID tag, unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarValueOld(const std::string & var_name,
                                              unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarValueOlder(const std::string & var_name,
                                                unsigned int comp = 0) const;
  const VariableValue & coupledScalarDot(const std::string & var_name, unsigned int comp = 0) const;
 
  const ADVariableValue & adCoupledScalarDot(const std::string & var_name,
                                             unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarDotDot(const std::string & var_name,
                                            unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarDotOld(const std::string & var_name,
                                            unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarDotDotOld(const std::string & var_name,
                                               unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarDotDu(const std::string & var_name,
                                           unsigned int comp = 0) const;
 
  const VariableValue & coupledScalarDotDotDu(const std::string & var_name,
                                              unsigned int comp = 0) const;
 
  const MooseVariableScalar * getScalarVar(const std::string & var_name, unsigned int comp) const;
 
protected:
  // Reference to FEProblemBase
  FEProblemBase & _sc_fe_problem;
 
  const THREAD_ID _sc_tid;
 
  const Real & _real_zero;
 
  const VariableValue & _scalar_zero;
 
  const Point & _point_zero;
 
private:
  const VariableValue * getDefaultValue(const std::string & var_name) const;
 
  const ADVariableValue * getADDefaultValue(const std::string & var_name) const;
 
  void checkVar(const std::string & var_name) const;
 
  void validateExecutionerType(const std::string & name, const std::string & fn_name) const;
 
  // Reference to the interface's input parameters
  const InputParameters & _sc_parameters;
 
  const std::string & _sc_name;
 
  const bool _sc_is_implicit;
 
  std::unordered_map<std::string, std::vector<MooseVariableScalar *>> _coupled_scalar_vars;
 
  mutable std::unordered_map<std::string, std::unique_ptr<VariableValue>> _default_value;
 
  mutable std::unordered_map<std::string, std::unique_ptr<ADVariableValue>> _dual_default_value;
 
  std::vector<MooseVariableScalar *> _coupled_moose_scalar_vars;
 
  std::unordered_map<std::string, std::vector<MooseVariableFieldBase *>> _sc_coupled_vars;
 
  mutable std::set<TagID> _sc_coupleable_vector_tags;
  mutable std::set<TagID> _sc_coupleable_matrix_tags;
};