ShowerEventRecord.h

// -*- C++ -*-
#ifndef Herwig_ShowerEventRecord_H
#define Herwig_ShowerEventRecord_H
//
// This is the declaration of the ShowerEventRecord class.
//
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Handlers/StandardXComb.h"
#include "ThePEG/PDF/PDF.h"
#include "Herwig/MatrixElement/Matchbox/Matching/ShowerApproximation.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class ShowerEventRecord: public Base {
 
public:
 
  ShowerEventRecord();
 
  virtual ~ShowerEventRecord();
 
public:
 
  tSubProPtr subProcess() const { return subProcess_; }
 
  tStdXCombPtr xcombPtr() const { return XComb_; }
 
  void xcombPtr(tStdXCombPtr in) { XComb_ = in; }
 
  const StandardXComb& xcomb() const { return *XComb_; }
 
public:
 
  PPair& incoming() { return incoming_; }
 
  const PPair& incoming() const { return incoming_; }
 
  PList& outgoing() { return outgoing_; }
 
  const PList& outgoing() const { return outgoing_; }
 
  PList& intermediates() { return intermediates_; }
 
  const PList& intermediates() const { return intermediates_; }
 
  const pair<double,double>& fractions() const { return fractions_; }
 
  pair<double,double>& fractions() { return fractions_; }
 
  const pair<PDF,PDF>& pdfs() const { return PDFs_; }
 
public:
 
  bool isMCatNLOSEvent() const { return isMCatNLOSEvent_; }
 
  bool isMCatNLOHEvent() const { return isMCatNLOHEvent_; }
 
  bool isPowhegSEvent() const { return isPowhegSEvent_; }
 
  bool isPowhegHEvent() const { return isPowhegHEvent_; }
 
  void isMCatNLOSEvent(bool in) { isMCatNLOSEvent_ = in; }
 
  void isMCatNLOHEvent(bool in) { isMCatNLOHEvent_ = in; }
 
  Ptr<ShowerApproximation>::tptr showerApproximation() {
    return showerApproximation_;
  }
 
  bool truncatedShower() const { return truncatedShower_; }
 
  void truncatedShower(bool in) { truncatedShower_=in; }
 
public:
 
  virtual void clear();
 
protected:
 
  void subProcess(tSubProPtr in) { subProcess_ = in; }
 
  pair<PDF,PDF>& pdfs() { return PDFs_; }
 
public:
 
  void identifyEventType();
 
protected:
 
  map<ColinePtr,ColinePtr> & colourLines() {return colourLines_;}
 
  void colourIsolate(const vector<PPtr> & original, const vector<PPtr> & copy);
 
  void updateColour(PPtr particle, bool recursive);
 
  void mapColour(PPtr original, PPtr copy);
 
private:
 
  void isolateLine(vector<PPair>::const_iterator cit,
                   vector<PPair> & particles,
                   tcColinePtr oldline,
                   tColinePtr newline);
 
private:
 
  ShowerEventRecord & operator=(const ShowerEventRecord &) = delete;
 
 
private:
 
  SubProPtr subProcess_;
 
  StdXCombPtr XComb_;
 
  PPair incoming_;
 
  PList outgoing_;
 
  PList intermediates_;
 
  pair<PDF,PDF> PDFs_;
 
  pair<double,double> fractions_;
 
private:
  
  bool isMCatNLOSEvent_;
 
  bool isMCatNLOHEvent_;
 
  bool isPowhegSEvent_;
 
  bool isPowhegHEvent_;
 
  Ptr<ShowerApproximation>::tptr showerApproximation_;
 
  map<ColinePtr,ColinePtr> colourLines_;
 
  bool truncatedShower_;
 
};
 
}
 
#endif /* Herwig_ShowerEventRecord_H */