SiPixelGainCalibrationServiceBase.h

Go to the documentation of this file.

#ifndef CalibTracker_SiPixelESProducers_SiPixelGainCalibrationServiceBase_H
#define CalibTracker_SiPixelESProducers_SiPixelGainCalibrationServiceBase_H

// ************************************************************************
// ************************************************************************
// *******     SiPixelOfflineCalibrationServiceBase                 *******
// *******     Author: Vincenzo Chiochia (chiochia@cern.ch)         *******
// *******     Modified: Evan Friis (evan.friis@cern.ch)            *******
// *******     Additions: Freya Blekman (freya.blekman@cern.ch)     *******
// *******                                                          *******
// *******     Provides common interface to SiPixel gain calib      *******
// *******     payloads in offline database                         *******
// *******                                                          *******
// ************************************************************************
// ************************************************************************

#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"

// Framework
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"

// Abstract base class provides common interface to different payload getters 
class SiPixelGainCalibrationServiceBase {
   public:

  typedef edm::DetSet<PixelDigi>::const_iterator    DigiIterator;


  SiPixelGainCalibrationServiceBase(){};
  virtual ~SiPixelGainCalibrationServiceBase(){};
  
  // default inplementation from PixelThresholdClusterizer 
  virtual void calibrate(uint32_t detID, DigiIterator b, DigiIterator e, float conversionFactor, float offset, int * electron);
  
  virtual float getGain      ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual float getPedestal  ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual bool  isDead       ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual bool  isDeadColumn ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual bool  isNoisy       ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual bool  isNoisyColumn ( const uint32_t& detID , const int& col , const int& row)=0;
  virtual void  setESObjects(const edm::EventSetup& es )=0;
  virtual std::vector<uint32_t> getDetIds()=0;
  virtual double getGainLow()=0;
  virtual double getGainHigh()=0;
  virtual double getPedLow()=0;
  virtual double getPedHigh()=0;

};


// Abstract template class that defines DB access types and payload specific getters
template<class thePayloadObject, class theDBRecordType>
class SiPixelGainCalibrationServicePayloadGetter : public SiPixelGainCalibrationServiceBase {

 public:
  explicit SiPixelGainCalibrationServicePayloadGetter(const edm::ParameterSet& conf);
  ~SiPixelGainCalibrationServicePayloadGetter() override{};

  //Abstract methods
  float getGain(const uint32_t& detID, const int& col, const int& row) override =0;
  float getPedestal(const uint32_t& detID, const int& col, const int& row) override =0;

  bool isDead       ( const uint32_t& detID, const int& col, const int& row ) override =0;
  bool isDeadColumn ( const uint32_t& detID, const int& col, const int& row ) override =0;

  bool isNoisy       ( const uint32_t& detID, const int& col, const int& row ) override =0;
  bool isNoisyColumn ( const uint32_t& detID, const int& col, const int& row ) override =0;

  void    setESObjects(const edm::EventSetup& es ) override;

  thePayloadObject const & payload() const { return *ped; }

  std::vector<uint32_t> getDetIds() override;
  double getGainLow() override;
  double getGainHigh() override;
  double getPedLow() override;
  double getPedHigh() override;

 protected:

  float   getPedestalByPixel(const uint32_t& detID,const int& col, const int& row, bool& isDeadPixel, bool& isNoisyPixel) ;
  float   getGainByPixel(const uint32_t& detID,const int& col, const int& row, bool& isDeadPixel, bool& isNoisyPixel) ;

  // the getByColumn functions caches the data to prevent multiple lookups on averaged quanitities
  float   getPedestalByColumn(const uint32_t& detID,const int& col, const int& row, bool& isDeadColumn, bool& isNoisyColumn) ;
  float   getGainByColumn(const uint32_t& detID,const int& col, const int& row, bool& isDeadColumn, bool& isNoisyColumn) ;

  void    throwExepctionForBadRead(std::string payload, const uint32_t& detID, const int& col, const int& row, double value = -1) const;


  edm::ParameterSet conf_;
  bool ESetupInit_;
  edm::ESHandle<thePayloadObject> ped;
  int numberOfRowsAveragedOver_;
  double gainLow_;
  double gainHigh_;
  double pedLow_;
  double pedHigh_;

  uint32_t old_detID;
  int      old_cols;
  // Cache data for payloads that average over columns
  
  // these two quantities determine what column averaged block we are in - i.e. ROC 1 or ROC 2
  int      oldAveragedBlockDataGain_;
  int      oldAveragedBlockDataPed_;
  
  bool     oldThisColumnIsDeadGain_;
  bool     oldThisColumnIsDeadPed_;
  bool     oldThisColumnIsNoisyGain_;
  bool     oldThisColumnIsNoisyPed_;
  int      oldColumnIndexGain_;
  int      oldColumnIndexPed_;
  float    oldColumnValueGain_;
  float    oldColumnValuePed_;

