KokkosLinearFVBoundaryCondition.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 "KokkosDispatcher.h"
#include "KokkosDatum.h"
#include "KokkosMesh.h"
#include "KokkosSystem.h"
#include "KokkosVariable.h"

#include "BoundaryRestrictableRequired.h"
#include "FunctionInterface.h"
#include "MeshChangedInterface.h"
#include "MooseObject.h"
#include "PostprocessorInterface.h"
#include "Restartable.h"
#include "SetupInterface.h"
#include "TransientInterface.h"
#include "UserObjectInterface.h"
#include "VectorPostprocessorInterface.h"

class FEProblemBase;
class InputParameters;

namespace Moose::Kokkos
{

class LinearFVBoundaryCondition : public MooseObject,
                                  public SetupInterface,
                                  public FunctionInterface,
                                  public UserObjectInterface,
                                  public TransientInterface,
                                  public PostprocessorInterface,
                                  public VectorPostprocessorInterface,
                                  public Restartable,
                                  public MeshChangedInterface,
                                  public BoundaryRestrictableRequired,
                                  public MeshHolder,
                                  public SystemHolder
{
public:
  static InputParameters validParams();

  LinearFVBoundaryCondition(const InputParameters & parameters);
  LinearFVBoundaryCondition(const LinearFVBoundaryCondition & object);

  struct BoundaryValueLoop
  {
  };
  struct BoundaryNormalGradientLoop
  {
  };

  struct BoundaryRelation
  {
    Real coefficient = 0;
    Real source = 0;
  };

  struct BoundaryRelationData
  {
    Array<Real> coefficient;
    Array<Real> source;
  };

  struct BoundaryData
  {
    BoundaryRelationData value;
    BoundaryRelationData normal_gradient;
  };

  virtual void initialSetup() override;

  Variable variable() const { return _var; }

  const BoundaryData & boundaryData() const { return _boundary_data; }

  MOOSE_KOKKOS_INDEX_TYPE numBoundaryFaces() const;

  Pair<ContiguousElementID, unsigned int>
  boundaryFaceID(const MOOSE_KOKKOS_INDEX_TYPE bc_face_index) const;

  bool hasBoundaryValue() const;
  bool hasBoundaryNormalGradient() const;

  void computeBoundaryValueData();
  void computeBoundaryNormalGradientData();

  template <typename Derived>
  KOKKOS_FUNCTION BoundaryRelation computeBoundaryValue(const FVDatum &) const
  {
    ::Kokkos::abort("Default computeBoundaryValue() should never be called. Make sure you "
                    "properly redefined this method in your class without typos.");

    return {};
  }

  template <typename Derived>
  KOKKOS_FUNCTION BoundaryRelation computeBoundaryNormalGradient(const FVDatum &) const
  {
    ::Kokkos::abort("Default computeBoundaryNormalGradient() should never be called. Make sure "
                    "you properly redefined this method in your class without typos.");

    return {};
  }

  template <typename Derived>
  static auto defaultBoundaryValue()
  {
    return &LinearFVBoundaryCondition::computeBoundaryValue<Derived>;
  }

  template <typename Derived>
  static auto defaultBoundaryNormalGradient()
  {
    return &LinearFVBoundaryCondition::computeBoundaryNormalGradient<Derived>;
  }

  template <typename Derived>
  KOKKOS_FUNCTION void operator()(BoundaryValueLoop, const ThreadID tid, const Derived & bc) const;

  template <typename Derived>
  KOKKOS_FUNCTION void
  operator()(BoundaryNormalGradientLoop, const ThreadID tid, const Derived & bc) const;

protected:
  FEProblemBase & _fe_problem;

  Variable _var;

  BoundaryData _boundary_data;

  std::unique_ptr<DispatcherBase> _boundary_value_dispatcher;
  std::unique_ptr<DispatcherBase> _boundary_normal_gradient_dispatcher;

  Scalar<Real> _t;
  Scalar<const Real> _t_old;
  Scalar<int> _t_step;
  Scalar<Real> _dt;
  Scalar<Real> _dt_old;
};

template <typename Derived>
KOKKOS_FUNCTION void
LinearFVBoundaryCondition::operator()(BoundaryValueLoop,
                                      const ThreadID tid,
                                      const Derived & bc) const
{
  const auto [elem, side] = kokkosBoundaryElementSideID(tid);
  FVDatum datum(elem, side, kokkosMesh());
  const auto relation = bc.template computeBoundaryValue<Derived>(datum);
  _boundary_data.value.coefficient[tid] = relation.coefficient;
  _boundary_data.value.source[tid] = relation.source;
}

template <typename Derived>
KOKKOS_FUNCTION void
LinearFVBoundaryCondition::operator()(BoundaryNormalGradientLoop,
                                      const ThreadID tid,
                                      const Derived & bc) const
{
  const auto [elem, side] = kokkosBoundaryElementSideID(tid);
  FVDatum datum(elem, side, kokkosMesh());
  const auto relation = bc.template computeBoundaryNormalGradient<Derived>(datum);
  _boundary_data.normal_gradient.coefficient[tid] = relation.coefficient;
  _boundary_data.normal_gradient.source[tid] = relation.source;
}

} // namespace Moose::Kokkos