SiStripClusterToDigiProducer.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
 
#include "CalibFormats/SiStripObjects/interface/SiStripGain.h"
#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
 
#include "CalibTracker/Records/interface/SiStripDependentRecords.h"
 
#include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
#include <numeric>
 
class SiStripClusterToDigiProducer : public edm::stream::EDProducer<> {
  typedef edmNew::DetSetVector<SiStripCluster> ClusterCollection;
  typedef edmNew::DetSet<SiStripCluster> DetClusterCollection;
  typedef edmNew::DetSet<SiStripCluster>::const_iterator DetClusIter;
 
  typedef edm::DetSetVector<SiStripDigi> DigiCollection;
  typedef edm::DetSet<SiStripDigi> DetDigiCollection;
  typedef edm::DetSet<SiStripDigi>::const_iterator DetDigiIter;
 
public:
  explicit SiStripClusterToDigiProducer(const edm::ParameterSet& conf);
  void produce(edm::Event&, const edm::EventSetup&) override;
 
private:
  void process(const ClusterCollection& input, std::vector<DetDigiCollection>& output_base);
  void initialize(const edm::EventSetup& es);
  void setDetId(const uint32_t id);
  float gain(const uint16_t& strip) const { return gainHandle->getStripGain(strip, gainRange); }
  uint16_t applyGain(const uint16_t& strip, const uint16_t& adc);
 
  edm::EDGetTokenT<ClusterCollection> token;
  SiStripApvGain::Range gainRange;
  edm::ESHandle<SiStripGain> gainHandle;
  uint32_t gain_cache_id, detId;
};
 
SiStripClusterToDigiProducer::SiStripClusterToDigiProducer(const edm::ParameterSet& conf) {
  token = consumes<ClusterCollection>(conf.getParameter<edm::InputTag>("ClusterProducer"));
 
  produces<DigiCollection>("ZeroSuppressed");
  produces<DigiCollection>("VirginRaw");
  produces<DigiCollection>("ProcessedRaw");
  produces<DigiCollection>("ScopeMode");
}
 
void SiStripClusterToDigiProducer::produce(edm::Event& event, const edm::EventSetup& es) {
  initialize(es);
 
  std::vector<DetDigiCollection> output_base;
  edm::Handle<ClusterCollection> input;
  event.getByToken(token, input);
 
  if (input.isValid())
    process(*input, output_base);
 
  auto outputZS = std::make_unique<DigiCollection>(output_base);
  auto outputVR = std::make_unique<DigiCollection>();
  auto outputPR = std::make_unique<DigiCollection>();
  auto outputSM = std::make_unique<DigiCollection>();
 
  event.put(std::move(outputZS), "ZeroSuppressed");
  event.put(std::move(outputVR), "VirginRaw");
  event.put(std::move(outputPR), "ProcessedRaw");
  event.put(std::move(outputSM), "ScopeMode");
}
 
void SiStripClusterToDigiProducer::process(const ClusterCollection& input,
                                           std::vector<DetDigiCollection>& output_base) {
  for (ClusterCollection::const_iterator it = input.begin(); it != input.end(); ++it) {
    uint32_t detid = it->detId();
 
    setDetId(detid);
    DetDigiCollection detDigis(detid);
 
    DetClusIter clus(it->begin()), endclus(it->end());
    for (; clus != endclus; clus++) {
      size_t istrip = 0;
      size_t width = clus->amplitudes().size();
      size_t firstStrip = clus->firstStrip();
      uint16_t stripPos = firstStrip;
      for (; istrip < width; ++istrip) {
        detDigis.data.push_back(SiStripDigi(stripPos, applyGain(stripPos, clus->amplitudes()[istrip])));
        stripPos++;
      }
    }
 
    if (!detDigis.empty())
      output_base.push_back(detDigis);
  }
}
 
void SiStripClusterToDigiProducer::initialize(const edm::EventSetup& es) {
  uint32_t g_cache_id = es.get<SiStripGainRcd>().cacheIdentifier();
 
  if (g_cache_id != gain_cache_id) {
    es.get<SiStripGainRcd>().get(gainHandle);
    gain_cache_id = g_cache_id;
  }
}
 
inline void SiStripClusterToDigiProducer::setDetId(const uint32_t id) {
  gainRange = gainHandle->getRange(id);
  detId = id;
}
 
inline uint16_t SiStripClusterToDigiProducer::applyGain(const uint16_t& strip, const uint16_t& adc) {
  if (adc > 255)
    throw cms::Exception("Invalid Charge") << " digi at strip " << strip << " has ADC out of range " << adc;
  if (adc > 253)
    return adc;  //saturated, do not scale
  uint16_t charge = static_cast<uint16_t>(
      adc * gain(strip) +
      0.5);  //NB: here we revert the gain applied at the clusterizer level. for this reason the adc counts are multiplied by gain and not divided
  return (charge > 1022 ? 255 : (charge > 253 ? 254 : charge));
}
 
#include "FWCore/PluginManager/interface/ModuleDef.h"
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(SiStripClusterToDigiProducer);