gainCalibHelper::gainCalibPI Namespace Reference

Enumerations
enum	type { t_gain = 0, t_pedestal = 1, t_correlation = 2 }

Functions
template<typename PayloadType >
static std::array< std::shared_ptr< TH1F >, 2 >	fillDiffAndRatio (const std::shared_ptr< PayloadType > &payload_A, const std::shared_ptr< PayloadType > &payload_B, const gainCalibPI::type &theType)
template<typename PayloadType >
static void	fillTheHisto (const std::shared_ptr< PayloadType > &payload, std::shared_ptr< TH1F > h1, gainCalibPI::type theType, const std::vector< uint32_t > &wantedIds={})
template<typename PayloadType >
static void	fillTheHistos (const std::shared_ptr< PayloadType > &payload, std::shared_ptr< TH1 > hBPix, std::shared_ptr< TH1 > hFPix, gainCalibPI::type theType)
template<typename PayloadType >
static void	fillThePerModuleMap (const std::shared_ptr< PayloadType > &payload, AvgMap &map, gainCalibPI::type theType)

Variables
static const std::array< std::string, 3 >	t_titles = {{"gain", "pedestal", "correlation"}}

Enumeration Type Documentation

type

enum gainCalibHelper::gainCalibPI::type

Enumerator
t_gain
t_pedestal
t_correlation

Definition at line 40 of file SiPixelGainCalibHelper.h.

{ t_gain = 0, t_pedestal = 1, t_correlation = 2 };

Function Documentation

fillDiffAndRatio()

template<typename PayloadType >

static std::array<std::shared_ptr<TH1F>, 2> gainCalibHelper::gainCalibPI::fillDiffAndRatio ( const std::shared_ptr< PayloadType > &  payload_A, const std::shared_ptr< PayloadType > &  payload_B, const gainCalibPI::type &  theType  )

static

Definition at line 46 of file SiPixelGainCalibHelper.h.

References cms::cuda::assert(), cuy::col, ztail::d, change_name::diff, SiStripPI::max, reco::castor::maxDiff(), hgcalPlots::ncols, FastTimerService_cff::range, particleFlowDisplacedVertex_cfi::ratio, jetUpdater_cfi::sort, t_gain, and t_pedestal.

Referenced by gainCalibHelper::SiPixelGainCalibDiffAndRatioBase< myType, nIOVs, ntags, PayloadType >::fill().

                                                                                                 {
      std::array<std::shared_ptr<TH1F>, 2> arr;

      std::vector<uint32_t> detids_A;
      payload_A->getDetIds(detids_A);
      std::vector<uint32_t> detids_B;
      payload_B->getDetIds(detids_B);

      std::vector<float> v_ratios;
      std::vector<float> v_diffs;

      if (detids_A != detids_B) {
        edm::LogError("fillDiffAndRatio") << "the list of DetIds for the two payloads are not equal"
                                          << " cannot make any comparison!" << std::endl;
      }

      assert(detids_A == detids_B);
      for (const auto& d : detids_A) {
        auto range = payload_A->getRange(d);
        int numberOfRowsToAverageOver = payload_A->getNumberOfRowsToAverageOver();
        int ncols = payload_A->getNCols(d);
        int nRocsInRow = (range.second - range.first) / ncols / numberOfRowsToAverageOver;
        unsigned int nRowsForHLT = 1;
        int nrows = std::max((payload_A->getNumberOfRowsToAverageOver() * nRocsInRow),
                             nRowsForHLT);  // dirty trick to make it work for the HLT payload

        auto rAndCol_A = payload_A->getRangeAndNCols(d);
        auto rAndCol_B = payload_B->getRangeAndNCols(d);
        bool isDeadCol, isNoisyCol;

        float ratio(-.1), diff(-1.);
        for (int col = 0; col < ncols; col++) {
          for (int row = 0; row < nrows; row++) {
            switch (theType) {
              case gainCalibPI::t_gain: {
                auto gainA = payload_A->getGain(col, row, rAndCol_A.first, rAndCol_A.second, isDeadCol, isNoisyCol);
                auto gainB = payload_B->getGain(col, row, rAndCol_B.first, rAndCol_B.second, isDeadCol, isNoisyCol);
                ratio = gainB != 0 ? (gainA / gainB) : -1.;  // if the ratio does not make sense the default is -1
                diff = gainA - gainB;
                break;
              }
              case gainCalibPI::t_pedestal: {
                auto pedA = payload_A->getPed(col, row, rAndCol_A.first, rAndCol_A.second, isDeadCol, isNoisyCol);
                auto pedB = payload_B->getPed(col, row, rAndCol_B.first, rAndCol_B.second, isDeadCol, isNoisyCol);
                ratio = pedB != 0 ? (pedA / pedB) : -1.;  // if the ratio does not make sense the default is -1
                diff = pedA - pedB;
                break;
              }
              default:
                edm::LogError("gainCalibPI::fillTheHisto") << "Unrecognized type " << theType << std::endl;
                break;
            }
            // fill the containers
            v_diffs.push_back(diff);
            v_ratios.push_back(ratio);
          }  // loop on rows
        }    // loop on cols
      }      // loop on detids

      std::sort(v_diffs.begin(), v_diffs.end());
      std::sort(v_ratios.begin(), v_ratios.end());

      double minDiff = v_diffs.front();
      double maxDiff = v_diffs.back();
      double minRatio = v_ratios.front();
      double maxRatio = v_ratios.back();

      arr[0] = std::make_shared<TH1F>("h_Ratio", "", 50, minRatio - 1., maxRatio + 1.);
      arr[1] = std::make_shared<TH1F>("h_Diff", "", 50, minDiff - 1., maxDiff + 1.);

      for (const auto& r : v_ratios) {
        arr[0]->Fill(r);
      }
      for (const auto& d : v_diffs) {
        arr[1]->Fill(d);
      }
      return arr;
    }