  typename thePayloadObject::Range old_range;
};

template<class thePayloadObject, class theDBRecordType>
SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::SiPixelGainCalibrationServicePayloadGetter(const edm::ParameterSet& conf):
  conf_(conf),
  ESetupInit_(false)
{

  edm::LogInfo("SiPixelGainCalibrationServicePayloadGetter")  << "[SiPixelGainCalibrationServicePayloadGetter::SiPixelGainCalibrationServicePayloadGetter]";
  // Initialize cache variables
  old_detID             = 0;
  oldColumnIndexGain_   = -1;
  oldColumnIndexPed_    = -1;
  oldColumnValueGain_   = 0.;
  oldColumnValuePed_    = 0.; 

  oldAveragedBlockDataGain_ = -1;
  oldAveragedBlockDataPed_  = -1;
  oldThisColumnIsDeadGain_ = false;
  oldThisColumnIsDeadPed_  = false;
  oldThisColumnIsNoisyGain_ = false;
  oldThisColumnIsNoisyPed_  = false;

}

template<class thePayloadObject, class theDBRecordType>
void SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::setESObjects( const edm::EventSetup& es ) {

    es.get<theDBRecordType>().get(ped);
    // ped->initialize();  moved to cond infrastructure
    numberOfRowsAveragedOver_ = ped->getNumberOfRowsToAverageOver();
    ESetupInit_ = true;

}

template<class thePayloadObject, class theDBRecordType>
std::vector<uint32_t> SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getDetIds() {

  std::vector<uint32_t> vdetId_;  
  ped->getDetIds(vdetId_);
  return vdetId_;

}

template<class thePayloadObject, class theDBRecordType>
double SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getGainLow() {
  double gainLow_ = ped->getGainLow();
  return gainLow_;
}

template<class thePayloadObject, class theDBRecordType>
double SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getGainHigh() {
  double gainHigh_ = ped->getGainHigh();
  return gainHigh_;
}

template<class thePayloadObject, class theDBRecordType>
double SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getPedLow() {
  double pedLow_ = ped->getPedLow();
  return pedLow_;
}

template<class thePayloadObject, class theDBRecordType>
double SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getPedHigh() {
  double pedHigh_ = ped->getPedHigh();
  return pedHigh_;
}

template<class thePayloadObject, class theDBRecordType>
float SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getPedestalByPixel(const uint32_t& detID,const int& col, const int& row, bool& isDead, bool& isNoisy) { 
  if(ESetupInit_) {
    //&&&&&&&&&&&&&&&&&&&&
    //Access from DB
    //&&&&&&&&&&&&&&&&&&&&
      if (detID != old_detID){
    old_detID=detID;
        std::pair<const typename thePayloadObject::Range, const int> rangeAndNCols = ped->getRangeAndNCols(detID);
    old_range = rangeAndNCols.first;
    old_cols  = rangeAndNCols.second;
    oldColumnIndexGain_ = -1;
      }
      //std::cout<<" Pedestal "<<ped->getPed(col, row, old_range, old_cols)<<std::endl;
      return  ped->getPed(col, row, old_range, old_cols, isDead, isNoisy);
  } else throw cms::Exception("NullPointer")
    << "[SiPixelGainCalibrationServicePayloadGetter::getPedestalByPixel] SiPixelGainCalibrationRcd not initialized ";
}


template<class thePayloadObject, class theDBRecordType>
float SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getGainByPixel(const uint32_t& detID,const int& col, const int& row, bool& isDead, bool& isNoisy) {
  if(ESetupInit_) {
    //&&&&&&&&&&&&&&&&&&&&
    //Access from DB
    //&&&&&&&&&&&&&&&&&&&&
    if (detID != old_detID){
      old_detID=detID;
      std::pair<const typename thePayloadObject::Range, const int> rangeAndNCols = ped->getRangeAndNCols(detID);
      old_range = rangeAndNCols.first;
      old_cols  = rangeAndNCols.second;
      return oldColumnValuePed_;
    }
    return ped->getGain(col, row, old_range, old_cols, isDead, isNoisy);
  } else throw cms::Exception("NullPointer")
    << "[SiPixelGainCalibrationServicePayloadGetter::getGainByPixel] SiPixelGainCalibrationRcd not initialized ";
}


