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