generator.h

// -*- C++ -*-
//
// generator.h is part of ExSample -- A Library for Sampling Sudakov-Type Distributions
//
// Copyright (C) 2008-2019 Simon Platzer -- simon.plaetzer@desy.de, The Herwig Collaboration
//
// ExSample is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
#ifndef EXSAMPLE_generator_h_included
#define EXSAMPLE_generator_h_included
 
#include "cell.h"
#include "selectors.h"
#include "statistics.h"
#include "binary_tree.h"
 
namespace exsample {
 
  struct generator_update{};
 
  template<class Function, class Random>
  class generator {
 
  public:
 
    generator()
      : function_(0), statistics_(), check_events_(0),
        adaption_info_(), root_cell_(),
        rnd_gen_(), did_split_(false), initialized_(false),
        last_cell_(), last_point_(), last_value_(0.),
        compensating_(false) {}
 
  public:
 
    template<class SlaveStatistics>
    void initialize(SlaveStatistics&);
 
    template<class SlaveStatistics>
    double generate(SlaveStatistics&);
 
    const std::vector<double>& last_point() const { return last_point_; }
 
    void reject() {
      statistics_.reject(last_value_);
      last_cell_->info().reject();
    }
 
    void finalize() {
      statistics_.reset();
    }
 
  public:
 
    bool initialized() const { return initialized_; }
 
    bool did_split() const { return did_split_; }
 
    Function& function() { return *function_; }
 
    void function(Function * f) { function_ = f; }
 
    const statistics& stats() const { return statistics_; }
 
    double volume() const {
      return exsample::volume(adaption_info_.lower_left, adaption_info_.upper_right);
    }
 
    double integral() const {
      return volume() * statistics_.average_weight();
    }
 
    double integral_uncertainty() const {
      return volume() * std::sqrt(statistics_.average_weight_variance());
    }
 
    double current_integral() const {
      return volume() * statistics_.current().first;
    }
 
    double current_integral_uncertainty() const {
      return volume() * std::sqrt(statistics_.current().second);
    }
 
    double integral_variance() const {
      return sqr(volume()) * statistics_.average_weight_variance();
    }
 
    adaption_info& sampling_parameters() { return adaption_info_; }
 
    bool compensating() const { return compensating_; }
 
  public:
 
    template<class OStream>
    void put(OStream& os) const;
 
    template<class IStream>
    void get(IStream& is);
 
  private:
 
    bool split();
 
    void compensate();
 
    Function * function_;
 
    statistics statistics_;
 
    unsigned long check_events_;
 
    adaption_info adaption_info_;
 
    binary_tree<cell> root_cell_;
 
    rnd_generator<Random> rnd_gen_;
 
    bool did_split_;
 
    bool initialized_;
 
    binary_tree<cell>::iterator last_cell_;      
 
    std::vector<double> last_point_;
 
    double last_value_;
 
    bool compensating_;
 
  };
 
}
 
#include "generator.icc"
 
#endif // EXSAMPLE_generator_h_included