ComputePi_module.cc

Go to the documentation of this file.

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

// art libraries
#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.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()