LundFragHandler.h

// -*- C++ -*-
#ifndef PYTHIA7_LundFragHandler_H
#define PYTHIA7_LundFragHandler_H
// This is the declaration of the LundFragHandler class.

#include "FragConfig.h"
#include "ThePEG/Handlers/HadronizationHandler.h"
#include "LundFragHandler.xh"
#include "LundFlavourGenerator.h"
#include "Oriented.h"
#include "OrientedIndex.h"
#include "ThePEG/Handlers/PtGenerator.h"
#include "ThePEG/Handlers/ZGenerator.h"
#include "ThePEG/Handlers/FlavourGenerator.h"
#include "ThePEG/Handlers/ClusterCollapser.h"
#include "EndPoint.h"
#include "Hadron.h"


namespace Pythia7 {

class LundFragHandler:public HadronizationHandler, public Oriented {

public:

  typedef OrientedIndex OIndex;

  typedef pair<double, double> Xhat;
  typedef vector<Xhat> XhatVector;
  typedef list<Hadron> Buffer;
  typedef Buffer::iterator BufferIt;


public:

  LundFragHandler();

  LundFragHandler(const LundFragHandler &);

  ~LundFragHandler();

  virtual void handle(EventHandler & eh, const tPVector & tagged,
                      const Hint & hint);

  ParticleList Hadronize(const tcPVector& );


  static void Init();


  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

public: 

  inline void PtGen(PtGeneratorPtr);

  inline PtGeneratorPtr PtGen() const;

  inline void FlavourGen(FlavourGeneratorPtr);

  inline FlavourGeneratorPtr FlavourGen() const;

  inline void ZGen(ZGeneratorPtr);

  inline ZGeneratorPtr ZGen() const;

  inline long maxLoop() const;

  inline void maxLoop(long n);

  inline Energy Wmin0() const;

  inline double k() const;

  inline double Delta() const;

  inline Energy m0() const;

  inline InvEnergy4 d0() const;

  inline double SqRatio() const;

  
  void showEP() const;

  void echoXhat(cStringRegionPtr );

protected:


protected:

  inline virtual IBPtr clone() const;

  inline virtual IBPtr fullclone() const;


protected:

  inline virtual void doupdate() throw(UpdateException);

  inline virtual void doinit() throw(InitException);

  inline virtual void dofinish();


protected: 

  void resetHandler();

  void initHadronization(const tcPVector& );

  PVector copyRecombine(tcPPtr first, const tcPVector & inPVec);

  void initOpenString(const tcPVector& );  

  void initClosedString(const tcPVector& );  


  void getHadron();

  void loopBack();

  void finalTwoHadrons();

  void Stepping();

  void solveGammaM2System();

  void Step();
  void stepDown();

  LorentzMomentum p0(cStringRegionPtr first, cStringRegionPtr last);
  

  cPPtr selectBreakup(const tcPVector&);

  void pickFirstEPts();


  void setupCommonFinalRegion();

  void solveKinematics(); 

  inline cStringRegionPtr finalSR() const;

  inline  const EndPoint& firstEP() const;

  inline  EndPoint& secondEP();

  inline  Hadron& secondH();



  Energy2 Wmin2() const;

  inline bool enoughE() const; 

  inline bool AqqbarSystem() const;

  inline bool inconsistentBreakupRegions() const;

  inline int  nSR() const;

  inline const EndPoint& lastEP() const;

  inline const EndPoint& lastOppEP() const;

  inline EndPoint& getLastEP();

  inline EndPoint& getLastOppEP();

  inline cStringRegionPtr CurrentSR() const;

  inline double CurrentXremf() const;

  inline double CurrentXremb() const;

  inline double& Xhatfwd(int );

  inline double& Xhatbwd(int );

  inline void setXhat(double, double);

  inline bool aSolution() const;

  void store(Hadron& , int Dir=Oriented::Dir());

  inline void clearBuffer();

  ParticleList createParticleList();

  virtual tcPDPtr generateHadron(tcPDPtr inPDPtr, cPDPtr& newPDPtr,
                                 long curtainQid=0);

  virtual tcPDPtr getHadron(tcPDPtr inPD1, tcPDPtr inPD2);


private : 

  PtGeneratorPtr thePtGen;

  FlavourGeneratorPtr theFlGen;  

  ZGeneratorPtr theZGen;

  ClusterCollapserPtr theCollapser;

  Energy pWmin0;          // PARJ(33) - PARJ(34) 

  double pK;              // PARJ(36)

  double pDelta;          // PARJ(37)

  Energy pM0;             // PARJ(32)


  Energy2 m2min;         // PARU(12)

  Energy2 m2mini;

  double angmin;         // PARU(13)

  double angmini;

  InvEnergy4 pd0;         // PAR(38)

  long MaxLoop;


  StringPtr theCurrentString;

  EndPoint  theRightEP;

  EndPoint  theLeftEP;

  EndPoint  CurrentEP;

  cStringRegionPtr thefinalSR;         

  cPDPtr newCreatedPD;        

  Hadron newHadron;

  Hadron lastHadron;


  XhatVector XhatFwdVector;

  XhatVector XhatBwdVector;

  LorentzMomentum Pzero;

  bool Estatus;

  bool GammaM2Solution;

  long ntry;

  cPPtr breakup;

  Buffer theBuffer;

  BufferIt currentBufferIt; 

  LorentzRotation cmr;

  static ClassDescription<LundFragHandler> initLundFragHandler;

};

}

namespace ThePEG {

template <>
struct BaseClassTrait<Pythia7::LundFragHandler,1>: public ClassTraitsType {
  typedef HadronizationHandler NthBase;
};

template <>
struct ClassTraits<Pythia7::LundFragHandler> 
  : public ClassTraitsBase<Pythia7::LundFragHandler> {
  static string className() { return "Pythia7::LundFragHandler"; }
  static string library() { return "libP7String.so"; }
};

}

#include "LundFragHandler.icc"
#ifndef PYTHIA7_TEMPLATES_IN_CC_FILE
// #include "LundFragHandler.tcc"
#endif

#endif /* PYTHIA7_LundFragHandler_H */

---