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 <unordered_map>
 
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ESWatcher.h"
#include "FWCore/Framework/interface/ProducesCollector.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h"
#include "SimTracker/SiPhase2Digitizer/plugins/Phase2TrackerDigitizerFwd.h"
 
// Forward declaration
namespace CLHEP {
  class HepRandomEngine;
}
 
namespace edm {
  class Event;
  class EventSetup;
  class ParameterSet;
  template <typename T>
  class Handle;
  class ConsumesCollector;
}  // namespace edm
 
class MagneticField;
class PileUpEventPrincipal;
class PSimHit;
class Phase2TrackerDigitizerAlgorithm;
class TrackerDigiGeometryRecord;
 
namespace cms {
  class Phase2TrackerDigitizer : public DigiAccumulatorMixMod {
  public:
    using ModuleTypeCache = std::unordered_map<uint32_t, TrackerGeometry::ModuleType>;
 
    explicit Phase2TrackerDigitizer(const edm::ParameterSet& iConfig,
                                    edm::ProducesCollector,
                                    edm::ConsumesCollector& iC);
    ~Phase2TrackerDigitizer() override;
 
    void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override;
    void accumulate(edm::Event const& e, edm::EventSetup const& c) override;
    void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override;
    void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override;
    virtual void beginJob() {}
    void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& iSetup) override;
 
    template <class T>
    void accumulate_local(T const& iEvent, edm::EventSetup const& iSetup);
 
    // For premixing
    void loadAccumulator(const std::map<uint32_t, std::map<int, float> >& accumulator);
 
  private:
    using vstring = std::vector<std::string>;
 
    // constants of different algorithm types
    enum class AlgorithmType { InnerPixel, InnerPixel3D, PixelinPS, StripinPS, TwoStrip, Unknown };
    AlgorithmType getAlgoType(uint32_t idet);
 
    void accumulatePixelHits(edm::Handle<std::vector<PSimHit> >, size_t globalSimHitIndex, const uint32_t tofBin);
    void addPixelCollection(edm::Event& iEvent, const edm::EventSetup& iSetup, const bool ot_analog);
 
    // Templated for premixing
    template <typename DigiType>
    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<uint32_t, const Phase2TrackerGeomDetUnit*> detectorUnits_;
    edm::ESHandle<TrackerTopology> tTopoHand_;
    edm::ESWatcher<TrackerDigiGeometryRecord> theTkDigiGeomWatcher_;
    const bool isOuterTrackerReadoutAnalog_;
    const bool premixStage1_;
    const bool makeDigiSimLinks_;
    // cache for detector types
    ModuleTypeCache moduleTypeCache_;
  };
}  // namespace cms
#endif