PyquenHadronizer.h

Go to the documentation of this file.

#ifndef Pyquen_Hadronizer_h
#define Pyquen_Hadronizer_h

#include "GeneratorInterface/Core/interface/BaseHadronizer.h"
#include "GeneratorInterface/HiGenCommon/interface/BaseHiGenEvtSelector.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "FWCore/Utilities/interface/EDGetToken.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 "HepMC/GenEvent.h"

namespace CLHEP {
  class HepRandomEngine;
}

namespace gen {
  class Pythia6Service;

  class PyquenHadronizer : public BaseHadronizer {
  public:
    PyquenHadronizer(const edm::ParameterSet&, edm::ConsumesCollector&&);
    ~PyquenHadronizer() 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; }
    bool select(HepMC::GenEvent* evtTry) const override { return selector_->filter(evtTry); }
    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);

    bool pyqpythia_init(const edm::ParameterSet& pset);
    bool pyquen_init(const edm::ParameterSet& pset);
    const char* nucleon();
    void rotateEvtPlane(HepMC::GenEvent* evt, double angle);

    edm::ParameterSet pset_;
    double abeamtarget_;                
    unsigned int angularspecselector_;  
    double bmin_;                       
    double bmax_;                       
    double bfixed_;                     
    int cflag_;                         
    double comenergy;                   
    bool doquench_;                     
    bool doradiativeenloss_;            
    bool docollisionalenloss_;          
    bool doIsospin_;                    
    int protonSide_;
    bool embedding_;
    double evtPlane_;
    double pfrac_;  

    unsigned int nquarkflavor_;      
    double qgpt0_;                   
    double qgptau0_;                 
    unsigned int maxEventsToPrint_;  

    HepMC::FourVector* fVertex_;     
    std::vector<double> signalVtx_;  

    bool pythiaHepMCVerbosity_;           
    unsigned int pythiaPylistVerbosity_;  

    //    CLHEP::HepRandomEngine* fRandomEngine;
    edm::EDGetTokenT<CrossingFrame<edm::HepMCProduct> > src_;
    Pythia6Service* pythia6Service_;
    std::string filterType_;
    BaseHiGenEvtSelector* selector_;
  };
}  // namespace gen

#endif