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 "MooseVariableBase.h"
#include "MoosePassKey.h"

class Coupleable;

namespace Moose::Kokkos
{

class Variable
{
public:
  using CoupleableKey = ::Moose::PassKey<::Coupleable>;

  Variable() = default;
  Variable(const MooseVariableFieldBase & variable, const TagID tag) { init(variable, tag); }
  Variable(const MooseVariableFieldBase & variable, const TagName & tag_name = Moose::SOLUTION_TAG)
  {
    init(variable, tag_name);
  }
  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 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);
  }

  void init(const MooseVariableFieldBase & variable, const TagID tag);
  void init(const MooseVariableFieldBase & variable,
            const TagName & tag_name = Moose::SOLUTION_TAG);
  void init(const std::vector<const MooseVariableFieldBase *> & variables, const TagID tag);
  void init(const std::vector<MooseVariableFieldBase *> & variables, const TagID 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<Real> & values, CoupleableKey);

  const MooseVariableFieldBase * mooseVar(unsigned int comp = 0)
  {
    return _moose_var.size() ? _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 dot() const { return _dot; }
  KOKKOS_FUNCTION bool old() const { return _old; }
  KOKKOS_FUNCTION unsigned int components() { 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);

    return _default_value[comp];
  }

private:
  bool _initialized = false;
  bool _coupled = false;
  bool _nodal = false;
  bool _dot = false;
  bool _old = false;
  unsigned int _components = 1;
  TagID _tag = Moose::INVALID_TAG_ID;
  Array<const MooseVariableFieldBase *> _moose_var;
  Array<unsigned int> _var;
  Array<unsigned int> _sys;
  Array<Real> _default_value;
};

} // namespace Moose::Kokkos