TotemRPDQMSource Class Reference

Inheritance diagram for TotemRPDQMSource:

Classes
struct	PlanePlots
	plots related to one RP plane More...
struct	PotPlots
	plots related to one RP More...

Public Member Functions
	TotemRPDQMSource (const edm::ParameterSet &ps)
	~TotemRPDQMSource () override

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &eSetup) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

Private Attributes
std::map< unsigned int, PlanePlots >	planePlots
std::map< unsigned int, PotPlots >	potPlots
edm::EDGetTokenT< edm::DetSetVector< TotemRPCluster > >	tokenCluster
edm::EDGetTokenT< edm::DetSetVector< TotemRPDigi > >	tokenDigi
edm::EDGetTokenT< edm::DetSetVector< TotemRPLocalTrack > >	tokenLocalTrack
edm::EDGetTokenT< edm::DetSetVector< TotemRPRecHit > >	tokenRecHit
edm::EDGetTokenT< edm::DetSetVector< TotemVFATStatus > >	tokenStatus
edm::EDGetTokenT< edm::DetSetVector< TotemRPUVPattern > >	tokenUVPattern
unsigned int	verbosity

Detailed Description

Definition at line 37 of file TotemRPDQMSource.cc.

Constructor & Destructor Documentation

TotemRPDQMSource()

TotemRPDQMSource::TotemRPDQMSource

(

const edm::ParameterSet &

ps

)

Definition at line 178 of file TotemRPDQMSource.cc.

    : verbosity(ps.getUntrackedParameter<unsigned int>("verbosity", 0)) {
  tokenStatus = consumes<DetSetVector<TotemVFATStatus>>(ps.getParameter<edm::InputTag>("tagStatus"));
 
  tokenDigi = consumes<DetSetVector<TotemRPDigi>>(ps.getParameter<edm::InputTag>("tagDigi"));
  tokenCluster = consumes<edm::DetSetVector<TotemRPCluster>>(ps.getParameter<edm::InputTag>("tagCluster"));
  tokenRecHit = consumes<edm::DetSetVector<TotemRPRecHit>>(ps.getParameter<edm::InputTag>("tagRecHit"));
  tokenUVPattern = consumes<DetSetVector<TotemRPUVPattern>>(ps.getParameter<edm::InputTag>("tagUVPattern"));
  tokenLocalTrack = consumes<DetSetVector<TotemRPLocalTrack>>(ps.getParameter<edm::InputTag>("tagLocalTrack"));
}

References edm::ParameterSet::getParameter(), tokenCluster, tokenDigi, tokenLocalTrack, tokenRecHit, tokenStatus, and tokenUVPattern.

~TotemRPDQMSource()

TotemRPDQMSource::~TotemRPDQMSource ( )

override

Definition at line 191 of file TotemRPDQMSource.cc.

{}

Member Function Documentation

analyze()

void TotemRPDQMSource::analyze ( edm::Event const &  e, edm::EventSetup const &  eSetup  )

overrideprotected

