BaseHadronizer.h

Go to the documentation of this file.

// -*- C++ -*-
//
//

// class BaseHadronizer meant as base class for hadronizers
// implements a few common methods concerning communication with the
// gen::HadronizerFilter<...> and gen::GeneratorFilter<...> templates,
// mostly memory management regarding the GenEvent pointers and such

#ifndef gen_BaseHadronizer_h
#define gen_BaseHadronizer_h

#include <memory>
#include <string>
#include <vector>

#include <memory>

#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"

#include "SimDataFormats/GeneratorProducts/interface/GenRunInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/GenLumiInfoHeader.h"

#include "SimDataFormats/GeneratorProducts/interface/LHERunInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/LHEEventProduct.h"

#include "GeneratorInterface/LHEInterface/interface/LHERunInfo.h"
#include "GeneratorInterface/LHEInterface/interface/LHEEvent.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"

#include "CLHEP/Random/RandomEngine.h"


// foward declarations
namespace edm {
  class Event;
}

namespace CLHEP {
  class HepRandomEngine;
}

namespace gen {

  class BaseHadronizer {
  public:
    BaseHadronizer( edm::ParameterSet const& ps );
    virtual ~BaseHadronizer() noexcept (false) {}

    // GenRunInfo and GenEvent passing
    GenRunInfoProduct &getGenRunInfo() { return genRunInfo_; }
    std::unique_ptr<HepMC::GenEvent> getGenEvent() { return std::move(genEvent_); }
    std::unique_ptr<GenEventInfoProduct> getGenEventInfo() { return std::move(genEventInfo_); }
    virtual std::unique_ptr<GenLumiInfoHeader> getGenLumiInfoHeader() const;
    std::unique_ptr<lhef::LHEEvent> getLHEEvent() { return std::move(lheEvent_);}

    void resetEvent(std::unique_ptr<HepMC::GenEvent> event) { genEvent_ = std::move(event); }
    void resetEventInfo(std::unique_ptr<GenEventInfoProduct> eventInfo) { genEventInfo_ = std::move(eventInfo); }

    // LHERunInfo and LHEEvent passing
    const std::shared_ptr<lhef::LHERunInfo> &getLHERunInfo() const { return lheRunInfo_; }

    void setLHERunInfo(std::unique_ptr<lhef::LHERunInfo> runInfo) { lheRunInfo_ = std::move(runInfo); }
    void setLHEEvent(std::unique_ptr<lhef::LHEEvent> event) { lheEvent_ = std::move(event); }

    // interface for accessing the EDM information from the hadronizer
    void setEDMEvent(edm::Event &event) { edmEvent_ = &event; }
    edm::Event &getEDMEvent() const { return *edmEvent_; }
    virtual bool select(HepMC::GenEvent*) const { return true;}

    void setRandomEngine(CLHEP::HepRandomEngine* v) { doSetRandomEngine(v); }

    std::vector<std::string> const& sharedResources() const { return doSharedResources(); }
    
    int randomIndex() const { return randomIndex_; }
    const std::string &randomInitConfigDescription() const { return randomInitConfigDescriptions_[randomIndex_]; }
    const std::string &gridpackPath() const { return gridpackPaths_[std::max(randomIndex_,0)]; }
    
    void randomizeIndex(edm::LuminosityBlock const& lumi, CLHEP::HepRandomEngine* rengine);
    void generateLHE(edm::LuminosityBlock const& lumi, CLHEP::HepRandomEngine* rengine, unsigned int ncpu);
    void cleanLHE();

  protected:
    GenRunInfoProduct& runInfo() { return genRunInfo_; }
    std::unique_ptr<HepMC::GenEvent>& event() { return genEvent_; }
    std::unique_ptr<GenEventInfoProduct>& eventInfo() { return genEventInfo_; }

    lhef::LHEEvent* lheEvent() { return lheEvent_.get(); }
    lhef::LHERunInfo *lheRunInfo() { return lheRunInfo_.get(); }
    int randomIndex_;
    std::string lheFile_;

  private:

    virtual void doSetRandomEngine(CLHEP::HepRandomEngine* v) { }

    virtual std::vector<std::string> const& doSharedResources() const { return theSharedResources; }

    GenRunInfoProduct                   genRunInfo_;
    std::unique_ptr<HepMC::GenEvent>      genEvent_;
    std::unique_ptr<GenEventInfoProduct>  genEventInfo_;

    std::shared_ptr<lhef::LHERunInfo>     lheRunInfo_;
    std::unique_ptr<lhef::LHEEvent>       lheEvent_;

    edm::Event                          *edmEvent_;

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

    std::vector<double> randomInitWeights_;
    std::vector<std::string> randomInitConfigDescriptions_;
    std::vector<std::string> gridpackPaths_;
        
  };

} // namespace gen

#endif // gen_BaseHadronizer_h