template<class thePayloadObject, class theDBRecordType>
float SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getPedestalByColumn(const uint32_t& detID,const int& col, const int& row, bool& isDeadColumn, bool& isNoisyColumn) { 
  if(ESetupInit_) {
    //&&&&&&&&&&&&&&&&&&&&
    //Access from DB
    //&&&&&&&&&&&&&&&&&&&&
      // see if we are in the same averaged data block
      bool inTheSameAveragedDataBlock = false;
      if ( row / numberOfRowsAveragedOver_ == oldAveragedBlockDataPed_ )
         inTheSameAveragedDataBlock = true;

      if (detID != old_detID){
    old_detID=detID;
        std::pair<const typename thePayloadObject::Range, const int> rangeAndNCols = ped->getRangeAndNCols(detID);
    old_range = rangeAndNCols.first;
    old_cols  = rangeAndNCols.second;
    oldColumnIndexGain_ = -1;
      } 
      else if (col == oldColumnIndexPed_ && inTheSameAveragedDataBlock) // same DetID, same column, same data block
      {
         isDeadColumn = oldThisColumnIsDeadPed_;
         isNoisyColumn = oldThisColumnIsNoisyPed_;
         return oldColumnValuePed_;
      } 

      oldColumnIndexPed_       = col;
      oldAveragedBlockDataPed_ = row / numberOfRowsAveragedOver_;
      oldColumnValuePed_       = ped->getPed(col, row, old_range, old_cols, isDeadColumn, isNoisyColumn);
      oldThisColumnIsDeadPed_  = isDeadColumn;
      oldThisColumnIsNoisyPed_  = isNoisyColumn;

      return oldColumnValuePed_;

  } else throw cms::Exception("NullPointer")
    << "[SiPixelGainCalibrationServicePayloadGetter::getPedestalByColumn] SiPixelGainCalibrationRcd not initialized ";
}


template<class thePayloadObject, class theDBRecordType>
float SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::getGainByColumn(const uint32_t& detID,const int& col, const int& row, bool& isDeadColumn, bool& isNoisyColumn) {
  if(ESetupInit_) {
    //&&&&&&&&&&&&&&&&&&&&
    //Access from DB
    //&&&&&&&&&&&&&&&&&&&&
    bool inTheSameAveragedDataBlock = false;
    if ( row / numberOfRowsAveragedOver_ == oldAveragedBlockDataGain_ )
       inTheSameAveragedDataBlock = true;

    if (detID != old_detID){
      old_detID=detID;
      std::pair<const typename thePayloadObject::Range, const int> rangeAndNCols = ped->getRangeAndNCols(detID);
      old_range = rangeAndNCols.first;
      old_cols  = rangeAndNCols.second;
      oldColumnIndexPed_ = -1;
    }
    else if (col == oldColumnIndexGain_ && inTheSameAveragedDataBlock) // same DetID, same column
    {
       isDeadColumn = oldThisColumnIsDeadGain_;
       isDeadColumn = oldThisColumnIsNoisyGain_;
       return oldColumnValueGain_;
    }

    oldColumnIndexGain_       = col;
    oldAveragedBlockDataGain_ = row / numberOfRowsAveragedOver_;
    oldColumnValueGain_       = ped->getGain(col, row, old_range, old_cols, isDeadColumn, isNoisyColumn);
    oldThisColumnIsDeadGain_  = isDeadColumn;
    oldThisColumnIsNoisyGain_  = isNoisyColumn;

    return oldColumnValueGain_;

  } else throw cms::Exception("NullPointer")
    << "[SiPixelGainCalibrationServicePayloadGetter::getGainByColumn] SiPixelGainCalibrationRcd not initialized ";
}

template<class thePayloadObject, class theDBRecordType>
void SiPixelGainCalibrationServicePayloadGetter<thePayloadObject,theDBRecordType>::throwExepctionForBadRead(std::string payload, const uint32_t& detID, const int& col, const int& row, const double value) const
{
   std::cerr << "[SiPixelGainCalibrationServicePayloadGetter::SiPixelGainCalibrationServicePayloadGetter]"
      << "[SiPixelGainCalibrationServicePayloadGetter] ERROR - Slow down, speed racer! You have tried to read the ped/gain on a pixel that is flagged as dead/noisy. For payload: " << payload << "  DETID: " 
      << detID << " col: " << col << " row: " << row << ". You must check if the pixel is dead/noisy before asking for the ped/gain value, otherwise you will get corrupt data! value: " << value << std::endl;

   // really yell if this occurs

   edm::LogError("SiPixelGainCalibrationService") << "[SiPixelGainCalibrationServicePayloadGetter::SiPixelGainCalibrationServicePayloadGetter]"
      << "[SiPixelGainCalibrationServicePayloadGetter] ERROR - Slow down, speed racer! You have tried to read the ped/gain on a pixel that is flagged as dead/noisy. For payload: " << payload << "  DETID: " 
      << detID << " col: " << col << " row: " << row << ". You must check if the pixel is dead/noisy before asking for the ped/gain value, otherwise you will get corrupt data! value: " << value << std::endl;
}


#endif