LesHouchesEventHandler.h

// -*- C++ -*-
//
// LesHouchesEventHandler.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_LesHouchesEventHandler_H
#define THEPEG_LesHouchesEventHandler_H
//
// This is the declaration of the LesHouchesEventHandler class.
//
 
#include "ThePEG/Handlers/EventHandler.h"
#include "LesHouchesEventHandler.fh"
#include "LesHouchesReader.fh"
#include "ThePEG/Utilities/CompSelector.h"
#include "ThePEG/Utilities/XSecStat.h"
 
namespace ThePEG {
 
 
class LesHouchesEventHandler: public EventHandler {
 
public:
 
  typedef vector<LesHouchesReaderPtr> ReaderVector;
 
  typedef CompSelector<int,CrossSection> ReaderSelector;
 
  enum WeightOpt {
    unitweight = 1,    
    unitnegweight = -1, 
    varweight = 2,      
    varnegweight = -2   
  };
 
public:
 
  LesHouchesEventHandler()
    : theWeightOption(unitweight), theUnitTolerance(1.0e-6), warnPNum(true),
      theNormWeight(0), UseLHEEvent(0)
  {
    selector().tolerance(unitTolerance());
  }
 
  virtual ~LesHouchesEventHandler();
 
public:
 
  virtual void initialize();
 
  virtual void statistics(ostream &) const;
 
  virtual CrossSection histogramScale() const;
 
  virtual CrossSection integratedXSec() const;
 
  virtual int ntriesinternal() const;
 
  virtual CrossSection integratedXSecErr() const;
 
  virtual const map<string,CrossSection> & optintegratedXSecMap() const;
 
 
  virtual EventPtr generateEvent();
 
  virtual tCollPtr performCollision();
 
  virtual EventPtr continueEvent();
 
  void select(double weight);
 
  void accept();
 
  void reject(double weight);
 
  void increaseMaxXSec(CrossSection maxxsec);
 
  void skipEvents();
 
 
  WeightOpt weightOption() const { return theWeightOption; }
 
  double unitTolerance() const { return theUnitTolerance; }
 
  const ReaderVector & readers() const { return theReaders; }
 
  const ReaderSelector & selector() const { return theSelector; }
 
  tLesHouchesReaderPtr currentReader() const { return theCurrentReader; }
 
 
  void currentReader(tLesHouchesReaderPtr x) { theCurrentReader = x; }
 
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
  tLesHouchesReaderPtr theCurrentReader;
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
protected:
 
  ReaderVector & readers() { return theReaders; }
 
  ReaderSelector & selector() { return theSelector; }
 
  void setUnitTolerance(double);
 
  XSecStat stats;
 
  XSecStat histStats;
 
  vector<string> weightnames;
 
  struct OptWeight {
 
    XSecStat stats;
 
    CrossSection xs;
    
    XSecStat histStats;
  };
 
  map <string,OptWeight> opt;
 
  int ntries;
 
  const map<string,OptWeight> & optWeights() const { return opt; }
 
private:
 
  ReaderVector theReaders;
 
  ReaderSelector theSelector;
 
  WeightOpt theWeightOption;
 
  double theUnitTolerance;
 
 
  bool warnPNum;
 
  unsigned int theNormWeight;
 
  unsigned int UseLHEEvent;
 
public:
 
  class LesHouchesInitError: public InitException {};
 
  class LesHouchesPNumException: public InitException {};
private:
 
  static ClassDescription<LesHouchesEventHandler> initLesHouchesEventHandler;
 
  LesHouchesEventHandler & operator=(const LesHouchesEventHandler &) = delete;
 
};
 
}
 
// CLASSDOC OFF
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<LesHouchesEventHandler,1> {
  typedef EventHandler NthBase;
};
 
template <>
struct ClassTraits<LesHouchesEventHandler>
  : public ClassTraitsBase<LesHouchesEventHandler> {
  static string className() { return "ThePEG::LesHouchesEventHandler"; }
  static string library() { return "LesHouches.so"; }
};
 
}
 
#endif /* THEPEG_LesHouchesEventHandler_H */