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