SiPixelDigiModule.cc

Go to the documentation of this file.

#include "DQM/SiPixelMonitorDigi/interface/SiPixelDigiModule.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQM/SiPixelCommon/interface/SiPixelHistogramId.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
// STL
#include <vector>
#include <memory>
#include <string>
#include <iostream>
#include <cstdlib>
#include <sstream>
#include <cstdio>

// Data Formats
#include "DataFormats/SiPixelDetId/interface/PixelBarrelName.h"
#include "DataFormats/SiPixelDetId/interface/PixelBarrelNameUpgrade.h"
#include "DataFormats/SiPixelDetId/interface/PixelEndcapName.h"
#include "DataFormats/SiPixelDetId/interface/PixelEndcapNameUpgrade.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "Geometry/Records/interface/TrackerTopologyRcd.h"

//
// Constructors
//
SiPixelDigiModule::SiPixelDigiModule() : id_(0), ncols_(416), nrows_(160) {}
SiPixelDigiModule::SiPixelDigiModule(const uint32_t& id) : id_(id), ncols_(416), nrows_(160) {}
SiPixelDigiModule::SiPixelDigiModule(const uint32_t& id, const int& ncols, const int& nrows)
    : id_(id), ncols_(ncols), nrows_(nrows) {}
//
// Destructor
//
SiPixelDigiModule::~SiPixelDigiModule() {}
//
// Book histograms
//
void SiPixelDigiModule::book(const edm::ParameterSet& iConfig,
                             const edm::EventSetup& iSetup,
                             DQMStore::IBooker& iBooker,
                             int type,
                             bool twoD,
                             bool hiRes,
                             bool reducedSet,
                             bool additInfo,
                             bool isUpgrade) {
  //isUpgrade = iConfig.getUntrackedParameter<bool>("isUpgrade");
  edm::ESHandle<TrackerTopology> tTopoHandle;
  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* pTT = tTopoHandle.product();

  bool barrel = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
  bool endcap = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
  bool isHalfModule = false;
  if (barrel) {
    isHalfModule = PixelBarrelName(DetId(id_), pTT, isUpgrade).isHalfModule();
  }

  std::string hid;
  // Get collection name and instantiate Histo Id builder
  edm::InputTag src = iConfig.getParameter<edm::InputTag>("src");

  int nbinx = ncols_ / 2, nbiny = nrows_ / 2;
  std::string twodtitle = "Number of Digis (1bin=four pixels)";
  std::string pxtitle = "Number of Digis (1bin=two columns)";
  std::string pytitle = "Number of Digis (1bin=two rows)";
  std::string twodroctitle = "ROC Occupancy (1bin=one ROC)";
  std::string twodzeroOccroctitle = "Zero Occupancy ROC Map (1bin=one ROC) for ";
  if (hiRes) {
    nbinx = ncols_;
    nbiny = nrows_;
    twodtitle = "Number of Digis (1bin=one pixel)";
    pxtitle = "Number of Digis (1bin=one column)";
    pytitle = "Number of Digis (1bin=one row)";
  }
  if (type == 0) {
    SiPixelHistogramId* theHistogramId = new SiPixelHistogramId(src.label());
    // Number of digis
    hid = theHistogramId->setHistoId("ndigis", id_);
    meNDigis_ = iBooker.book1D(hid, "Number of Digis", 25, 0., 25.);
    meNDigis_->setAxisTitle("Number of digis", 1);
    // Charge in ADC counts
    hid = theHistogramId->setHistoId("adc", id_);
    meADC_ = iBooker.book1D(hid, "Digi charge", 128, 0., 256.);
    meADC_->setAxisTitle("ADC counts", 1);
    if (!reducedSet) {
      if (twoD) {
        if (additInfo) {
          // 2D hit map
          hid = theHistogramId->setHistoId("hitmap", id_);
          mePixDigis_ = iBooker.book2D(hid, twodtitle, nbinx, 0., float(ncols_), nbiny, 0., float(nrows_));
          mePixDigis_->setAxisTitle("Columns", 1);
          mePixDigis_->setAxisTitle("Rows", 2);
          //std::cout << "During booking: type is "<< type << ", ID is "<< id_ << ", pwd for booking is " << theDMBE->pwd() << ", Plot name: " << hid << std::endl;
        }
      } else {
        // projections of 2D hit map
        hid = theHistogramId->setHistoId("hitmap", id_);
        mePixDigis_px_ = iBooker.book1D(hid + "_px", pxtitle, nbinx, 0., float(ncols_));
        mePixDigis_py_ = iBooker.book1D(hid + "_py", pytitle, nbiny, 0., float(nrows_));
        mePixDigis_px_->setAxisTitle("Columns", 1);
        mePixDigis_py_->setAxisTitle("Rows", 1);
      }
    }
    delete theHistogramId;
  }

  if (type == 1 && barrel) {
    uint32_t DBladder;
    DBladder = PixelBarrelName(DetId(id_), pTT, isUpgrade).ladderName();
    char sladder[80];
    sprintf(sladder, "Ladder_%02i", DBladder);
    hid = src.label() + "_" + sladder;
    if (isHalfModule)
      hid += "H";
    else
      hid += "F";
    // Number of digis
    meNDigisLad_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
    meNDigisLad_->setAxisTitle("Number of digis", 1);
    // Charge in ADC counts
    meADCLad_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
    meADCLad_->setAxisTitle("ADC counts", 1);
    if (!reducedSet) {
      if (twoD) {
        // 2D hit map
        mePixDigisLad_ = iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), nbiny, 0., float(nrows_));
        mePixDigisLad_->setAxisTitle("Columns", 1);
        mePixDigisLad_->setAxisTitle("Rows", 2);
        //std::cout << "During booking: type is "<< type << ", ID is "<< id_ << ", pwd for booking is " << theDMBE->pwd() << ", Plot name: " << hid << std::endl;
      } else {
        // projections of 2D hit map
        mePixDigisLad_px_ = iBooker.book1D("hitmap_" + hid + "_px", pxtitle, nbinx, 0., float(ncols_));
        mePixDigisLad_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, nbiny, 0., float(nrows_));
        mePixDigisLad_px_->setAxisTitle("Columns", 1);
        mePixDigisLad_py_->setAxisTitle("Rows", 1);
      }
    }
  }
  if (type == 2 && barrel) {
    uint32_t DBlayer;
    DBlayer = PixelBarrelName(DetId(id_), pTT, isUpgrade).layerName();
    char slayer[80];
    sprintf(slayer, "Layer_%i", DBlayer);
    hid = src.label() + "_" + slayer;
    if (!additInfo) {
      // Number of digis
      meNDigisLay_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
      meNDigisLay_->setAxisTitle("Number of digis", 1);
      // Charge in ADC counts
      meADCLay_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
      meADCLay_->setAxisTitle("ADC counts", 1);
    }
    if (!reducedSet) {
      if (twoD || additInfo) {
        // 2D hit map
        if (isHalfModule) {
          mePixDigisLay_ =
              iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), 2 * nbiny, 0., float(2 * nrows_));
        } else {
          mePixDigisLay_ =
              iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), nbiny, 0., float(nrows_));
        }
        mePixDigisLay_->setAxisTitle("Columns", 1);
        mePixDigisLay_->setAxisTitle("Rows", 2);

        //std::cout << "During booking: type is "<< type << ", ID is "<< id_ << ", pwd for booking is " << theDMBE->pwd() << ", Plot name: " << hid << std::endl;
        int yROCbins[3] = {18, 30, 42};
        mePixRocsLay_ = iBooker.book2D("rocmap_" + hid,
                                       twodroctitle,
                                       32,
                                       0.,
                                       32.,
                                       yROCbins[DBlayer - 1],
                                       1.5,
                                       1.5 + float(yROCbins[DBlayer - 1] / 2));
        mePixRocsLay_->setAxisTitle("ROCs per Module", 1);
        mePixRocsLay_->setAxisTitle("ROCs per 1/2 Ladder", 2);
        meZeroOccRocsLay_ = iBooker.book2D("zeroOccROC_map",
                                           twodzeroOccroctitle + hid,
                                           32,
                                           0.,
                                           32.,
                                           yROCbins[DBlayer - 1],
                                           1.5,
                                           1.5 + float(yROCbins[DBlayer - 1] / 2));
        meZeroOccRocsLay_->setAxisTitle("ROCs per Module", 1);
        meZeroOccRocsLay_->setAxisTitle("ROCs per 1/2 Ladder", 2);
      }
      if (!twoD && !additInfo) {
        // projections of 2D hit map
        mePixDigisLay_px_ = iBooker.book1D("hitmap_" + hid + "_px", pxtitle, nbinx, 0., float(ncols_));
        if (isHalfModule) {
          mePixDigisLay_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, 2 * nbiny, 0., float(2 * nrows_));
        } else {
          mePixDigisLay_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, nbiny, 0., float(nrows_));
        }
        mePixDigisLay_px_->setAxisTitle("Columns", 1);
        mePixDigisLay_py_->setAxisTitle("Rows", 1);
      }
    }
  }
  if (type == 3 && barrel) {
    uint32_t DBmodule;
    DBmodule = PixelBarrelName(DetId(id_), pTT, isUpgrade).moduleName();
    char smodule[80];
    sprintf(smodule, "Ring_%i", DBmodule);
    hid = src.label() + "_" + smodule;
    // Number of digis
    meNDigisPhi_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
    meNDigisPhi_->setAxisTitle("Number of digis", 1);
    // Charge in ADC counts
    meADCPhi_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
    meADCPhi_->setAxisTitle("ADC counts", 1);
    if (!reducedSet) {
      if (twoD) {
        // 2D hit map
        if (isHalfModule) {
          mePixDigisPhi_ =
              iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), 2 * nbiny, 0., float(2 * nrows_));
        } else {
          mePixDigisPhi_ =
              iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), nbiny, 0., float(nrows_));
        }
        mePixDigisPhi_->setAxisTitle("Columns", 1);
        mePixDigisPhi_->setAxisTitle("Rows", 2);
        //std::cout << "During booking: type is "<< type << ", ID is "<< id_ << ", pwd for booking is " << theDMBE->pwd() << ", Plot name: " << hid << std::endl;
      } else {
        // projections of 2D hit map
        mePixDigisPhi_px_ = iBooker.book1D("hitmap_" + hid + "_px", pxtitle, nbinx, 0., float(ncols_));
        if (isHalfModule) {
          mePixDigisPhi_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, 2 * nbiny, 0., float(2 * nrows_));
        } else {
          mePixDigisPhi_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, nbiny, 0., float(nrows_));
        }
        mePixDigisPhi_px_->setAxisTitle("Columns", 1);
        mePixDigisPhi_py_->setAxisTitle("Rows", 1);
      }
    }
  }
  if (type == 4 && endcap) {
    uint32_t blade;
    blade = PixelEndcapName(DetId(id_), pTT, isUpgrade).bladeName();

    char sblade[80];
    sprintf(sblade, "Blade_%02i", blade);
    hid = src.label() + "_" + sblade;
    // Number of digis
    meNDigisBlade_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
    meNDigisBlade_->setAxisTitle("Number of digis", 1);
    // Charge in ADC counts
    meADCBlade_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
    meADCBlade_->setAxisTitle("ADC counts", 1);
  }
  if (type == 5 && endcap) {
    uint32_t disk;
    disk = PixelEndcapName(DetId(id_), pTT, isUpgrade).diskName();

    char sdisk[80];
    sprintf(sdisk, "Disk_%i", disk);
    hid = src.label() + "_" + sdisk;
    if (!additInfo) {
      // Number of digis
      meNDigisDisk_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
      meNDigisDisk_->setAxisTitle("Number of digis", 1);
      // Charge in ADC counts
      meADCDisk_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
      meADCDisk_->setAxisTitle("ADC counts", 1);
    }
    if (additInfo) {
      mePixDigisDisk_ = iBooker.book2D("hitmap_" + hid, twodtitle, 260, 0., 260., 160, 0., 160.);
      mePixDigisDisk_->setAxisTitle("Columns", 1);
      mePixDigisDisk_->setAxisTitle("Rows", 2);
      //ROC information in disks
      mePixRocsDisk_ = iBooker.book2D("rocmap_" + hid, twodroctitle, 26, 0., 26., 24, 1., 13.);
      mePixRocsDisk_->setAxisTitle("ROCs per Module (2 Panels)", 1);
      mePixRocsDisk_->setAxisTitle("Blade Number", 2);
      meZeroOccRocsDisk_ = iBooker.book2D("zeroOccROC_map", twodzeroOccroctitle + hid, 26, 0., 26., 24, 1., 13.);
      meZeroOccRocsDisk_->setAxisTitle("Zero-Occupancy ROCs per Module (2 Panels)", 1);
      meZeroOccRocsDisk_->setAxisTitle("Blade Number", 2);
    }
  }
  if (type == 6 && endcap) {
    uint32_t panel;
    uint32_t module;
    panel = PixelEndcapName(DetId(id_), pTT, isUpgrade).pannelName();
    module = PixelEndcapName(DetId(id_), pTT, isUpgrade).plaquetteName();

    char slab[80];
    sprintf(slab, "Panel_%i_Ring_%i", panel, module);
    hid = src.label() + "_" + slab;
    // Number of digis
    meNDigisRing_ = iBooker.book1D("ndigis_" + hid, "Number of Digis", 25, 0., 25.);
    meNDigisRing_->setAxisTitle("Number of digis", 1);
    // Charge in ADC counts
    meADCRing_ = iBooker.book1D("adc_" + hid, "Digi charge", 128, 0., 256.);
    meADCRing_->setAxisTitle("ADC counts", 1);
    if (!reducedSet) {
      if (twoD) {
        // 2D hit map
        mePixDigisRing_ =
            iBooker.book2D("hitmap_" + hid, twodtitle, nbinx, 0., float(ncols_), nbiny, 0., float(nrows_));
        mePixDigisRing_->setAxisTitle("Columns", 1);
        mePixDigisRing_->setAxisTitle("Rows", 2);
        //std::cout << "During booking: type is "<< type << ", ID is "<< id_ << ", pwd for booking is " << theDMBE->pwd() << ", Plot name: " << hid << std::endl;
      } else {
        // projections of 2D hit map
        mePixDigisRing_px_ = iBooker.book1D("hitmap_" + hid + "_px", pxtitle, nbinx, 0., float(ncols_));
        mePixDigisRing_py_ = iBooker.book1D("hitmap_" + hid + "_py", pytitle, nbiny, 0., float(nrows_));
        mePixDigisRing_px_->setAxisTitle("Columns", 1);
        mePixDigisRing_py_->setAxisTitle("Rows", 1);
      }
    }
  }
}

