LandauDistribution.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-2020 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 <limits>
#include <random>

namespace ActsFatras {

class LandauDistribution {
 public:
  struct param_type {
    using distribution_type = LandauDistribution;

    double location = 0.0;
    double scale = 1.0;

    param_type(double location_, double scale_)
        : location(location_), scale(scale_) {}
    // Explicitlely defaulted construction and assignment
    param_type() = default;
    param_type(const param_type &) = default;
    param_type(param_type &&) = default;
    param_type &operator=(const param_type &) = default;
    param_type &operator=(param_type &&) = default;

    friend bool operator==(const param_type &lhs, const param_type &rhs) {
      return (lhs.location == rhs.location) and (lhs.scale == rhs.scale);
    }
    friend bool operator!=(const param_type &lhs, const param_type &rhs) {
      return not(lhs == rhs);
    }
  };
  using result_type = double;

  LandauDistribution(double location, double scale) : m_cfg(location, scale) {}
  LandauDistribution(const param_type &cfg) : m_cfg(cfg) {}
  // Explicitlely defaulted construction and assignment
  LandauDistribution() = default;
  LandauDistribution(const LandauDistribution &) = default;
  LandauDistribution(LandauDistribution &&) = default;
  LandauDistribution &operator=(const LandauDistribution &) = default;
  LandauDistribution &operator=(LandauDistribution &&) = default;

  void reset() {}
  param_type param() const { return m_cfg; }
  void param(const param_type &cfg) { m_cfg = cfg; }

  result_type min() const { return -std::numeric_limits<double>::infinity(); }
  result_type max() const { return std::numeric_limits<double>::infinity(); }

  template <typename Generator>
  result_type operator()(Generator &generator) {
    return (*this)(generator, m_cfg);
  }
  template <typename Generator>
  result_type operator()(Generator &generator, const param_type &params) {
    const auto z = std::uniform_real_distribution<double>()(generator);
    return params.location + params.scale * quantile(z);
  }

  friend bool operator==(const LandauDistribution &lhs,
                         const LandauDistribution &rhs) {
    return lhs.m_cfg == rhs.m_cfg;
  }
  friend bool operator!=(const LandauDistribution &lhs,
                         const LandauDistribution &rhs) {
    return !(lhs == rhs);
  }

 private:
  param_type m_cfg;

  static double quantile(double z);
};

}  // namespace ActsFatras