BinSampler.h

// -*- C++ -*-
//
// BinSampler.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef Herwig_BinSampler_H
#define Herwig_BinSampler_H
//
// This is the declaration of the BinSampler class.
//
 
#include "ThePEG/Handlers/StandardEventHandler.h"
#include "ThePEG/Utilities/Exception.h"
#include "ThePEG/Repository/UseRandom.h"
 
#include "MultiIterationStatistics.h"
#include "Remapper.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class GeneralSampler;
 
class BinSampler: public Herwig::MultiIterationStatistics {
 
public:
 
  BinSampler();
 
public:
 
  Ptr<BinSampler>::ptr cloneMe() const {
    return dynamic_ptr_cast<Ptr<BinSampler>::ptr>(clone());
  }
 
public:
 
  double evaluate(vector<double> p,
                  bool remap = true);
 
  double bias() const { return theBias; }
 
  void bias(double b) { theBias = b; }
 
  void eventHandler(tStdEHPtr eh) { theEventHandler = eh; }
 
  tStdEHPtr eventHandler() const { return theEventHandler; }
 
  void sampler(Ptr<GeneralSampler>::tptr);
 
  Ptr<GeneralSampler>::tptr sampler() const;
 
  int bin() const { return theBin; }
 
  void bin(int b) { theBin = b; }
 
  string process() const;
 
  string shortprocess() const;
  
  string id() const;
 
  const vector<double>& lastPoint() const { return theLastPoint; }
 
  vector<double>& lastPoint() { return theLastPoint; }
 
  double referenceWeight() const { return theReferenceWeight; }
 
  void referenceWeight(double w) { theReferenceWeight = w; }
 
  virtual bool canUnweight() const { return true; }
 
  virtual bool adaptsOnTheFly() const { return false; }
 
  virtual bool compensating() const { return false; }
 
  bool weighted() const { return theWeighted; }
 
  void doWeighted(bool yes = true) { theWeighted = yes; }
 
  struct NextIteration {};
 
  virtual double generate();
 
  void fillRemappers(bool progress);
 
  void saveRemappers() const;
 
  void saveIntegrationData() const;
 
  virtual void saveGrid() const {}
 
  void readIntegrationData();
 
  void setupRemappers(bool progress);
 
  void runIteration(unsigned long n, bool progress);
 
  virtual void adapt() {}
 
  virtual void initialize(bool progress);
 
  bool initialized() const { return theInitialized; }
 
  void isInitialized() { theInitialized = true; }
 
  bool integrated() const { return theIntegrated; }
 
  bool remappersFilled() const { return theRemappersFilled; }
 
  virtual bool existsGrid() const { return false; }
 
  bool hasGrids() const { return theHasGrids; }
 
  void didReadGrids() { theHasGrids = true; }
 
  virtual void finalize(bool); 
 
  virtual CrossSection integratedXSec() const {
    return averageWeight()*nanobarn;
  }
 
  virtual CrossSection integratedXSecErr() const {
    return sqrt(abs(averageWeightVariance()))*nanobarn;
  }
 
  struct RandomNumberHistogram {
 
    double lower;
 
    map<double,double > bins;
    
    map<double,double > binsw1;
    RandomNumberHistogram(double low = 0.0, 
                         double up = 1., 
                         unsigned int nbins = 20);
 
    void book(double inv, double weight) {
      map<double,double>::iterator b =  bins.upper_bound(inv);
      if ( b == bins.end() ) return;
      b->second = b->second+weight;
      map<double,double>::iterator b2 = binsw1.upper_bound(inv);
      if ( b2 == binsw1.end() ) return;
      b2->second = b2->second+1.;
 
    }
 
    void dump(const std::string& folder,const std::string& prefix, const std::string& process,const int NR)const;
 
 
  };
     
  typedef pair<string,size_t > RandomNumberIndex;
  
  map<RandomNumberIndex,pair<RandomNumberHistogram,double> > RandomNumberHistograms;
 
public:
 
  int dimension() const { return theEventHandler->nDim(bin()); }
 
  unsigned long initialPoints() const { return theInitialPoints; }
 
  void initialPoints(unsigned long n) { theInitialPoints = n; }
 
  size_t nIterations() const { return theNIterations; }
 
  void nIterations(size_t n) { theNIterations = n; }
 
  void enhancementFactor(double f) { theEnhancementFactor = f; }
 
  double enhancementFactor() const { return theEnhancementFactor; }
  
  string randomNumberString() const {return theRandomNumbers;}
 
  double kappa() const {return theKappa;}
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
private:
 
  double theBias;
 
  bool theWeighted;
 
  unsigned long theInitialPoints;
 
  size_t theNIterations;
 
  double theEnhancementFactor;
 
  bool theNonZeroInPresampling; 
  
  bool theHalfPoints;
 
  int theMaxNewMax;
 
  double theReferenceWeight;
 
  int theBin;
 
  bool theInitialized;
 
  vector<double> theLastPoint;
 
  tStdEHPtr theEventHandler;
 
  Ptr<GeneralSampler>::tptr theSampler;
  
  string theRandomNumbers;
 
  map<size_t,Remapper> remappers;
 
  unsigned long theRemapperPoints;
 
  bool theRemapChannelDimension;
 
  unsigned long theLuminosityMapperBins;
 
  unsigned long theGeneralMapperBins;
 
  double theRemapperMinSelection;
 
  bool theIntegrated;
 
  bool theRemappersFilled;
 
  bool theHasGrids;
 
 
 
  double theKappa;
 
private:
 
  BinSampler & operator=(const BinSampler &) = delete;
 
};
 
}
 
#endif /* Herwig_BinSampler_H */