HydjetHadronizer.h

Go to the documentation of this file.

#ifndef HydjetHadronizer_h
#define HydjetHadronizer_h

#define PYCOMP pycomp_

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "GeneratorInterface/Core/interface/BaseHadronizer.h"

#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
#include "SimDataFormats/PileupSummaryInfo/interface/PileupMixingContent.h"

#include <map>
#include <string>
#include <vector>
#include <cmath>

namespace CLHEP {
  class HepRandomEngine;
}

namespace HepMC {
  class GenEvent;
  class GenParticle;
  class GenVertex;
  class FourVector;
}  // namespace HepMC

namespace gen {
  class Pythia6Service;

  class HydjetHadronizer : public BaseHadronizer {
  public:
    HydjetHadronizer(const edm::ParameterSet&, edm::ConsumesCollector&&);
    ~HydjetHadronizer() override;

    bool generatePartonsAndHadronize();
    bool hadronize();
    bool decay();
    bool residualDecay();
    bool readSettings(int);
    bool initializeForExternalPartons();
    bool initializeForInternalPartons();
    bool declareStableParticles(const std::vector<int>&);
    bool declareSpecialSettings(const std::vector<std::string>&) { return true; }

    void finalizeEvent();
    void statistics();
    const char* classname() const;

  private:
    void doSetRandomEngine(CLHEP::HepRandomEngine* v) override;
    std::vector<std::string> const& doSharedResources() const override { return theSharedResources; }

    static const std::vector<std::string> theSharedResources;

    void add_heavy_ion_rec(HepMC::GenEvent* evt);
    HepMC::GenParticle* build_hyjet(int index, int barcode);
    HepMC::GenVertex* build_hyjet_vertex(int i, int id);
    bool get_particles(HepMC::GenEvent* evt);
    bool call_hyinit(double energy, double a, int ifb, double bmin, double bmax, double bfix, int nh);
    bool hydjet_init(const edm::ParameterSet& pset);
    inline double nuclear_radius() const;
    void rotateEvtPlane();
    int convertStatus(int st);

    HepMC::GenEvent* evt;
    edm::ParameterSet pset_;
    double abeamtarget_;                  
    int angularspecselector_;             
    double bfixed_;                       
    double bmax_;                         
    double bmin_;                         
    int cflag_;                           
    bool embedding_;                      
    double comenergy;                     
    bool doradiativeenloss_;              
    bool docollisionalenloss_;            
    double fracsoftmult_;                 
    double hadfreeztemp_;                 
    std::string hymode_;                  
    unsigned int maxEventsToPrint_;       
    double maxlongy_;                     
    double maxtrany_;                     
    int nsub_;                            
    int nhard_;                           
    int nmultiplicity_;                   
    int nsoft_;                           
    unsigned int nquarkflavor_;           
    unsigned int pythiaPylistVerbosity_;  
    double qgpt0_;                        
    double qgptau0_;                      

    double phi0_;  
    double sinphi0_;
    double cosphi0_;
    bool rotate_;  

    unsigned int shadowingswitch_;   
    double signn_;                   
    HepMC::FourVector* fVertex_;     
    std::vector<double> signalVtx_;  

    Pythia6Service* pythia6Service_;
    edm::EDGetTokenT<CrossingFrame<edm::HepMCProduct> > src_;
  };

  double HydjetHadronizer::nuclear_radius() const { return 1.15 * pow((double)abeamtarget_, 1. / 3.); }
}  // namespace gen
#endif