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 double	ls_duration_inverse = 1./23.357

static unsigned int	ls_max = 2000

static unsigned int	ls_min = 0

Detailed Description

Definition at line 30 of file ElasticPlotDQMSource.cc.

Constructor & Destructor Documentation

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

Definition at line 188 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 198 of file ElasticPlotDQMSource.cc.

199 {

200 }

Member Function Documentation

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

overrideprotected

Definition at line 233 of file ElasticPlotDQMSource.cc.

References DEFINE_FWK_MODULE, diagonalPlots, CTPPSDetId::getRPId(), TotemRPLocalTrack::getX0(), TotemRPLocalTrack::getY0(), hfClusterShapes_cfi::hits, mps_fire::i, edm::HandleBase::isValid(), ls_duration_inverse, edm::EventBase::luminosityBlock(), AlCaHLTBitMon_ParallelJobs::p, potPlots, createTree::pp, TotemRPUVPattern::projU, TotemRPUVPattern::projV, tokenLocalTrack, tokenRecHit, tokenUVPattern, HiIsolationCommonParameters_cff::track, l1t::tracks, and verbosity.

 {
   // 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.getRPId();
 
     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.getFittable())
         continue;
 
       if (p.getProjection() == TotemRPUVPattern::projU)
         n_pat_u++;
       else if (p.getProjection() == 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->getX0(), tr_i->getY0());
 
       if (cond_2rp)
         dp.v_h2_y_vs_x_dgn_2rp[i]->Fill(tr_i->getX0(), tr_i->getY0());
 
       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->getY0());
       }
     }
   }
 
   //------------------------------
   // 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 204 of file ElasticPlotDQMSource.cc.

References DQMStore::IBooker::cd(), diagonalPlots, potPlots, and DQMStore::IBooker::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);
       }
     }
   }
 }