RandomNumberDistributions.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file RandomNumberDistributions.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Fatras/Kernel/detail/LandauQuantile.hpp"
#include <random>

namespace Fatras {

using GaussDist = std::normal_distribution<double>;         
using UniformDist = std::uniform_real_distribution<double>; 
using GammaDist = std::gamma_distribution<double>;          
using PoissonDist = std::poisson_distribution<int>;         



class LandauDist {
public:
  struct param_type {
    double mean = 0.;  
    double scale = 1.; 

    param_type() = default;
    param_type(double mean, double scale);

    param_type(const param_type &) = default;
    param_type &operator=(const param_type &) = default;

    bool operator==(const param_type &other) const;
    bool operator!=(const param_type &other) const { return !(*this == other); }

    using distribution_type = LandauDist;
  };

  LandauDist() = default;
  LandauDist(double mean, double scale);
  LandauDist(const param_type &cfg);

  LandauDist(const LandauDist &) = default;
  LandauDist &operator=(const LandauDist &) = default;

  void reset() { /* There is currently no state to reset here */
  }
  param_type param() const { return m_cfg; }
  void param(const param_type &p) { m_cfg = p; }

  using result_type = double;
  result_type min() const;
  result_type max() const;

  template <typename Generator> result_type operator()(Generator &engine) {
    return (*this)(engine, m_cfg);
  }

  template <typename Generator>
  result_type operator()(Generator &engine, const param_type &params) {
    double x = std::generate_canonical<float, 10>(engine);
    double res = params.mean + landau_quantile(x, params.scale);
    return res;
  }

  bool operator==(const LandauDist &other) const;
  bool operator!=(const LandauDist &other) const { return !(*this == other); }

private:
  param_type m_cfg; 
};
} // namespace Fatras