KokkosVariable.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 "KokkosTypes.h"
 
#include "MooseTypes.h"
#include "MooseVariableFieldBase.h"
#include "MooseVariableScalar.h"
#include "MoosePassKey.h"
 
class Coupleable;
class ScalarCoupleable;
 
namespace Moose::Kokkos
{
 
class Variable
{
public:
  using CoupleableKey = ::Moose::PassKey<::Coupleable>;
  using ScalarCoupleableKey = ::Moose::PassKey<::ScalarCoupleable>;
 
  Variable() = default;
  Variable(const MooseVariableBase & variable, const TagID tag) { init(variable, tag); }
  Variable(const MooseVariableBase & variable, const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variable, tag_name);
  }
  Variable(const std::vector<const MooseVariableBase *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
  Variable(const std::vector<MooseVariableBase *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
  Variable(const std::vector<const MooseVariableFieldBase *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
  Variable(const std::vector<MooseVariableFieldBase *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
  Variable(const std::vector<const MooseVariableScalar *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
  Variable(const std::vector<MooseVariableScalar *> & variables, const TagID tag)
  {
    init(variables, tag);
  }
 
  Variable(const std::vector<const MooseVariableBase *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
  Variable(const std::vector<MooseVariableBase *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
  Variable(const std::vector<const MooseVariableFieldBase *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
  Variable(const std::vector<MooseVariableFieldBase *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
  Variable(const std::vector<const MooseVariableScalar *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
  Variable(const std::vector<MooseVariableScalar *> & variables,
           const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variables, tag_name);
  }
 
  void init(const MooseVariableBase & variable, const TagID tag);
  void init(const MooseVariableBase & variable, const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<const MooseVariableBase *> & variables, const TagID tag);
  void init(const std::vector<MooseVariableBase *> & variables, const TagID tag)
  {
    init(std::vector<const MooseVariableBase *>(variables.begin(), variables.end()), tag);
  }
  void init(const std::vector<const MooseVariableFieldBase *> & variables, const TagID tag)
  {
    init(std::vector<const MooseVariableBase *>(variables.begin(), variables.end()), tag);
  }
  void init(const std::vector<MooseVariableFieldBase *> & variables, const TagID tag)
  {
    init(std::vector<const MooseVariableBase *>(variables.begin(), variables.end()), tag);
  }
  void init(const std::vector<const MooseVariableScalar *> & variables, const TagID tag)
  {
    init(std::vector<const MooseVariableBase *>(variables.begin(), variables.end()), tag);
  }
  void init(const std::vector<MooseVariableScalar *> & variables, const TagID tag)
  {
    init(std::vector<const MooseVariableBase *>(variables.begin(), variables.end()), tag);
  }
 
  void init(const std::vector<const MooseVariableBase *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<MooseVariableBase *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<const MooseVariableFieldBase *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<MooseVariableFieldBase *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<const MooseVariableScalar *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<MooseVariableScalar *> & variables,
            const TagName & tag_name = Moose::SOLUTION_TAG);
 
  void init(const std::vector<Real> & values, CoupleableKey);
  void init(const std::vector<Real> & values, ScalarCoupleableKey);
 
  void init(const std::vector<Real3> & values, CoupleableKey);
 
  const MooseVariableBase * mooseVar(unsigned int comp = 0)
  {
    return _moose_var.size() ? _moose_var[comp] : nullptr;
  }
  const MooseVariableFieldBase * mooseFieldVar(unsigned int comp = 0)
  {
    return _moose_var.size() ? dynamic_cast<const MooseVariableFieldBase *>(_moose_var[comp])
                             : nullptr;
  }
  const MooseVariableScalar * mooseScalarVar(unsigned int comp = 0)
  {
    return _moose_var.size() ? dynamic_cast<const MooseVariableScalar *>(_moose_var[comp])
                             : nullptr;
  }
 
  KOKKOS_FUNCTION bool initialized() const { return _initialized; }
  KOKKOS_FUNCTION bool coupled() const { return _coupled; }
  KOKKOS_FUNCTION bool nodal() const { return _nodal; }
  KOKKOS_FUNCTION bool scalar() const { return _scalar; }
  KOKKOS_FUNCTION bool dot() const { return _dot; }
  KOKKOS_FUNCTION bool old() const { return _old; }
  KOKKOS_FUNCTION bool vector() const { return _vector; }
  KOKKOS_FUNCTION unsigned int components() const { return _components; }
  KOKKOS_FUNCTION TagID tag() const { return _tag; }
  KOKKOS_FUNCTION unsigned int var(unsigned int comp = 0) const { return _var[comp]; }
  KOKKOS_FUNCTION unsigned int sys(unsigned int comp = 0) const { return _sys[comp]; }
  KOKKOS_FUNCTION Real value(unsigned int comp = 0) const
  {
    KOKKOS_ASSERT(!_coupled && !_vector);
 
    return _default_value[comp];
  }
  KOKKOS_FUNCTION Real3 vectorValue(unsigned int comp = 0) const
  {
    KOKKOS_ASSERT(!_coupled && _vector);
 
    return _default_vector_value[comp];
  }
 
private:
  bool _initialized = false;
  bool _coupled = false;
  bool _nodal = false;
  bool _scalar = false;
  bool _dot = false;
  bool _old = false;
  bool _vector = false;
  unsigned int _components = 1;
  TagID _tag = Moose::INVALID_TAG_ID;
  Array<const MooseVariableBase *> _moose_var;
  Array<unsigned int> _var;
  Array<unsigned int> _sys;
  Array<Real> _default_value;
  Array<Real3> _default_vector_value;
};
 
} // namespace Moose::Kokkos