//
// Fill histograms
//
int SiPixelDigiModule::fill(const edm::DetSetVector<PixelDigi>& input,
                            const edm::EventSetup& iSetup,
                            MonitorElement* combBarrel,
                            MonitorElement* chanBarrel,
                            std::vector<MonitorElement*>& chanBarrelL,
                            MonitorElement* combEndcap,
                            bool modon,
                            bool ladon,
                            bool layon,
                            bool phion,
                            bool bladeon,
                            bool diskon,
                            bool ringon,
                            bool twoD,
                            bool reducedSet,
                            bool twoDimModOn,
                            bool twoDimOnlyLayDisk,
                            int& nDigisA,
                            int& nDigisB,
                            bool isUpgrade) {
  edm::ESHandle<TrackerTopology> tTopoHandle;
  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* pTT = tTopoHandle.product();

  bool barrel = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
  bool endcap = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
  bool isHalfModule = false;
  uint32_t DBladder = 0;
  if (barrel) {
    isHalfModule = PixelBarrelName(DetId(id_), pTT, isUpgrade).isHalfModule();
    DBladder = PixelBarrelName(DetId(id_), pTT, isUpgrade).ladderName();
  }

  edm::DetSetVector<PixelDigi>::const_iterator isearch = input.find(id_);  // search  digis of detid

  unsigned int numberOfDigisMod = 0;
  int msize;
  if (isUpgrade) {
    msize = 10;
  } else {
    msize = 8;
  }
  int numberOfDigis[msize];
  for (int i = 0; i != msize; i++)
    numberOfDigis[i] = 0;
  nDigisA = 0;
  nDigisB = 0;
  if (isearch != input.end()) {  // Not an empty iterator

    // Look at digis now
    edm::DetSet<PixelDigi>::const_iterator di;
    for (di = isearch->data.begin(); di != isearch->data.end(); di++) {
      int adc = di->adc();     // charge
      int col = di->column();  // column
      int row = di->row();     // row
      numberOfDigisMod++;

      int DBlayer = 0;
      int DBmodule = 0;

      if (!isUpgrade) {
        PixelBarrelName::Shell DBshell = PixelBarrelName(DetId(id_), pTT, isUpgrade).shell();
        DBlayer = PixelBarrelName(DetId(id_), pTT, isUpgrade).layerName();
        DBmodule = PixelBarrelName(DetId(id_), pTT, isUpgrade).moduleName();
        if (barrel) {
          if (isHalfModule) {
            if (DBshell == PixelBarrelName::pI || DBshell == PixelBarrelName::pO) {
              numberOfDigis[0]++;
              nDigisA++;
              if (DBlayer == 1)
                numberOfDigis[2]++;
              if (DBlayer == 2)
                numberOfDigis[3]++;
              if (DBlayer == 3)
                numberOfDigis[4]++;
            }
            if (DBshell == PixelBarrelName::mI || DBshell == PixelBarrelName::mO) {
              numberOfDigis[1]++;
              nDigisB++;
              if (DBlayer == 1)
                numberOfDigis[5]++;
              if (DBlayer == 2)
                numberOfDigis[6]++;
              if (DBlayer == 3)
                numberOfDigis[7]++;
            }
          } else {
            if (row < 80) {
              numberOfDigis[0]++;
              nDigisA++;
              if (DBlayer == 1)
                numberOfDigis[2]++;
              if (DBlayer == 2)
                numberOfDigis[3]++;
              if (DBlayer == 3)
                numberOfDigis[4]++;
            } else {
              numberOfDigis[1]++;
              nDigisB++;
              if (DBlayer == 1)
                numberOfDigis[5]++;
              if (DBlayer == 2)
                numberOfDigis[6]++;
              if (DBlayer == 3)
                numberOfDigis[7]++;
            }
          }
        }
      } else if (isUpgrade) {
        DBlayer = PixelBarrelName(DetId(id_), pTT, isUpgrade).layerName();
        DBmodule = PixelBarrelName(DetId(id_), pTT, isUpgrade).moduleName();
        if (barrel) {
          if (row < 80) {
            numberOfDigis[0]++;
            nDigisA++;
            if (DBlayer == 1)
              numberOfDigis[2]++;
            if (DBlayer == 2)
              numberOfDigis[3]++;
            if (DBlayer == 3)
              numberOfDigis[4]++;
            if (DBlayer == 4)
              numberOfDigis[5]++;
          } else {
            numberOfDigis[1]++;
            nDigisB++;
            if (DBlayer == 1)
              numberOfDigis[6]++;
            if (DBlayer == 2)
              numberOfDigis[7]++;
            if (DBlayer == 3)
              numberOfDigis[8]++;
            if (DBlayer == 4)
              numberOfDigis[9]++;
          }
        }
      }

      if (modon) {
        if (!reducedSet) {
          if (twoD) {
            if (twoDimModOn)
              (mePixDigis_)->Fill((float)col, (float)row);
          } else {
            (mePixDigis_px_)->Fill((float)col);
            (mePixDigis_py_)->Fill((float)row);
          }
        }
        (meADC_)->Fill((float)adc);
      }
      if (ladon && barrel) {
        (meADCLad_)->Fill((float)adc);
        if (!reducedSet) {
          if (twoD)
            (mePixDigisLad_)->Fill((float)col, (float)row);
          else {
            (mePixDigisLad_px_)->Fill((float)col);
            (mePixDigisLad_py_)->Fill((float)row);
          }
        }
      }
      if ((layon || twoDimOnlyLayDisk) && barrel) {
        if (!twoDimOnlyLayDisk)
          (meADCLay_)->Fill((float)adc);
        if (!reducedSet) {
          if ((layon && twoD) || twoDimOnlyLayDisk) {
            //ROC histos...
            float rocx = (float)col / 52. + 8.0 * float(DBmodule - 1);
            float rocy = (float)row / 160. + float(DBladder);
            //Shift 1st ladder (half modules) up by 1 bin
            if (DBladder == 1)
              rocy = rocy + 0.5;
            mePixRocsLay_->Fill(rocx, rocy);

            if (isHalfModule && DBladder == 1) {
              (mePixDigisLay_)->Fill((float)col, (float)row + 80);
            } else
              (mePixDigisLay_)->Fill((float)col, (float)row);
          }
          if ((layon && !twoD) && !twoDimOnlyLayDisk) {
            (mePixDigisLay_px_)->Fill((float)col);
            if (isHalfModule && DBladder == 1) {
              (mePixDigisLay_py_)->Fill((float)row + 80);
            } else
              (mePixDigisLay_py_)->Fill((float)row);
          }
        }
      }
      if (phion && barrel) {
        (meADCPhi_)->Fill((float)adc);
        if (!reducedSet) {
          if (twoD) {
            if (isHalfModule && DBladder == 1) {
              (mePixDigisPhi_)->Fill((float)col, (float)row + 80);
            } else
              (mePixDigisPhi_)->Fill((float)col, (float)row);
          } else {
            (mePixDigisPhi_px_)->Fill((float)col);
            if (isHalfModule && DBladder == 1) {
              (mePixDigisPhi_py_)->Fill((float)row + 80);
            } else
              (mePixDigisPhi_py_)->Fill((float)row);
          }
        }
      }
      if (bladeon && endcap) {
        (meADCBlade_)->Fill((float)adc);
      }

      if ((diskon || twoDimOnlyLayDisk) && endcap) {
        if (!twoDimOnlyLayDisk)
          (meADCDisk_)->Fill((float)adc);
        if (twoDimOnlyLayDisk) {
          (mePixDigisDisk_)->Fill((float)col, (float)row);
          //ROC monitoring
          int DBpanel;
          int DBblade;
          DBpanel = PixelEndcapName(DetId(id_), pTT, isUpgrade).pannelName();
          DBblade = PixelEndcapName(DetId(id_), pTT, isUpgrade).bladeName();
          float offx = 0.;
          //This crazy offset takes into account the roc and module fpix configuration
          for (int i = DBpanel; i < DBmodule; ++i) {
            offx = offx + float(5 + DBpanel - i);
          }
          float rocx = (float)col / 52. + offx + 14.0 * float(DBpanel - 1);
          float rocy = (float)row / 160. + float(DBblade);
          mePixRocsDisk_->Fill(rocx, rocy);
        }
      }
      if (ringon && endcap) {
        (meADCRing_)->Fill((float)adc);
        if (!reducedSet) {
          if (twoD)
            (mePixDigisRing_)->Fill((float)col, (float)row);
          else {
            (mePixDigisRing_px_)->Fill((float)col);
            (mePixDigisRing_py_)->Fill((float)row);
          }
        }
      }
    }
    if (modon)
      (meNDigis_)->Fill((float)numberOfDigisMod);
    if (ladon && barrel)
      (meNDigisLad_)->Fill((float)numberOfDigisMod);
    if (layon && barrel && !twoDimOnlyLayDisk)
      (meNDigisLay_)->Fill((float)numberOfDigisMod);
    if (phion && barrel)
      (meNDigisPhi_)->Fill((float)numberOfDigisMod);
    if (bladeon && endcap)
      (meNDigisBlade_)->Fill((float)numberOfDigisMod);
    if (diskon && endcap && !twoDimOnlyLayDisk)
      (meNDigisDisk_)->Fill((float)numberOfDigisMod);
    if (ringon && endcap)
      (meNDigisRing_)->Fill((float)numberOfDigisMod);
    if (barrel) {
      if (combBarrel)
        combBarrel->Fill((float)numberOfDigisMod);
      if (chanBarrel) {
        if (numberOfDigis[0] > 0)
          chanBarrel->Fill((float)numberOfDigis[0]);
        if (numberOfDigis[1] > 0)
          chanBarrel->Fill((float)numberOfDigis[1]);
      }
      int j = 2;
      for (std::vector<MonitorElement*>::iterator i = chanBarrelL.begin(); i != chanBarrelL.end(); i++) {
        if (numberOfDigis[j] > 0)
          (*i)->Fill((float)numberOfDigis[j]);
        j++;
      }
    } else if (endcap) {
      if (combEndcap)
        combEndcap->Fill((float)numberOfDigisMod);
    }
  }

  //std::cout<<"numberOfDigis for this module: "<<numberOfDigis<<std::endl;
  return numberOfDigisMod;
}

