ClusterCollapser.h

// -*- C++ -*-
//
// ClusterCollapser.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_ClusterCollapser_H
#define ThePEG_ClusterCollapser_H
// This is the declaration of the ClusterCollapser class.
 
#include "ThePEG/Handlers/StepHandler.h"
#include "ThePEG/Handlers/FlavourGenerator.h"
#include "ThePEG/EventRecord/ColourSinglet.h"
#include "ClusterCollapser.fh"
// #include "ClusterCollapser.xh"
 
 
namespace ThePEG {
 
class ClusterCollapser: public StepHandler {
 
public:
 
  typedef Ptr<FlavourGenerator>::pointer FlavGenPtr;
 
  typedef multimap<Energy,ColourSinglet> SingletMap;
 
public:
 
  ClusterCollapser()
    : theEnergyCut(1.0*GeV), theNTry2(2), errorlevel(Exception::eventerror),
      pStrange(1.0/3.0) {}
 
  virtual ~ClusterCollapser();
 
public:
 
  virtual void handle(EventHandler & eh, const tPVector & tagged,
                      const Hint & hint);
 
  virtual vector<ColourSinglet> collapse(tPVector tagged,
                                         tStepPtr newstep);
 
  virtual SingletMap getSinglets(const tPVector & tagged) const;
 
  virtual ColourSinglet splitDiQuarkJunction(ColourSinglet & cs,
                                             tStepPtr newStep) const;
 
  virtual ColourSinglet splitDiDiQuark(ColourSinglet & cs,
                                       tStepPtr newStep) const;
 
  static bool diQuarkJunction(const ColourSinglet & cs);
 
  static bool diDiQuark(const ColourSinglet & cs);
 
  Energy cut() const { return theEnergyCut; }
 
  int nTry2() const { return theNTry2; }
 
  static Energy mass(const ColourSinglet & cl);
 
  static void insert(SingletMap & mmap, const ColourSinglet & cl);
 
  virtual tcPDPtr pickFlavour() const;
 
protected:
 
  virtual void collapse(tStepPtr newStep, const ColourSinglet & cs,
                        const tPVector & tagged) const;
  virtual bool collapse2(tStepPtr newStep, const ColourSinglet & cs) const;
 
  virtual tPVector getCompensators(Energy mh, const ColourSinglet & cs,
                                   const tPVector & tagged,
                                   tStepPtr newStep) const;
 
  virtual tcPDPtr getHadron(const ColourSinglet & cs) const;
 
  virtual tcPDPair getHadrons(const ColourSinglet & cs) const;
 
  void updateTagged(tPVector & tagged) const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
  class ClusterException: public Exception {
  public:
    ClusterException(const ClusterCollapser & cc) {
      theMessage << "In ClusterCollapser '" << cc.name() << "': ";
    }
  };
private:
 
  Energy theEnergyCut;
 
  int theNTry2;
 
  FlavGenPtr flavGen;
 
protected:
 
  Exception::Severity errorlevel;
 
  double pStrange;
 
private:
 
  static ClassDescription<ClusterCollapser> initClusterCollapser;
 
  ClusterCollapser & operator=(const ClusterCollapser &) = delete;
 
};
 
}
 
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<ClusterCollapser,1>: public ClassTraitsType {
  typedef StepHandler NthBase;
};
 
template <>
struct ClassTraits<ClusterCollapser>:
    public ClassTraitsBase<ClusterCollapser> {
  static string className() { return "ThePEG::ClusterCollapser"; }
 
};
 
}
 
#endif /* ThePEG_ClusterCollapser_H */