Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #pragma once
      11             : 
      12             : #include "KokkosDatum.h"
      13             : 
      14             : class UserObject;
      15             : class InputParameters;
      16             : 
      17             : template <typename Base>
      18             : class KokkosExtremeValueBase : public Base
      19             : {
      20             : public:
      21             :   static InputParameters validParams();
      22             : 
      23             :   KokkosExtremeValueBase(const InputParameters & parameters);
      24             : 
      25             :   virtual void initialize() override;
      26             :   virtual void finalize() override;
      27             :   virtual Real getValue() const override;
      28             : 
      29             :   template <typename Derived>
      30             :   KOKKOS_FUNCTION void
      31             :   computeExtremeValue(const unsigned int qp, Datum & datum, Real * result) const;
      32             :   template <typename Derived>
      33             :   KOKKOS_FUNCTION void join(Real * result, const Real * source) const;
      34             :   template <typename Derived>
      35             :   KOKKOS_FUNCTION void init(Real * result) const;
      36             : 
      37             : protected:
      38             :   /**
      39             :    * Type of extreme value we are going to compute
      40             :    */
      41             :   enum class ExtremeType
      42             :   {
      43             :     MAX,
      44             :     MIN,
      45             :     MAX_ABS
      46             :   } _type;
      47             : };
      48             : 
      49             : template <typename Base>
      50             : template <typename Derived>
      51             : KOKKOS_FUNCTION void
      52      292745 : KokkosExtremeValueBase<Base>::computeExtremeValue(const unsigned int qp,
      53             :                                                   Datum & datum,
      54             :                                                   Real * result) const
      55             : {
      56      292745 :   auto pv = static_cast<const Derived *>(this)->getProxyValuePair(qp, datum);
      57      292745 :   auto rpv = Kokkos::make_pair(result[0], result[1]);
      58             : 
      59      585490 :   if ((_type == ExtremeType::MAX && pv > rpv) || (_type == ExtremeType::MIN && pv < rpv))
      60             :   {
      61       20088 :     result[0] = pv.first;
      62       20088 :     result[1] = pv.second;
      63             :   }
      64      272657 :   else if (_type == ExtremeType::MAX_ABS && Kokkos::abs(pv.first) > rpv.first)
      65             :   {
      66           0 :     result[0] = Kokkos::abs(pv.first);
      67           0 :     result[1] = pv.second;
      68             :   }
      69      292745 : }
      70             : 
      71             : template <typename Base>
      72             : template <typename Derived>
      73             : KOKKOS_FUNCTION void
      74          51 : KokkosExtremeValueBase<Base>::join(Real * result, const Real * source) const
      75             : {
      76          51 :   auto rpv = Kokkos::make_pair(result[0], result[1]);
      77          51 :   auto spv = Kokkos::make_pair(source[0], source[1]);
      78             : 
      79         102 :   if ((_type == ExtremeType::MAX && spv > rpv) || (_type == ExtremeType::MIN && spv < rpv))
      80             :   {
      81          34 :     result[0] = source[0];
      82          34 :     result[1] = source[1];
      83             :   }
      84          17 :   else if (_type == ExtremeType::MAX_ABS && Kokkos::abs(spv.first) > rpv.first)
      85             :   {
      86           0 :     result[0] = Kokkos::abs(source[0]);
      87           0 :     result[1] = source[1];
      88             :   }
      89          51 : }
      90             : 
      91             : template <typename Base>
      92             : template <typename Derived>
      93             : KOKKOS_FUNCTION void
      94         462 : KokkosExtremeValueBase<Base>::init(Real * result) const
      95             : {
      96         462 :   if (_type == ExtremeType::MAX || _type == ExtremeType::MAX_ABS)
      97             :   {
      98         326 :     result[0] = Kokkos::Experimental::finite_min_v<Real>;
      99         326 :     result[1] = Kokkos::Experimental::finite_min_v<Real>;
     100             :   }
     101         136 :   else if (_type == ExtremeType::MIN)
     102             :   {
     103         136 :     result[0] = Kokkos::Experimental::finite_max_v<Real>;
     104         136 :     result[1] = Kokkos::Experimental::finite_max_v<Real>;
     105             :   }
     106         462 : }