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