ComputePi_module.cc

Go to the documentation of this file.

// C/C++ standard libraries
#include <iomanip> // std::setprecision
#include <ios>     // std::fixed
#include <random>  // std::default_random_engine, std::uniform_real_distribution

// art libraries
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

namespace lar {

  class ComputePi : public art::EDAnalyzer {
  public:
    using Counter_t = unsigned long long; 
    using Seed_t = std::default_random_engine::result_type;

    explicit ComputePi(fhicl::ParameterSet const& p);

    virtual ~ComputePi() = default;

    virtual void analyze(const art::Event&) override;

    double best_pi() const { return tries ? 4. * double(hits) / double(tries) : 3.0; }

    Counter_t best_pi_tries() const { return tries; }

    static const char* VersionString; 

  private:
    Counter_t samples; 
    Seed_t seed;       
    bool bFixed;       
    bool bVerbose;     

    std::default_random_engine generator; 
    Counter_t hits = 0;                   
    Counter_t tries = 0;                  

  }; // class ComputePi

} // namespace lar

//------------------------------------------------------------------------------

DEFINE_ART_MODULE(lar::ComputePi)

const char* lar::ComputePi::VersionString = "1.0";

template <typename T>
inline constexpr T sqr(T v)
{
  return v * v;
}

lar::ComputePi::ComputePi(const fhicl::ParameterSet& p)
  : EDAnalyzer(p)
  , samples(p.get<Counter_t>("Ksamples", 10000) * 1000)
  , seed(p.get<Seed_t>("Seed", 314159))
  , bFixed(p.get<bool>("Fixed", false))
  , bVerbose(p.get<bool>("Verbose", false))
  , generator(seed)
{
  mf::LogInfo("ComputePi") << "version " << VersionString << " using " << samples
                           << " samples per event, random seed " << seed;
} // lar::ComputePi::ComputePi()

void lar::ComputePi::analyze(const art::Event&)
{

  // prepare our personal pseudo-random engine;
  // we'll use always the same sequence!
  std::uniform_real_distribution<float> flat(0.0, 1.0);

  // if we want to fix the random sequence, we reseed the generator
  // with the same value over and over again
  if (bFixed) generator.seed(seed);

  Counter_t local_hits = 0, tries_left = samples;
  while (tries_left-- > 0) {
    float x = flat(generator), y = flat(generator);
    if (sqr(x) + sqr(y) < 1.0) ++local_hits;
  } // while

  double local_pi = double(local_hits) / double(samples) * 4.0;
  hits += local_hits;
  tries += samples;

  if (bVerbose) {
    mf::LogInfo("ComputePi") << "today's pi = " << std::fixed << std::setprecision(9) << local_pi
                             << " (pi = " << std::fixed << std::setprecision(12) << best_pi()
                             << " after " << best_pi_tries() << " samples)";
  } // if verbose

} // lar::ComputePi::analyze()