PartonExtractor.h

// -*- C++ -*-
//
// PartonExtractor.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_PartonExtractor_H
#define ThePEG_PartonExtractor_H
// This is the declaration of the PartonExtractor class.
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Handlers/LastXCombInfo.h"
#include "ThePEG/PDF/PartonBin.h"
#include "ThePEG/PDF/PartonBinInstance.h"
#include "ThePEG/PDF/PDFBase.h"
#include "ThePEG/PDT/ParticleData.h"
#include "PartonExtractor.xh"
 
namespace ThePEG {
 
class PartonExtractor: public HandlerBase, public LastXCombInfo<> {
 
  friend class XComb;
 
public:
 
  typedef map<cPPtr,PBIPtr> PartonBinInstanceMap;
 
public:
 
  PartonExtractor();
 
  virtual ~PartonExtractor();
 
public:
 
  virtual bool canHandle(const cPDPair &) { return true; }
 
  virtual PartonPairVec getPartons(Energy maxEnergy, const cPDPair &,
                                   const Cuts &) const;
 
  virtual Energy2 newScale();
 
  virtual void colourConnect(tPPtr particle, tPPtr parton,
                             const tPVector & remnants) const;
 
  virtual PBIPair newRemnants(tPPair oldp, tPPair newp, tStepPtr step);
 
  virtual pair<int,int> nDims(const PBPair & pbins);
 
  virtual void prepare(const PBIPair & pbins);
 
  virtual void updatePartonBinInstances(const PBIPair & pbins);
 
  virtual bool generateL(const PBIPair & pbins,
                         const double * r1, const double * r2);
 
  virtual void generateL(PartonBinInstance & pb, const double * r);
 
  virtual Energy2 generateSHat(Energy2 s, const PBIPair & pbins,
                               const double * r1, const double * r2,
                               bool mepartons = false);
 
  virtual double fullFn(const PBIPair & pbins, Energy2 scale,
                        pair<bool,bool> noLastPDF = make_pair(false,false));
 
  virtual void construct(const PBIPair & pbins, tStepPtr step) const;
 
  virtual void constructRemnants(const PBIPair & pbins, tSubProPtr sub,
                         tStepPtr step) const;
 
  virtual LorentzRotation
  boostRemnants(PBIPair & bins, LorentzMomentum k1, LorentzMomentum k2,
           bool side1, bool side2) const;
 
  tPBIPtr partonBinInstance(tcPPtr) const;
 
  void select(tXCombPtr newXComb);
 
 
  int maxTries() const { return theMaxTries; }
 
  tcPDFPtr getPDF(tcPDPtr particle) const;
 
protected:
 
 
  virtual bool generate(PartonBinInstance & pb, const double * r,
                        Energy2 shat, const Lorentz5Momentum & first,
                        bool haveMEPartons = false);
 
  virtual double fullFn(const PartonBinInstance & pb,
                        bool noLastPDF = false);
 
  virtual void construct(PartonBinInstance & pb,
                         tStepPtr step, bool boost = true) const;
 
  PBIPtr newRemnants(tPBIPtr oldpb, tPPtr newp, const LorentzMomentum & k);
 
  void addNewRemnants(tPBIPtr oldpb, tPBIPtr newpb, tStepPtr step);
 
  virtual void transformRemnants(LorentzMomentum & Ph, LorentzMomentum & Pr,
                                 const LorentzMomentum & k,
                                 const LorentzMomentum & P) const;
 
  virtual void
  constructRemnants(PartonBinInstance & pb, LorentzMomentum & Ph,
                    const LorentzMomentum & k) const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void addPartons(tPBPtr incoming ,const PDFCuts & cuts,
                          tcPDFPtr pdf ,PartonVector & pbins) const;
 
  tcPDFPtr noPDF() const { return theNoPDF; }
 
  template <typename Iterator>
  void findConnect(tColinePtr line, tPPtr parton, bool anti,
                   Iterator first, Iterator last) const {
    for ( ; first != last; ++first ) {
      if ( *first != parton &&  (**first).hasColour(anti) &&
           !(**first).colourLine(anti) ) {
        line->addColoured(*first, anti);
        return;
      }
    }
    throw RemColException(*this);
  }
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
  virtual void dofinish();
 
private:
 
  PartonBinInstanceMap& partonBinInstances() const { 
    assert(lastXCombPtr());
    return lastXCombPtr()->partonBinInstanceMap();
  }
 
  vector<PDFPtr> theSpecialDensities;
 
  PDFPtr theFirstPDF;
 
  PDFPtr theSecondPDF;
 
  PDFPtr theNoPDF;
 
  int theMaxTries;
 
  bool flatSHatY;
 
private:
 
  static ClassDescription<PartonExtractor> initPartonExtractor;
 
  PartonExtractor & operator=(const PartonExtractor &) = delete;
 
};
 
template <>
struct BaseClassTrait<PartonExtractor,1>: public ClassTraitsType {
  typedef HandlerBase NthBase;
};
 
template <>
struct ClassTraits<PartonExtractor>: public ClassTraitsBase<PartonExtractor> {
  static string className() { return "ThePEG::PartonExtractor"; }
};
 
}
 
#endif /* ThePEG_PartonExtractor_H */