PartonExtractor.h

// -*- C++ -*-
//
// PartonExtractor.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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 bool generateL(const PBIPair & pbins,
                         const double * r1, const double * r2);

  virtual Energy2 generateSHat(Energy2 s, const PBIPair & pbins,
                               const double * r1, const double * r2);

  virtual double fullFn(const PBIPair & pbins, Energy2 scale);

  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 void generateL(PartonBinInstance & pb, const double * r);

  virtual bool generate(PartonBinInstance & pb, const double * r,
                        Energy2 shat, const Lorentz5Momentum & first);

  virtual double fullFn(const PartonBinInstance & pb);

  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,
                  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:

  mutable PartonBinInstanceMap partonBinInstances;

  vector<PDFPtr> theSpecialDensities;

  PDFPtr theNoPDF;

  int theMaxTries;

  bool flatSHatY;

private:

  static ClassDescription<PartonExtractor> initPartonExtractor;

  PartonExtractor & operator=(const PartonExtractor &);

};

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

---