// This was done in the Source file, but is moved to the Module for thread safety reasons. Using ME that is booked here.
void SiPixelDigiModule::resetRocMap() {
  if (mePixRocsDisk_)
    mePixRocsDisk_->Reset();
  if (mePixRocsLay_)
    mePixRocsLay_->Reset();
}

//Moved from source. Gets the zero and low eff ROCs from each module. Called in source for each module.
std::pair<int, int> SiPixelDigiModule::getZeroLoEffROCs() {
  int nZeroROC = 0;
  int nLoEffROC = 0;
  float SF = 1.0;
  if (mePixRocsDisk_ && meZeroOccRocsDisk_) {
    if (mePixRocsDisk_->getEntries() > 0)
      SF = float(mePixRocsDisk_->getNbinsX() * mePixRocsDisk_->getNbinsY() / mePixRocsDisk_->getEntries());
    for (int i = 1; i < mePixRocsDisk_->getNbinsX() + 1; ++i) {
      for (int j = 1; j < mePixRocsDisk_->getNbinsY() + 1; ++j) {
        float localX = float(i) - 0.5;
        float localY = float(j) / 2.0 + 0.75;
        if (mePixRocsDisk_->getBinContent(i, j) < 1) {
          nZeroROC++;
          meZeroOccRocsDisk_->Fill(localX, localY);
        }
        if (mePixRocsDisk_->getBinContent(i, j) * SF < 0.25) {
          nLoEffROC++;
        }
      }
    }
    return std::pair<int, int>(nZeroROC, nLoEffROC);
  }
  if (mePixRocsLay_ && meZeroOccRocsLay_) {
    if (mePixRocsLay_->getEntries() > 0)
      SF = float(mePixRocsLay_->getNbinsX() * mePixRocsLay_->getNbinsY() / mePixRocsLay_->getEntries());
    for (int i = 1; i < mePixRocsLay_->getNbinsX() + 1; ++i) {
      for (int j = 1; j < mePixRocsLay_->getNbinsY() + 1; ++j) {
        float localX = float(i) - 0.5;
        float localY = float(j) / 2.0 + 1.25;
        if (mePixRocsLay_->getBinContent(i, j) < 8) {
          nZeroROC++;
          meZeroOccRocsLay_->Fill(localX, localY);
        }  //in some regions of pixel there are modules with no HV but enabled ROCs that sometime give a fake hit, so the dead rocs have to be counted to have less than 8 hits in 10 LS
        if (mePixRocsLay_->getBinContent(i, j) * SF < 0.25) {
          nLoEffROC++;
        }
      }
    }
    return std::pair<int, int>(nZeroROC, nLoEffROC);
  }
  return std::pair<int, int>(0, 0);
}