DataMixingSiStripMCDigiWorker.h

Go to the documentation of this file.

#ifndef DataMixingSiStripMCDigiWorker_h
#define SimDataMixingSiStripMCDigiWorker_h

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventPrincipal.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Utilities/interface/RandomNumberGenerator.h"

//Data Formats
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSet.h"
#include "DataFormats/SiStripDigi/interface/SiStripDigi.h"

#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CondFormats/SiStripObjects/interface/SiStripPedestals.h"
#include "CondFormats/SiStripObjects/interface/SiStripThreshold.h"
#include "CalibFormats/SiStripObjects/interface/SiStripGain.h"
#include "SimTracker/SiStripDigitizer/interface/SiTrivialDigitalConverter.h"
#include "SimTracker/SiStripDigitizer/interface/SiGaussianTailNoiseAdder.h"
#include "RecoLocalTracker/SiStripZeroSuppression/interface/SiStripFedZeroSuppression.h"

#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
#include "Geometry/CommonTopologies/interface/StripTopology.h"
#include "Geometry/CommonDetUnit/interface/GeomDetType.h"


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

namespace edm
{
  class ModuleCallingContext;
  class ConsumesCollector; 
  class DataMixingSiStripMCDigiWorker
    {
    public:

      DataMixingSiStripMCDigiWorker();

      explicit DataMixingSiStripMCDigiWorker(const edm::ParameterSet& ps, edm::ConsumesCollector && iC);
      virtual ~DataMixingSiStripMCDigiWorker();

      void putSiStrip(edm::Event &e, edm::EventSetup const& iSetup) ;
      void addSiStripSignals(const edm::Event &e); 
      void addSiStripPileups(const int bcr, const edm::EventPrincipal*,unsigned int EventId,
                             ModuleCallingContext const*);


      virtual void initializeEvent(const edm::Event &e, edm::EventSetup const& iSetup);

      void DMinitializeDetUnit(StripGeomDetUnit const * det, const edm::EventSetup& iSetup );

    private:
      // data specifiers

      edm::InputTag SistripLabelSig_ ;        // name given to collection of SiStrip digis
      edm::InputTag SiStripPileInputTag_ ;    // InputTag for pileup strips
      std::string SiStripDigiCollectionDM_  ; // secondary name to be given to new SiStrip digis

      edm::InputTag SistripAPVLabelSig_;      // where to find vector of dead APVs
      edm::InputTag SiStripAPVPileInputTag_;
      std::string SistripAPVListDM_;          // output tag


      // 

      typedef float Amplitude;
      typedef std::pair<uint16_t, Amplitude> RawDigi;  // Replacement for SiStripDigi with pulse height instead of integer ADC
      typedef std::vector<SiStripDigi> OneDetectorMap;   // maps by strip ID for later combination - can have duplicate strips
      typedef std::vector<RawDigi> OneDetectorRawMap;   // maps by strip ID for later combination - can have duplicate strips
      typedef std::map<uint32_t, OneDetectorMap> SiGlobalIndex; // map to all data for each detector ID
      typedef std::map<uint32_t, OneDetectorRawMap> SiGlobalRawIndex; // map to all data for each detector ID

      typedef SiDigitalConverter::DigitalVecType DigitalVecType;

      SiGlobalIndex SiHitStorage_;
      SiGlobalRawIndex SiRawDigis_;

      //      unsigned int eventId_; //=0 for signal, from 1-n for pileup events

      // variables for temporary storage of mixed hits:


      typedef std::map<int, Amplitude>  SignalMapType;
      typedef std::map<uint32_t, SignalMapType>  signalMaps;

      const SignalMapType* getSignal(uint32_t detID) const {
    auto where = signals_.find(detID);
    if(where == signals_.end()) {
      return 0;
    }
    return &where->second;
      }

      signalMaps signals_;

      // to keep track of dead APVs from HIP interactions
      typedef std::multimap< uint32_t, std::bitset<6> > APVMap;

      APVMap theAffectedAPVmap_;

      // for noise adding:

      std::string label_;

      std::string gainLabel;
      bool SingleStripNoise;
      bool peakMode;
      double theThreshold;
      double theElectronPerADC;
      bool APVSaturationFromHIP_;
      int theFedAlgo;
      std::string geometryType;

      std::unique_ptr<SiGaussianTailNoiseAdder> theSiNoiseAdder;
      std::unique_ptr<SiStripFedZeroSuppression> theSiZeroSuppress;
      std::unique_ptr<SiTrivialDigitalConverter> theSiDigitalConverter;

      edm::ESHandle<TrackerGeometry> pDD;

      // bad channels for each detector ID
      std::map<unsigned int, std::vector<bool> > allBadChannels;
      // channels killed by HIP interactions for each detector ID
      std::map<unsigned int, std::vector<bool> > allHIPChannels;
      // first and last channel wit signal for each detector ID
      std::map<unsigned int, size_t> firstChannelsWithSignal;
      std::map<unsigned int, size_t> lastChannelsWithSignal;

      //----------------------------

      class StrictWeakOrdering{
      public:
    bool operator() (SiStripDigi i,SiStripDigi j) const {return i.strip() < j.strip();}
      };

      class StrictWeakRawOrdering{
      public:
    bool operator() (RawDigi i,RawDigi j) const {return i.first < j.first;}
      };

    };
}//edm

#endif