Phase2TrackerDigitizer.h

Go to the documentation of this file.

#ifndef __SimTracker_SiPhase2Digitizer_Phase2TrackerDigitizer_h
#define __SimTracker_SiPhase2Digitizer_Phase2TrackerDigitizer_h

//-------------------------------------------------------------
// class Phase2TrackerDigitizer
//
// Phase2TrackerDigitizer produces digis from SimHits
// The real algorithm is in Phase2TrackerDigitizerAlgorithm
//
// Author: Suchandra Dutta, Suvankar Roy Chowdhury, Subir Sarkar
//
//--------------------------------------------------------------

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

#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "SimTracker/SiPhase2Digitizer/plugins/Phase2TrackerDigitizerFwd.h"
#include "FWCore/Framework/interface/ESWatcher.h"
#include "FWCore/Framework/interface/stream/EDProducerBase.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"

#include <unordered_map>

// Forward declaration
namespace CLHEP {
  class HepRandomEngine;
}

namespace edm {
  class Event;
  class EventSetup;
  class ParameterSet;
  template<typename T> class Handle;
  class ConsumesCollector;
}

class MagneticField;
class PileUpEventPrincipal;
class PSimHit;
class Phase2TrackerDigitizerAlgorithm;
class TrackerDigiGeometryRecord;

namespace cms 
{
  class Phase2TrackerDigitizer: public DigiAccumulatorMixMod {

  public:
    typedef std::unordered_map<unsigned, TrackerGeometry::ModuleType>  ModuleTypeCache;

    explicit Phase2TrackerDigitizer(const edm::ParameterSet& iConfig, edm::stream::EDProducerBase& mixMod, edm::ConsumesCollector& iC);
    virtual ~Phase2TrackerDigitizer();
    virtual void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override;
    virtual void accumulate(edm::Event const& e, edm::EventSetup const& c) override;
    virtual void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override;
    virtual void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override;
    virtual void beginJob() {}
    virtual void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& iSetup) override;
    virtual void endLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& iSetup) override; 

    template <class T>
    void accumulate_local(T const& iEvent, edm::EventSetup const& iSetup);

  
  private:
    using vstring = std::vector<std::string> ;

    // constants of different algorithm types
    enum class AlgorithmType {
      InnerPixel,
      PixelinPS,
      StripinPS,
      TwoStrip,
      Unknown   
    };
    AlgorithmType getAlgoType(unsigned int idet); 

    void accumulatePixelHits(edm::Handle<std::vector<PSimHit> >, 
                 size_t globalSimHitIndex,
                 const unsigned int tofBin);   
    void addPixelCollection(edm::Event& iEvent, const edm::EventSetup& iSetup, const bool ot_analog);
    void addOuterTrackerCollection(edm::Event& iEvent, const edm::EventSetup& iSetup);
   

    bool first_;

    std::map<std::string,size_t> crossingSimHitIndexOffset_; 
    std::map<AlgorithmType, std::unique_ptr<Phase2TrackerDigitizerAlgorithm> > algomap_;
    const std::string hitsProducer_;
    const vstring trackerContainers_;
    const std::string geometryType_;
    edm::ESHandle<TrackerGeometry> pDD_;
    edm::ESHandle<MagneticField> pSetup_;
    std::map<unsigned int, const Phase2TrackerGeomDetUnit*> detectorUnits_;
    CLHEP::HepRandomEngine* rndEngine_;
    edm::ESHandle<TrackerTopology> tTopoHand;
    edm::ESWatcher<TrackerDigiGeometryRecord> theTkDigiGeomWatcher;
    const edm::ParameterSet& iconfig_;

    // cache for detector types
    ModuleTypeCache moduleTypeCache_;
    
  };
}
#endif