Inheritance diagram for ElasticPlotDQMSource:

Classes
struct	DiagonalPlots
	plots related to one (anti)diagonal More...

struct	PotPlots
	plots related to one RP More...

Public Member Functions
	ElasticPlotDQMSource (const edm::ParameterSet &ps)

	~ElasticPlotDQMSource () 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, DiagonalPlots >	diagonalPlots

std::map< unsigned int, PotPlots >	potPlots

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

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

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

unsigned int	verbosity

Static Private Attributes
static constexpr double	ls_duration_inverse = 1. / 23.357

static constexpr unsigned int	ls_max = 2000

static constexpr unsigned int	ls_min = 0

Detailed Description

Definition at line 29 of file ElasticPlotDQMSource.cc.

Constructor & Destructor Documentation

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

Definition at line 186 of file ElasticPlotDQMSource.cc.

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

     : verbosity(ps.getUntrackedParameter<unsigned int>("verbosity", 0)) {
   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"));
 }

ElasticPlotDQMSource::~ElasticPlotDQMSource ( )

override

Definition at line 195 of file ElasticPlotDQMSource.cc.

195 {}

Member Function Documentation

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

overrideprotected

Definition at line 224 of file ElasticPlotDQMSource.cc.

References diagonalPlots, mps_fire::i, edm::HandleBase::isValid(), dqmiolumiharvest::j, ls_duration_inverse, edm::EventBase::luminosityBlock(), AlCaHLTBitMon_ParallelJobs::p, potPlots, createTree::pp, TotemRPUVPattern::projU, TotemRPUVPattern::projV, CTPPSDetId::rpId(), tokenLocalTrack, tokenRecHit, tokenUVPattern, HLT_FULL_cff::track, tracks, verbosity, TotemRPLocalTrack::x0(), and TotemRPLocalTrack::y0().

                                                                                          {
   // get event data
   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 &= hits.isValid();
   valid &= patterns.isValid();
   valid &= tracks.isValid();
 
   if (!valid) {
     if (verbosity) {
       LogProblem("ElasticPlotDQMSource") << "ERROR in ElasticPlotDQMSource::analyze > some of the required inputs are "
                                             "not valid. Skipping this event.\n"
                                          << "    hits.isValid = " << hits.isValid() << "\n"
                                          << "    patterns.isValid = " << patterns.isValid() << "\n"
                                          << "    tracks.isValid = " << tracks.isValid();
     }
 
     return;
   }
 
   //------------------------------
   // categorise RP data
   map<unsigned int, unsigned int> rp_planes_u_too_full, rp_planes_v_too_full;
   map<unsigned int, bool> rp_pat_suff;
   map<unsigned int, const TotemRPLocalTrack *> rp_track;
 
   for (const auto &ds : *hits) {
     TotemRPDetId detId(ds.detId());
     CTPPSDetId rpId = detId.rpId();
 
     if (ds.size() > 5) {
       if (detId.isStripsCoordinateUDirection())
         rp_planes_u_too_full[rpId]++;
       else
         rp_planes_v_too_full[rpId]++;
     }
   }
 
   for (auto &ds : *patterns) {
     CTPPSDetId rpId(ds.detId());
 
     // count U and V patterns
     unsigned int n_pat_u = 0, n_pat_v = 0;
     for (auto &p : ds) {
       if (!p.fittable())
         continue;
 
       if (p.projection() == TotemRPUVPattern::projU)
         n_pat_u++;
       else if (p.projection() == TotemRPUVPattern::projV)
         n_pat_v++;
     }
 
     rp_pat_suff[rpId] =
         (n_pat_u > 0 || rp_planes_u_too_full[rpId] >= 3) && (n_pat_v > 0 || rp_planes_v_too_full[rpId] >= 3);
   }
 
   for (auto &ds : *tracks) {
     CTPPSDetId rpId(ds.detId());
 
     const TotemRPLocalTrack *track = nullptr;
     for (auto &ft : ds) {
       if (ft.isValid()) {
         track = &ft;
         break;
       }
     }
 
     rp_track[rpId] = track;
   }
 
   //------------------------------
   // diagonal plots
 
   for (auto &dpp : diagonalPlots) {
     auto &dp = dpp.second;
 
     // determine diagonal conditions
     bool cond_4rp = true, cond_2rp = true;
     for (unsigned int i = 0; i < 4; i++) {
       if (rp_track[dp.rpIds[i]] == nullptr)
         cond_4rp = false;
 
       if ((i == 0 || i == 3) && rp_track[dp.rpIds[i]] == nullptr)
         cond_2rp = false;
     }
 
     if (cond_4rp)
       dp.h_rate_vs_time_dgn_4rp->Fill(event.luminosityBlock(), ls_duration_inverse);
 
     if (cond_2rp)
       dp.h_rate_vs_time_dgn_2rp->Fill(event.luminosityBlock(), ls_duration_inverse);
 
     for (unsigned int i = 0; i < 4; i++) {
       const TotemRPLocalTrack *tr_i = rp_track[dp.rpIds[i]];
 
       if (tr_i == nullptr)
         continue;
 
       if (cond_4rp)
         dp.v_h2_y_vs_x_dgn_4rp[i]->Fill(tr_i->x0(), tr_i->y0());
 
       if (cond_2rp)
         dp.v_h2_y_vs_x_dgn_2rp[i]->Fill(tr_i->x0(), tr_i->y0());
 
       for (unsigned int j = 0; j < 4; j++) {
         if (rp_track[dp.rpIds[j]] == nullptr)
           continue;
 
         dp.h2_track_corr_vert->Fill(i, j);
 
         dp.v_h_y[i][j]->Fill(tr_i->y0());
       }
     }
   }
 
   //------------------------------
   // pot plots
 
   for (const auto &p : rp_pat_suff) {
     const auto &rpId = p.first;
     auto pp_it = potPlots.find(rpId);
     if (pp_it == potPlots.end())
       continue;
     auto &pp = pp_it->second;
 
     const auto &pat_suff = rp_pat_suff[rpId];
     const auto &has_track = (rp_track[rpId] != nullptr);
 
     if (pat_suff)
       pp.h_rate_vs_time_suff->Fill(event.luminosityBlock(), ls_duration_inverse);
     if (has_track)
       pp.h_rate_vs_time_track->Fill(event.luminosityBlock(), ls_duration_inverse);
     if (pat_suff && !has_track)
       pp.h_rate_vs_time_unresolved->Fill(event.luminosityBlock(), ls_duration_inverse);
   }
 }

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

overrideprotected

Definition at line 199 of file ElasticPlotDQMSource.cc.

References dqm::implementation::NavigatorBase::cd(), diagonalPlots, potPlots, and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                                                          {
   ibooker.cd();
   ibooker.setCurrentFolder("CTPPS");
 
   // initialize (anti-)diagonal plots
   diagonalPlots[0] = DiagonalPlots(ibooker, 0);  // 45 bot - 56 bot
   diagonalPlots[1] = DiagonalPlots(ibooker, 1);  // 45 bot - 56 top
   diagonalPlots[2] = DiagonalPlots(ibooker, 2);  // 45 top - 56 bot
   diagonalPlots[3] = DiagonalPlots(ibooker, 3);  // 45 top - 56 top
 
   // loop over arms
   for (unsigned int arm = 0; arm < 2; arm++) {
     // 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);
       }
     }
   }
 }