ConstituentReshuffler.h

// -*- C++ -*-
//
// ConstituentReshuffler.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_ConstituentReshuffler_H
#define HERWIG_ConstituentReshuffler_H
//
// This is the declaration of the ConstituentReshuffler class.
//
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Utilities/Exception.h"
#include "Herwig/Shower/PerturbativeProcess.h"
#include "Herwig/Utilities/Reshuffler.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class ConstituentReshuffler: public HandlerBase, public Reshuffler {
 
public:
 
  void reshuffle(PList& out,
                 PPair& in,
                 PList& intermediates,
                 const bool decay,
                 PList& decayPartons,
                 PList& decayRecoilers);
 
  void reshuffle(PList& out,
                 PPair& in,
                 PList& intermediates,
                 const bool decay=false) {
 
    PList decayPartons;
    PList decayRecoilers;
 
    reshuffle(out,
              in,
              intermediates,
              decay,
              decayPartons,
              decayRecoilers);
  }
 
 
  void hardProcDecayReshuffle(PList& decaying,
                              PList& eventOutgoing,
                              PList& eventHard,
                              PPair& eventIncoming,
                              PList& eventIntermediates) ;
 
  void decayReshuffle(PerturbativeProcessPtr& decayProc,
                      PList& eventOutgoing,
                      PList& eventHard,
                      PList& eventIntermediates) ;
 
  void updateEvent( PList& intermediates,
                    PList& eventIntermediates,
                    PList& out,
                    PList& eventOutgoing,
                    PList& eventHard,
                    PerturbativeProcessPtr decayProc = PerturbativeProcessPtr() ) ;
 
 
  void updateSpinInfo( PPtr& oldPart,
                       PPtr& newPart ) ;
  
protected:
 
  struct DecayReshuffleEquation {
 
    DecayReshuffleEquation (Energy q,
                            PList::iterator m_begin,
                            PList::iterator m_end,
                            PList::iterator n_begin,
                            PList::iterator n_end)
      : w(q), p_begin(m_begin), p_end(m_end), r_begin(n_begin), r_end(n_end) {}
 
    typedef double ArgType;
    typedef double ValType;
 
    static double aUnit() { return 1.; }
    static double vUnit() { return 1.; }
 
    Energy w;
 
    PList::iterator p_begin;
    PList::iterator p_end;
 
    PList::iterator r_begin;
    PList::iterator r_end;
 
    double operator() (double xi) const {
 
      double r = - w/GeV;
      
      for (PList::iterator pIt = p_begin; pIt != p_end; ++pIt) {
        r += sqrt(sqr((**pIt).dataPtr()->constituentMass()) +
                  xi*xi*(sqr((**pIt).momentum().t())-sqr((**pIt).dataPtr()->mass()))) / GeV;
      }
      
      for (PList::iterator rIt = r_begin; rIt != r_end; ++rIt) {
        r +=  sqrt(sqr((**rIt).momentum().m()) +
                   xi*xi*(sqr((**rIt).momentum().t())-sqr((**rIt).momentum().m()))) / GeV;
      }
      
      return r;  
    }
 
  };
 
 
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
 
private:
 
  static ClassDescription<ConstituentReshuffler> initConstituentReshuffler;
 
  ConstituentReshuffler & operator=(const ConstituentReshuffler &) = delete;
 
};
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<Herwig::ConstituentReshuffler,1> {
  typedef HandlerBase NthBase;
};
 
template <>
struct ClassTraits<Herwig::ConstituentReshuffler>
  : public ClassTraitsBase<Herwig::ConstituentReshuffler> {
  static string className() { return "Herwig::ConstituentReshuffler"; }
  static string library() { return "HwDipoleShower.so"; }
};
 
}
 
#endif /* HERWIG_ConstituentReshuffler_H */