fillTheHisto()

template<typename PayloadType >

static void gainCalibHelper::gainCalibPI::fillTheHisto ( const std::shared_ptr< PayloadType > &  payload, std::shared_ptr< TH1F >  h1, gainCalibPI::type  theType, const std::vector< uint32_t > &  wantedIds = {}  )

static

Definition at line 130 of file SiPixelGainCalibHelper.h.

Referenced by gainCalibHelper::SiPixelGainCalibrationValues< myType, PayloadType >::fill(), gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >::fill(), gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::fill(), and gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::fill().

                                                                    {}) {
      std::vector<uint32_t> detids;
      if (wantedIds.empty()) {
        payload->getDetIds(detids);
      } else {
        detids.assign(wantedIds.begin(), wantedIds.end());
      }

      for (const auto& d : detids) {
        // skip the special case used to signal there are no attached dets
        if (d == 0xFFFFFFFF)
          continue;

        auto range = payload->getRange(d);
        int numberOfRowsToAverageOver = payload->getNumberOfRowsToAverageOver();
        int ncols = payload->getNCols(d);
        int nRocsInRow = (range.second - range.first) / ncols / numberOfRowsToAverageOver;
        unsigned int nRowsForHLT = 1;
        int nrows = std::max((payload->getNumberOfRowsToAverageOver() * nRocsInRow),
                             nRowsForHLT);  // dirty trick to make it work for the HLT payload

        auto rangeAndCol = payload->getRangeAndNCols(d);
        bool isDeadColumn;
        bool isNoisyColumn;

        COUT << "NCOLS: " << payload->getNCols(d) << " " << rangeAndCol.second << " NROWS:" << nrows
             << ", RANGES: " << rangeAndCol.first.second - rangeAndCol.first.first
             << ", Ratio: " << float(rangeAndCol.first.second - rangeAndCol.first.first) / rangeAndCol.second
             << std::endl;

        float quid(-99999.);

        for (int col = 0; col < ncols; col++) {
          for (int row = 0; row < nrows; row++) {
            switch (theType) {
              case gainCalibPI::t_gain:
                quid = payload->getGain(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
                break;
              case gainCalibPI::t_pedestal:
                quid = payload->getPed(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
                break;
              default:
                edm::LogError("gainCalibPI::fillTheHisto") << "Unrecognized type " << theType << std::endl;
                break;
            }
            h1->Fill(quid);
          }  // loop on rows
        }    // loop on cols
      }      // loop on detids
    }        // fillTheHisto

fillTheHistos()

template<typename PayloadType >

static void gainCalibHelper::gainCalibPI::fillTheHistos ( const std::shared_ptr< PayloadType > &  payload, std::shared_ptr< TH1 >  hBPix, std::shared_ptr< TH1 >  hFPix, gainCalibPI::type  theType  )

static

Definition at line 233 of file SiPixelGainCalibHelper.h.

References HLT_2024v10_cff::Class, cuy::col, ztail::d, PedestalClient_cfi::gain, SiStripPI::max, hgcalPlots::ncols, jetsAK4_Puppi_cff::payload, QIE10Task_cfi::ped, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, FastTimerService_cff::range, DetId::subdetId(), t_correlation, and t_gain.

Referenced by gainCalibHelper::SiPixelGainCalibrationCorrelations< PayloadType >::fill(), and gainCalibHelper::SiPixelGainCalibrationValuesByPart< myType, PayloadType >::fill().

                                                       {
      std::vector<uint32_t> detids;
      payload->getDetIds(detids);

      bool isCorrelation_ = hBPix.get()->InheritsFrom(TH2::Class()) && (theType == gainCalibPI::t_correlation);

      for (const auto& d : detids) {
        int subid = DetId(d).subdetId();
        auto range = payload->getRange(d);
        int numberOfRowsToAverageOver = payload->getNumberOfRowsToAverageOver();
        int ncols = payload->getNCols(d);
        int nRocsInRow = (range.second - range.first) / ncols / numberOfRowsToAverageOver;
        unsigned int nRowsForHLT = 1;
        int nrows = std::max((payload->getNumberOfRowsToAverageOver() * nRocsInRow),
                             nRowsForHLT);  // dirty trick to make it work for the HLT payload

        auto rangeAndCol = payload->getRangeAndNCols(d);
        bool isDeadColumn;
        bool isNoisyColumn;

        for (int col = 0; col < ncols; col++) {
          for (int row = 0; row < nrows; row++) {
            float gain = payload->getGain(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
            float ped = payload->getPed(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);

            switch (subid) {
              case PixelSubdetector::PixelBarrel: {
                if (isCorrelation_) {
                  hBPix->Fill(gain, ped);
                } else {
                  hBPix->Fill((theType == gainCalibPI::t_gain ? gain : ped));
                }
                break;
              }
              case PixelSubdetector::PixelEndcap: {
                if (isCorrelation_) {
                  hFPix->Fill(gain, ped);
                } else {
                  hFPix->Fill((theType == gainCalibPI::t_gain ? gain : ped));
                }
                break;
              }
              default:
                edm::LogError("gainCalibPI::fillTheHistos") << d << " is not a Pixel DetId" << std::endl;
                break;
            }  // switch on subid
          }    // row loop
        }      // column loop
      }        // detid loop
    }          // filltheHistos

fillThePerModuleMap()

template<typename PayloadType >

static void gainCalibHelper::gainCalibPI::fillThePerModuleMap ( const std::shared_ptr< PayloadType > &  payload, AvgMap &  map, gainCalibPI::type  theType  )

static

Definition at line 187 of file SiPixelGainCalibHelper.h.

References cuy::col, ztail::d, genParticles_cff::map, SiStripPI::max, hgcalPlots::ncols, jetsAK4_Puppi_cff::payload, FastTimerService_cff::range, t_gain, and t_pedestal.

Referenced by gainCalibHelper::SiPixelGainCalibrationMap< myType, PayloadType, myDetType >::fill(), and gainCalibHelper::SiPixelGainCalibrationByRegionComparisonBase< myType, PayloadType, nIOVs, ntags >::fill().

                                                             {
      std::vector<uint32_t> detids;
      payload->getDetIds(detids);

      for (const auto& d : detids) {
        auto range = payload->getRange(d);
        int numberOfRowsToAverageOver = payload->getNumberOfRowsToAverageOver();
        int ncols = payload->getNCols(d);
        int nRocsInRow = (range.second - range.first) / ncols / numberOfRowsToAverageOver;
        unsigned int nRowsForHLT = 1;
        int nrows = std::max((payload->getNumberOfRowsToAverageOver() * nRocsInRow),
                             nRowsForHLT);  // dirty trick to make it work for the HLT payload

        auto rangeAndCol = payload->getRangeAndNCols(d);
        bool isDeadColumn;
        bool isNoisyColumn;

        float sumOfX(0.);
        int nPixels(0);
        for (int col = 0; col < ncols; col++) {
          for (int row = 0; row < nrows; row++) {
            nPixels++;
            switch (theType) {
              case gainCalibPI::t_gain:
                sumOfX +=
                    payload->getGain(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
                break;
              case gainCalibPI::t_pedestal:
                sumOfX += payload->getPed(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
                break;
              default:
                edm::LogError("gainCalibPI::fillThePerModuleMap") << "Unrecognized type " << theType << std::endl;
                break;
            }  // switch on the type
          }    // rows
        }      // columns
        // fill the return value map
        map[d] = sumOfX / nPixels;
      }  // loop on the detId
    }    // fillThePerModuleMap

Variable Documentation

t_titles

const std::array<std::string, 3> gainCalibHelper::gainCalibPI::t_titles = {{"gain", "pedestal", "correlation"}}

static

Definition at line 41 of file SiPixelGainCalibHelper.h.

Referenced by gainCalibHelper::SiPixelGainCalibrationMap< myType, PayloadType, myDetType >::fill().