Branch data     Line data    Source code

       1                 :             : // Class Distribution
       2                 :             : //   This class can be used for creating a distribution object
       3                 :             : //   with custom pdf, cdf, and estimate function that is used for
       4                 :             : //   the sampling method.
       5                 :             : //
       6                 :             : 
       7                 :             : #ifndef IPPL_DISTRIBUTION_H
       8                 :             : #define IPPL_DISTRIBUTION_H
       9                 :             : 
      10                 :             : #include "Types/ViewTypes.h"
      11                 :             : 
      12                 :             : #include "Random/Utility.h"
      13                 :             : 
      14                 :             : namespace ippl {
      15                 :             :     namespace random {
      16                 :             : 
      17                 :             :         /*!
      18                 :             :          * @file Distribution.h
      19                 :             :          * @class Distribution
      20                 :             :          */
      21                 :             : 
      22                 :             :         /*!
      23                 :             :          * @ingroup Distribution
      24                 :             :          * @brief The class that represents a distribution.
      25                 :             :          * @tparam T Datatype.
      26                 :             :          * @tparam Dim Dimensionality of sample space.
      27                 :             :          * @tparam DimP Dimensionality of the parameter array.
      28                 :             :          * @tparam PDF Struct type for the PDF (Probability Density Function).
      29                 :             :          * @tparam CDF Struct type for the CDF (Cumulative Distribution Function).
      30                 :             :          * @tparam ESTIMATE Struct type for the ESTIMATE function.
      31                 :             :          */
      32                 :             :         template <typename T, unsigned Dim, unsigned DimP, typename DistributionFunctions>
      33                 :             :         class Distribution {
      34                 :             :         public:
      35                 :             :             /*!
      36                 :             :              * @param par_m An array of distribution parameters.
      37                 :             :              * @param pdf_m PDF of the distribution class as a member functor.
      38                 :             :              * @param cdf_m CDF of the distribution class as a member functor.
      39                 :             :              * @param estimate_m Estimate of the initial guess for the sampling method as a member
      40                 :             :              * functor.
      41                 :             :              */
      42                 :             :             T par_m[DimP];
      43                 :             :             typename DistributionFunctions::PDF pdf_m;
      44                 :             :             typename DistributionFunctions::CDF cdf_m;
      45                 :             :             typename DistributionFunctions::Estimate estimate_m;
      46                 :             :             /*!
      47                 :             :              * @ingroup Distribution
      48                 :             :              * @brief Constructor for the Distribution class.
      49                 :             :              * @param par_ Pointer to the parameter array.
      50                 :             :              */
      51                 :           0 :             KOKKOS_INLINE_FUNCTION Distribution(const T* par_p) {
      52         [ #  # ]:           0 :                 for (unsigned int i = 0; i < DimP; i++) {
      53                 :           0 :                     par_m[i] = par_p[i];
      54                 :             :                 }
      55                 :           0 :             }
      56                 :             : 
      57                 :             :             /*!
      58                 :             :              * @ingroup Distribution
      59                 :             :              * @brief Destructor for the Distribution class.
      60                 :             :              */
      61                 :           0 :             KOKKOS_INLINE_FUNCTION ~Distribution() {}
      62                 :             : 
      63                 :             :             /*!
      64                 :             :              * @brief A wrapper to change the signature arguments of pdf in each dimension d
      65                 :             :              * from (x, d, par) to (x, d).
      66                 :             :              */
      67                 :           0 :             KOKKOS_INLINE_FUNCTION T getPdf(T x, unsigned int d) const {
      68                 :           0 :                 return pdf_m(x, d, par_m);
      69                 :             :             }
      70                 :             : 
      71                 :             :             /*!
      72                 :             :              * @brief A wrapper to change the signature arguments of cdf in each dimension d
      73                 :             :              * from (x, d, par) to (x, d).
      74                 :             :              */
      75                 :           0 :             KOKKOS_INLINE_FUNCTION T getCdf(T x, unsigned int d) const {
      76                 :           0 :                 return cdf_m(x, d, par_m);
      77                 :             :             }
      78                 :             : 
      79                 :             :             /*!
      80                 :             :              * @brief A wrapper to change the signature arguments of estimate in each dimension d
      81                 :             :              * from (x, d, par) to (x, d).
      82                 :             :              */
      83                 :           0 :             KOKKOS_INLINE_FUNCTION T getEstimate(T x, unsigned int d) const {
      84                 :           0 :                 return estimate_m(x, d, par_m);
      85                 :             :             }
      86                 :             : 
      87                 :             :             /*!
      88                 :             :              * @returns Objective function that is used in inverse transform sampling, i.e. obj =
      89                 :             :              * cdf(x)-u. Here u is uniformly distributed on [0, 1] and x is the sample of target
      90                 :             :              * distribution.
      91                 :             :              */
      92                 :           0 :             KOKKOS_INLINE_FUNCTION T getObjFunc(T x, unsigned int d, T u) const {
      93                 :           0 :                 return getCdf(x, d) - u;
      94                 :             :             }
      95                 :             : 
      96                 :             :             /*!
      97                 :             :              * @returns Derivative of the objective function that is used in inverse transform
      98                 :             :              * sampling, i.e. d(obj)/dx = pdf(x)
      99                 :             :              */
     100                 :           0 :             KOKKOS_INLINE_FUNCTION T getDerObjFunc(T x, unsigned int d) const {
     101                 :           0 :                 return getPdf(x, d);
     102                 :             :             }
     103                 :             : 
     104                 :             :             /*!
     105                 :             :              * @returns Total pdf given uncorrelated pdf in each dimension.
     106                 :             :              * i.e. total_pdf = pdf(x_1) * pdf(x_2) * ...  pdf(x_N).
     107                 :             :              */
     108                 :             :             KOKKOS_INLINE_FUNCTION T getFullPdf(ippl::Vector<T, Dim> x) const {
     109                 :             :                 T totalPdf = 1.0;
     110                 :             :                 for (unsigned int d = 0; d < Dim; d++) {
     111                 :             :                     totalPdf *= getPdf(x[d], d);
     112                 :             :                 }
     113                 :             :                 return totalPdf;
     114                 :             :             }
     115                 :             :         };
     116                 :             :     }  // namespace random
     117                 :             : }  // namespace ippl
     118                 :             : 
     119                 :             : #endif