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)
  {
    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;

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 */