ColourReconnector.h

// -*- C++ -*-
//
// ColourReconnector.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_ColourReconnector_H
#define HERWIG_ColourReconnector_H
 
#include <ThePEG/Interface/Interfaced.h>
#include "CluHadConfig.h"
#include "ColourReconnector.fh"
 
namespace Herwig {
 
 
using namespace ThePEG;
 
class ColourReconnector: public Interfaced {
 
public:
 
  void rearrange(ClusterVector & clusters);
 
  using CluVecIt = ClusterVector::iterator;
 
private:
 
  Energy2 _clusterMassSum(const PVector & q, const PVector & aq) const;
  
  
  
  double _displacement(tcPPtr p, tcPPtr q) const;
  
   
  double _displacementBaryonic(tcPPtr p1, tcPPtr p2, tcPPtr p3) const;
 
  
  bool _containsColour8(const ClusterVector & cv, const vector<size_t> & P) const;
 
  void _doRecoStatistical(ClusterVector & cv) const;
 
  void _doRecoPlain(ClusterVector & cv) const;
 
 
  void _doRecoBaryonic(ClusterVector & cv) const;
  
  
  void _doRecoBaryonicMesonic(ClusterVector & cv) const; 
  
  
 
 
  void _makeBaryonicClusters(ClusterPtr &c1, ClusterPtr &c2, ClusterPtr &c3,
                             ClusterPtr &newcluster1, ClusterPtr &newcluster2) const;
  
 
  CluVecIt _findRecoPartner(CluVecIt cl, ClusterVector & cv) const;
 
  CluVecIt _findPartnerRapidity(CluVecIt cl, ClusterVector & cv) const;
 
  CluVecIt _findPartnerBaryonic(CluVecIt cl, ClusterVector & cv, 
                                               bool & tetraCand, 
                                               const ClusterVector& a, 
                                               CluVecIt  &baryonic1,
                                               CluVecIt  &baryonic2 ) const;
  
  void _findbestreconnectionoption(std::vector<CluVecIt> &cls,
                                                                                        const unsigned &baryonic,
                                                                                        string &kind_of_reco,
                                                                                        int (&reco_info)[3]) const;
 
  pair <ClusterPtr,ClusterPtr> _reconnect(ClusterPtr &c1, ClusterPtr &c2) const;
  
  pair <ClusterPtr,ClusterPtr> _reconnect2Bto2B(ClusterPtr &c1, ClusterPtr &c2, const int s1, const int s2) const;
  
  std::tuple  <ClusterPtr, ClusterPtr, ClusterPtr> _reconnectBbarBto3M(ClusterPtr &c1, ClusterPtr &c2, const int s0, const int s1, const int s2 ) const;
  
  std::tuple  <ClusterPtr, ClusterPtr, ClusterPtr> _reconnect3Mto3M(ClusterPtr &c1, ClusterPtr &c2, ClusterPtr &c3, const int infos[3] ) const;
  
   
  pair  <ClusterPtr, ClusterPtr> _reconnectMBtoMB(ClusterPtr &c1, ClusterPtr &c2, const int s0) const;
  
  
  
  
  bool _clustersFarApart( const std::vector<CluVecIt> & clu ) const;
        
  void _doReco2BeamClusters(ClusterVector & cv) const;
 
 
  void _2Bto2BreconnectionFinder(ClusterPtr &c1, ClusterPtr &c2, int &bswap1, int &bswap2, double mindisplsum, string &kind_of_reco ) const;
 
  void _BbarBto3MreconnectionFinder(ClusterPtr &c1, ClusterPtr &c2, int &mswap0, int &mswap1, int &mswap2,
                                                                                                                        double min_displ_sum, string & kind_of_reco) const; 
 
  void _BMtoBMreconnectionfinder(ClusterPtr &c1, ClusterPtr &c2, int &swap, 
                                                                                                                        double min_displ_sum, string &kind_of_reco) const;
 
  void _3MtoXreconnectionfinder(std::vector<CluVecIt> &cv, int &swap0, int &swap1,
                                                                                                                                int &swap2, double min_displ_sum, string &kind_of_reco) const;
 
  pair <int,int>
    _shuffle(const PVector & q, const PVector & aq, unsigned maxtries = 10) const;
 
 
  int _algorithm = 0;
 
  int _clreco = 0;
 
  int _debug = 0;
  
  int _junctionMBCR = 1;
 
  double _initTemp = 0.01;
 
  double _annealingFactor = 0.21;
 
  unsigned int _annealingSteps = 10;
 
  double _triesPerStepFactor = 0.66;
 
  double _preco = 0.5;
 
  double _precoBaryonic = 0.5;
 
  double _preco3M_3M = 0.5;
 
  double _preco3M_BBbar = 0.5;
 
  double _precoBbarB_3M = 0.5;
  
  double _preco2B_2B = 0.5;
  
  double _precoMB_MB = 0.5;
  
  double _stepFactor = 5.0;
 
  double _mesonToBaryonFactor = 2.0;
 
  Length _maxDistance = femtometer;
 
  bool _isColour8(tcPPtr p, tcPPtr q) const;
  
  unsigned int _octetOption = 0;
 
  int _cr2BeamClusters = 0;
 
  int _prePlainCR = 0;
 
  int _localCR = 0;
 
  int _causalCR = 0;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
private:
 
  ColourReconnector & operator=(const ColourReconnector &) = delete;
 
 
};
 
 
}
 
#endif /* HERWIG_ColourReconnector_H */