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 38 of file TotemRPDQMSource.cc.

Constructor & Destructor Documentation

TotemRPDQMSource::TotemRPDQMSource ( const edm::ParameterSet & ps )

Definition at line 173 of file TotemRPDQMSource.cc.

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

                                                             :
   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"));
 }

TotemRPDQMSource::~TotemRPDQMSource ( )

override

Definition at line 187 of file TotemRPDQMSource.cc.

188 {

189 }

Member Function Documentation

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

overrideprotected

Definition at line 223 of file TotemRPDQMSource.cc.

References edm::DetSet< T >::begin(), edm::EventBase::bunchCrossing(), python.rootplot.argparse::category, edmIntegrityCheck::d, DEFINE_FWK_MODULE, reco::dp, geometry, edm::EventSetup::get(), CTPPSDetId::getRPId(), CTPPSGeometry::getRPTranslation(), CTPPSGeometry::getSensor(), CTPPSGeometry::globalToLocal(), hfClusterShapes_cfi::hits, edm::eventsetup::heterocontainer::insert(), TotemRPDetId::isStripsCoordinateUDirection(), edm::HandleBase::isValid(), CTPPSGeometry::localToGlobalDirection(), match(), AlCaHLTBitMon_ParallelJobs::p, TotemRPDetId::plane(), planePlots, nanoDQM_cfi::plots, potPlots, createTree::pp, TotemRPUVPattern::projU, TotemRPUVPattern::projV, alignCSCRings::s, TotemRPDetId::setPlane(), mps_update::status, tokenCluster, tokenDigi, tokenLocalTrack, tokenRecHit, tokenStatus, tokenUVPattern, l1t::tracks, DetGeomDesc::translation(), mitigatedMETSequence_cff::U, findQualityFiles::v, verbosity, x, and y.

 {
   // 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.getRPId();
 
     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.getChipPosition());
         plots.vfat_missing->Fill(plNum, s.getChipPosition());
       }
 
       if (s.isECProgressError() || s.isBCProgressError())
       {
         plots.vfat_problem->Fill(plNum, s.getChipPosition());
         plots.vfat_ec_bc_error->Fill(plNum, s.getChipPosition());
       }
 
       if (s.isIDMismatch() || s.isFootprintError() || s.isCRCError())
       {
         plots.vfat_problem->Fill(plNum, s.getChipPosition());
         plots.vfat_corruption->Fill(plNum, s.getChipPosition());
       }
     }
   }
 
   //------------------------------
   // 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->getStripNumber());
   }
 
   // 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->getCenterStripPosition());
 
       // cluster size
       plots.cluster_size->Fill(dit->getNumberOfStrips());
     }
   }
 
   // plane efficiency plots
   for (auto &ds : *tracks)
   {
     CTPPSDetId rpId(ds.detId());
 
     for (auto &ft : ds)
     {
       if (!ft.isValid())
         continue;
 
       double rp_z = geometry->getRPTranslation(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.getZ0();
         double ft_x = ft.getX0() + ft.getTx() * (ft_z - rp_z);
         double ft_y = ft.getY0() + ft.getTy() * (ft_z - rp_z);
 
         double ft_v = geometry->globalToLocal(plId, CLHEP::Hep3Vector(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.getPosition()) < 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.getRPId();
 
     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.getNumberOfClusters() > 0)
       {
         activity = true;
         break;
       }
     }
 
     if (!activity)
       continue;
 
     TotemRPDetId detId(ds.detId());
     unsigned int planeNum = detId.plane();
     CTPPSDetId rpId = detId.getRPId();
 
     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.getRPId();
 
     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->getCenterStripPosition());
   }
 
   // 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.getFittable())
         continue;
 
       if (p.getProjection() == TotemRPUVPattern::projU)
         u++;
 
       if (p.getProjection() == 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.getFittable())
           continue;
 
         if (p.getProjection() == TotemRPUVPattern::projU)
           pat_u++;
 
         if (p.getProjection() == 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.getHits())
       {
         TotemRPDetId plId(hds.detId());
         bool uProj = plId.isStripsCoordinateUDirection();
 
         for (auto &h : hds)
         {
           h.getPosition();  // 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->getSensor(plId_V)->translation().x() +
                       geometry->getSensor(plId_U)->translation().x() ) / 2.;
       double rp_y = ( geometry->getSensor(plId_V)->translation().y() +
                       geometry->getSensor(plId_U)->translation().y() ) / 2.;
 
       // mean read-out direction of U and V planes
       CLHEP::Hep3Vector rod_U = geometry->localToGlobalDirection(plId_U, CLHEP::Hep3Vector(0., 1., 0.));
       CLHEP::Hep3Vector rod_V = geometry->localToGlobalDirection(plId_V, CLHEP::Hep3Vector(0., 1., 0.));
 
       double x = ft.getX0() - rp_x;
       double y = ft.getY0() - 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.getRPId();
     unsigned int uvFlag = (plId.isStripsCoordinateUDirection()) ? 0 : 1;
 
     set<unsigned int> sectors;
     for (const auto &d : dp)
     {
       unsigned int sector = d.getStripNumber() / 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);
       }
     }
   }
 }

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

overrideprotected

Definition at line 193 of file TotemRPDQMSource.cc.

References DQMStore::IBooker::cd(), planePlots, potPlots, and DQMStore::IBooker::setCurrentFolder().

 {
   ibooker.cd();
   ibooker.setCurrentFolder("CTPPS");
 
   // loop over arms
   for (unsigned int arm : {0, 1})
   {
     // loop over stations
     for (unsigned int st : {0, 2})
     {
       // loop over RPs
       for (unsigned int rp : {4, 5})
       {
         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);
         }
       }
     }
   }
 }