Definition at line 220 of file TotemRPDQMSource.cc.

                                                                                     {
  // get event setup data
  ESHandle<CTPPSGeometry> geometry;
  eventSetup.get<VeryForwardRealGeometryRecord>().get(geometry);
 
  // get event data
  Handle<DetSetVector<TotemVFATStatus>> status;
  event.getByToken(tokenStatus, status);
 
  Handle<DetSetVector<TotemRPDigi>> digi;
  event.getByToken(tokenDigi, digi);
 
  Handle<DetSetVector<TotemRPCluster>> digCluster;
  event.getByToken(tokenCluster, digCluster);
 
  Handle<DetSetVector<TotemRPRecHit>> hits;
  event.getByToken(tokenRecHit, hits);
 
  Handle<DetSetVector<TotemRPUVPattern>> patterns;
  event.getByToken(tokenUVPattern, patterns);
 
  Handle<DetSetVector<TotemRPLocalTrack>> tracks;
  event.getByToken(tokenLocalTrack, tracks);
 
  // check validity
  bool valid = true;
  valid &= status.isValid();
  valid &= digi.isValid();
  valid &= digCluster.isValid();
  valid &= hits.isValid();
  valid &= patterns.isValid();
  valid &= tracks.isValid();
 
  if (!valid) {
    if (verbosity) {
      LogProblem("TotemRPDQMSource")
          << "ERROR in TotemDQMModuleRP::analyze > some of the required inputs are not valid. Skipping this event.\n"
          << "    status.isValid = " << status.isValid() << "\n"
          << "    digi.isValid = " << digi.isValid() << "\n"
          << "    digCluster.isValid = " << digCluster.isValid() << "\n"
          << "    hits.isValid = " << hits.isValid() << "\n"
          << "    patterns.isValid = " << patterns.isValid() << "\n"
          << "    tracks.isValid = " << tracks.isValid();
    }
 
    return;
  }
 
  //------------------------------
  // Status Plots
 
  for (auto &ds : *status) {
    TotemRPDetId detId(ds.detId());
    unsigned int plNum = detId.plane();
    CTPPSDetId rpId = detId.rpId();
 
    auto it = potPlots.find(rpId);
    if (it == potPlots.end())
      continue;
    auto &plots = it->second;
 
    for (auto &s : ds) {
      if (s.isMissing()) {
        plots.vfat_problem->Fill(plNum, s.chipPosition());
        plots.vfat_missing->Fill(plNum, s.chipPosition());
      }
 
      if (s.isECProgressError() || s.isBCProgressError()) {
        plots.vfat_problem->Fill(plNum, s.chipPosition());
        plots.vfat_ec_bc_error->Fill(plNum, s.chipPosition());
      }
 
      if (s.isIDMismatch() || s.isFootprintError() || s.isCRCError()) {
        plots.vfat_problem->Fill(plNum, s.chipPosition());
        plots.vfat_corruption->Fill(plNum, s.chipPosition());
      }
    }
  }
 
  //------------------------------
  // Plane Plots
 
  // digi profile cumulative
  for (DetSetVector<TotemRPDigi>::const_iterator it = digi->begin(); it != digi->end(); ++it) {
    TotemRPDetId detId(it->detId());
 
    auto plIt = planePlots.find(detId);
    if (plIt == planePlots.end())
      continue;
    auto &plots = plIt->second;
 
    for (DetSet<TotemRPDigi>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
      plots.digi_profile_cumulative->Fill(dit->stripNumber());
  }
 
  // cluster plots
  for (DetSetVector<TotemRPCluster>::const_iterator it = digCluster->begin(); it != digCluster->end(); it++) {
    TotemRPDetId detId(it->detId());
 
    auto plIt = planePlots.find(detId);
    if (plIt == planePlots.end())
      continue;
    auto &plots = plIt->second;
 
    // hit multiplicity
    plots.hit_multiplicity->Fill(it->size());
 
    for (DetSet<TotemRPCluster>::const_iterator dit = it->begin(); dit != it->end(); ++dit) {
      // profile cumulative
      plots.cluster_profile_cumulative->Fill(dit->centerStripPosition());
 
      // cluster size
      plots.cluster_size->Fill(dit->numberOfStrips());
    }
  }
 
  // plane efficiency plots
  for (auto &ds : *tracks) {
    CTPPSDetId rpId(ds.detId());
 
    for (auto &ft : ds) {
      if (!ft.isValid())
        continue;
 
      double rp_z = geometry->rpTranslation(rpId).z();
 
      for (unsigned int plNum = 0; plNum < 10; ++plNum) {
        TotemRPDetId plId = rpId;
        plId.setPlane(plNum);
 
        auto plIt = planePlots.find(plId);
        if (plIt == planePlots.end())
          continue;
        auto &plots = plIt->second;
 
        double ft_z = ft.z0();
        double ft_x = ft.x0() + ft.tx() * (ft_z - rp_z);
        double ft_y = ft.y0() + ft.ty() * (ft_z - rp_z);
 
        double ft_v = geometry->globalToLocal(plId, CTPPSGeometry::Vector(ft_x, ft_y, ft_z)).y();
 
        bool hasMatchingHit = false;
        const auto &hit_ds_it = hits->find(plId);
        if (hit_ds_it != hits->end()) {
          for (const auto &h : *hit_ds_it) {
            bool match = (fabs(ft_v - h.position()) < 2. * 0.066);
            if (match) {
              hasMatchingHit = true;
              break;
            }
          }
        }
 
        plots.efficiency_den->Fill(ft_v);
        if (hasMatchingHit)
          plots.efficiency_num->Fill(ft_v);
      }
    }
  }
 
  //------------------------------
  // Roman Pots Plots
 
  // determine active planes (from RecHits and VFATStatus)
  map<unsigned int, set<unsigned int>> planes;
  map<unsigned int, set<unsigned int>> planes_u;
  map<unsigned int, set<unsigned int>> planes_v;
  for (const auto &ds : *hits) {
    if (ds.empty())
      continue;
 
    TotemRPDetId detId(ds.detId());
    unsigned int planeNum = detId.plane();
    CTPPSDetId rpId = detId.rpId();
 
    planes[rpId].insert(planeNum);
    if (detId.isStripsCoordinateUDirection())
      planes_u[rpId].insert(planeNum);
    else
      planes_v[rpId].insert(planeNum);
  }
 
  for (const auto &ds : *status) {
    bool activity = false;
    for (const auto &s : ds) {
      if (s.isNumberOfClustersSpecified() && s.numberOfClusters() > 0) {
        activity = true;
        break;
      }
    }
 
    if (!activity)
      continue;
 
    TotemRPDetId detId(ds.detId());
    unsigned int planeNum = detId.plane();
    CTPPSDetId rpId = detId.rpId();
 
    planes[rpId].insert(planeNum);
    if (detId.isStripsCoordinateUDirection())
      planes_u[rpId].insert(planeNum);
    else
      planes_v[rpId].insert(planeNum);
  }
 
  // plane activity histogram
  for (std::map<unsigned int, PotPlots>::iterator it = potPlots.begin(); it != potPlots.end(); it++) {
    it->second.activity->Fill(planes[it->first].size());
    it->second.activity_u->Fill(planes_u[it->first].size());
    it->second.activity_v->Fill(planes_v[it->first].size());
 
    if (planes[it->first].size() >= 6) {
      it->second.activity_per_bx->Fill(event.bunchCrossing());
      it->second.activity_per_bx_short->Fill(event.bunchCrossing());
    }
  }
 
  for (DetSetVector<TotemRPCluster>::const_iterator it = digCluster->begin(); it != digCluster->end(); it++) {
    TotemRPDetId detId(it->detId());
    unsigned int planeNum = detId.plane();
    CTPPSDetId rpId = detId.rpId();
 
    auto plIt = potPlots.find(rpId);
    if (plIt == potPlots.end())
      continue;
    auto &plots = plIt->second;
 
    for (DetSet<TotemRPCluster>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
      plots.hit_plane_hist->Fill(planeNum, dit->centerStripPosition());
  }
 
  // recognized pattern histograms
  for (auto &ds : *patterns) {
    CTPPSDetId rpId(ds.detId());
 
    auto plIt = potPlots.find(rpId);
    if (plIt == potPlots.end())
      continue;
    auto &plots = plIt->second;
 
    // count U and V patterns
    unsigned int u = 0, v = 0;
    for (auto &p : ds) {
      if (!p.fittable())
        continue;
 
      if (p.projection() == TotemRPUVPattern::projU)
        u++;
 
      if (p.projection() == TotemRPUVPattern::projV)
        v++;
    }
 
    plots.patterns_u->Fill(u);
    plots.patterns_v->Fill(v);
  }
 
  // event-category histogram
  for (auto &it : potPlots) {
    TotemRPDetId rpId(it.first);
    auto &pp = it.second;
 
    // process hit data for this plot
    unsigned int pl_u = planes_u[rpId].size();
    unsigned int pl_v = planes_v[rpId].size();
 
    // process pattern data for this pot
    const auto &rp_pat_it = patterns->find(rpId);
 
    unsigned int pat_u = 0, pat_v = 0;
    if (rp_pat_it != patterns->end()) {
      for (auto &p : *rp_pat_it) {
        if (!p.fittable())
          continue;
 
        if (p.projection() == TotemRPUVPattern::projU)
          pat_u++;
 
        if (p.projection() == TotemRPUVPattern::projV)
          pat_v++;
      }
    }
 
    // determine category
    signed int category = -1;
 
    if (pl_u == 0 && pl_v == 0)
      category = 0;  // empty
 
    if (category == -1 && pat_u + pat_v <= 1) {
      if (pl_u + pl_v < 6)
        category = 1;  // insuff
      else
        category = 4;  // shower
    }
 
    if (pat_u == 1 && pat_v == 1)
      category = 2;  // 1-track
 
    if (category == -1)
      category = 3;  // multi-track
 
    pp.event_category->Fill(category);
  }
 
  // RP track-fit plots
  set<unsigned int> rps_with_tracks;
 
  for (auto &ds : *tracks) {
    CTPPSDetId rpId(ds.detId());
 
    rps_with_tracks.insert(rpId);
 
    auto plIt = potPlots.find(rpId);
    if (plIt == potPlots.end())
      continue;
    auto &plots = plIt->second;
 
    for (auto &ft : ds) {
      if (!ft.isValid())
        continue;
 
      // number of planes contributing to (valid) fits
      unsigned int n_pl_in_fit_u = 0, n_pl_in_fit_v = 0;
      for (auto &hds : ft.hits()) {
        TotemRPDetId plId(hds.detId());
        bool uProj = plId.isStripsCoordinateUDirection();
 
        for (auto &h : hds) {
          h.position();  // just to keep compiler silent
          if (uProj)
            n_pl_in_fit_u++;
          else
            n_pl_in_fit_v++;
        }
      }
 
      plots.h_planes_fit_u->Fill(n_pl_in_fit_u);
      plots.h_planes_fit_v->Fill(n_pl_in_fit_v);
 
      // mean position of U and V planes
      TotemRPDetId plId_V(rpId);
      plId_V.setPlane(0);
      TotemRPDetId plId_U(rpId);
      plId_U.setPlane(1);
 
      double rp_x = (geometry->sensor(plId_V)->translation().x() + geometry->sensor(plId_U)->translation().x()) / 2.;
      double rp_y = (geometry->sensor(plId_V)->translation().y() + geometry->sensor(plId_U)->translation().y()) / 2.;
 
      // mean read-out direction of U and V planes
      const auto &rod_U = geometry->localToGlobalDirection(plId_U, CTPPSGeometry::Vector(0., 1., 0.));
      const auto &rod_V = geometry->localToGlobalDirection(plId_V, CTPPSGeometry::Vector(0., 1., 0.));
 
      double x = ft.x0() - rp_x;
      double y = ft.y0() - rp_y;
 
      plots.trackHitsCumulativeHist->Fill(x, y);
 
      double U = x * rod_U.x() + y * rod_U.y();
      double V = x * rod_V.x() + y * rod_V.y();
 
      plots.track_u_profile->Fill(U);
      plots.track_v_profile->Fill(V);
    }
  }
 
  // restore trigger-sector map from digis
  map<unsigned int, map<unsigned int, map<unsigned int, unsigned int>>>
      triggerSectorMap;  // [rpId, U/V flag, sector] --> number of planes
  for (const auto &dp : *digi) {
    TotemRPDetId plId(dp.detId());
    CTPPSDetId rpId = plId.rpId();
    unsigned int uvFlag = (plId.isStripsCoordinateUDirection()) ? 0 : 1;
 
    set<unsigned int> sectors;
    for (const auto &d : dp) {
      unsigned int sector = d.stripNumber() / 32;
      sectors.insert(sector);
    }
 
    for (const auto &sector : sectors)
      triggerSectorMap[rpId][uvFlag][sector]++;
  }
 
  for (auto &rpp : triggerSectorMap) {
    const unsigned int rpId = rpp.first;
 
    // trigger sector is counted as active if at least 3 planes report activity
 
    set<unsigned int> triggerSectorsU;
    for (const auto sp : rpp.second[0]) {
      if (sp.second >= 3)
        triggerSectorsU.insert(sp.first);
    }
 
    set<unsigned int> triggerSectorsV;
    for (const auto sp : rpp.second[1]) {
      if (sp.second >= 3)
        triggerSectorsV.insert(sp.first);
    }
 
    auto plIt = potPlots.find(rpId);
    if (plIt == potPlots.end())
      continue;
    auto &plots = plIt->second;
 
    const bool high_mult = (triggerSectorsU.size() > 2 && triggerSectorsV.size() > 2);
 
    const bool has_track = (rps_with_tracks.find(rpId) != rps_with_tracks.end());
 
    for (const auto &secU : triggerSectorsU) {
      for (const auto &secV : triggerSectorsV) {
        plots.triggerSectorUVCorrelation_all->Fill(secV, secU);
 
        if (!high_mult)
          plots.triggerSectorUVCorrelation_mult2->Fill(secV, secU);
 
        if (has_track)
          plots.triggerSectorUVCorrelation_track->Fill(secV, secU);
      }
    }
  }
}

References taus_updatedMVAIds_cff::category, ztail::d, Calorimetry_cff::dp, options_cfi::eventSetup, geometry, get, hfClusterShapes_cfi::hits, edm::eventsetup::heterocontainer::insert(), TotemRPDetId::isStripsCoordinateUDirection(), edm::HandleBase::isValid(), match(), AlCaHLTBitMon_ParallelJobs::p, TotemRPDetId::plane(), planePlots, HLTObjectsMonitor_cfi::plots, potPlots, createTree::pp, TotemRPUVPattern::projU, TotemRPUVPattern::projV, year_2016_postTS2_cff::rpId, alignCSCRings::s, volumeBasedMagneticField_160812_cfi::sectors, TotemRPDetId::setPlane(), mps_update::status, tokenCluster, tokenDigi, tokenLocalTrack, tokenRecHit, tokenStatus, tokenUVPattern, PDWG_EXOHSCP_cff::tracks, mitigatedMETSequence_cff::U, cms::cuda::V, findQualityFiles::v, validateGeometry_cfg::valid, verbosity, x, and y.

bookHistograms()

void TotemRPDQMSource::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  , edm::EventSetup const &    )

overrideprotected

Definition at line 195 of file TotemRPDQMSource.cc.

                                                                                                     {
  ibooker.cd();
  ibooker.setCurrentFolder("CTPPS");
 
  // loop over arms
  for (unsigned int arm : {0, 1}) {
    // loop over RPs
    for (unsigned int st_rp : {2, 3, 4, 5, 24, 25}) {
      const unsigned int st = st_rp / 10;
      const unsigned int rp = st_rp % 10;
 
      TotemRPDetId rpId(arm, st, rp);
      potPlots[rpId] = PotPlots(ibooker, rpId);
 
      // loop over planes
      for (unsigned int pl = 0; pl < 10; ++pl) {
        TotemRPDetId plId(arm, st, rp, pl);
        planePlots[plId] = PlanePlots(ibooker, plId);
      }
    }
  }
}

References planePlots, potPlots, and year_2016_postTS2_cff::rpId.

Member Data Documentation

planePlots

std::map<unsigned int, PlanePlots> TotemRPDQMSource::planePlots

private

Definition at line 96 of file TotemRPDQMSource.cc.

Referenced by analyze(), and bookHistograms().

potPlots

std::map<unsigned int, PotPlots> TotemRPDQMSource::potPlots

private

Definition at line 82 of file TotemRPDQMSource.cc.

Referenced by analyze(), and bookHistograms().

tokenCluster

edm::EDGetTokenT<edm::DetSetVector<TotemRPCluster> > TotemRPDQMSource::tokenCluster

private

Definition at line 57 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

tokenDigi

edm::EDGetTokenT<edm::DetSetVector<TotemRPDigi> > TotemRPDQMSource::tokenDigi

private

Definition at line 56 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

tokenLocalTrack

edm::EDGetTokenT<edm::DetSetVector<TotemRPLocalTrack> > TotemRPDQMSource::tokenLocalTrack

private

Definition at line 60 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

tokenRecHit

edm::EDGetTokenT<edm::DetSetVector<TotemRPRecHit> > TotemRPDQMSource::tokenRecHit

private

Definition at line 58 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

tokenStatus

edm::EDGetTokenT<edm::DetSetVector<TotemVFATStatus> > TotemRPDQMSource::tokenStatus

private

Definition at line 55 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

tokenUVPattern

edm::EDGetTokenT<edm::DetSetVector<TotemRPUVPattern> > TotemRPDQMSource::tokenUVPattern

private

Definition at line 59 of file TotemRPDQMSource.cc.

Referenced by analyze(), and TotemRPDQMSource().

verbosity

unsigned int TotemRPDQMSource::verbosity

private

Definition at line 53 of file TotemRPDQMSource.cc.

Referenced by analyze().