Inheritance diagram for TotemRPDQMSource:

Classes
struct	ArmPlots
	plots related to one arm More...

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

struct	GlobalPlots
	plots related to the whole system More...

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

struct	PotPlots
	plots related to one RP More...

struct	StationPlots
	plots related to one station More...

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

virtual	~TotemRPDQMSource ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

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

void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

void	endRun (edm::Run const &run, edm::EventSetup const &eSetup) override

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Attributes
std::map< unsigned int, ArmPlots >	armPlots

std::map< unsigned int, DiagonalPlots >	diagonalPlots

GlobalPlots	globalPlots

std::map< unsigned int, PlanePlots >	planePlots

std::map< unsigned int, PotPlots >	potPlots

std::map< unsigned int, StationPlots >	stationPlots

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

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 39 of file TotemRPDQMSource.cc.

Constructor & Destructor Documentation

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

Definition at line 330 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"));
   //tokenMultiTrackColl = consumes< RPMulFittedTrackCollection >(ps.getParameter<edm::InputTag>("tagMultiTrackColl"));
 }

TotemRPDQMSource::~TotemRPDQMSource ( )

virtual

Definition at line 345 of file TotemRPDQMSource.cc.

346 {

347 }

Member Function Documentation

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

overrideprotectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 425 of file TotemRPDQMSource.cc.

References CTPPSDetId::arm(), armPlots, edm::DetSet< T >::begin(), edm::EventBase::bunchCrossing(), python.rootplot.argparse::category, TotemRPDQMSource::GlobalPlots::events_per_bx, TotemRPDQMSource::GlobalPlots::events_per_bx_short, MonitorElement::Fill(), geometry, edm::EventSetup::get(), CTPPSDetId::getArmId(), TotemRPGeometry::GetDetector(), TotemRPGeometry::GetRPGlobalTranslation(), CTPPSDetId::getRPId(), globalPlots, TotemRPGeometry::GlobalToLocal(), TotemRPDQMSource::ArmPlots::h_trackCorr, TotemRPDQMSource::GlobalPlots::h_trackCorr_hor, TotemRPDQMSource::ArmPlots::h_trackCorr_overlap, TotemRPDQMSource::PotPlots::hit_plane_hist, hfClusterShapes_cfi::hits, edm::eventsetup::heterocontainer::insert(), TotemRPDetId::isStripsCoordinateUDirection(), edm::HandleBase::isValid(), TotemRPGeometry::LocalToGlobalDirection(), match(), TtSemiLepHitFitProducer_Electrons_cfi::mTop, AlCaHLTBitMon_ParallelJobs::p, patterns, TotemRPDetId::plane(), planePlots, plot_utils::plots, potPlots, createTree::pp, TotemRPUVPattern::projU, TotemRPUVPattern::projV, CTPPSDetId::rp(), 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<TotemRPGeometry> 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);
 
   //Handle< RPMulFittedTrackCollection > multiTracks;
   //event.getByToken(tokenMultiTrackColl, multiTracks);
 
   // check validity
   bool valid = true;
   valid &= status.isValid();
   valid &= digi.isValid();
   valid &= digCluster.isValid();
   valid &= hits.isValid();
   valid &= patterns.isValid();
   valid &= tracks.isValid();
   //valid &= multiTracks.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();
       //<< "    multiTracks.isValid = %i\n", multiTracks.isValid()
     }
 
     return;
   }
 
   //------------------------------
   // Global Plots
 
   globalPlots.events_per_bx->Fill(event.bunchCrossing());
   globalPlots.events_per_bx_short->Fill(event.bunchCrossing());
 
   for (auto &ds1 : *tracks)
   {
     for (auto &tr1 : ds1)
     {
       if (! tr1.isValid())
         continue;
   
       CTPPSDetId rpId1(ds1.detId());
       unsigned int arm1 = rpId1.arm();
       unsigned int stNum1 = rpId1.station();
       unsigned int rpNum1 = rpId1.rp();
       if (stNum1 != 0 || (rpNum1 != 2 && rpNum1 != 3))
         continue;
       unsigned int idx1 = arm1*2 + rpNum1-2;
 
       for (auto &ds2 : *tracks)
       {
         for (auto &tr2 : ds2)
         {
           if (! tr2.isValid())
             continue;
         
           CTPPSDetId rpId2(ds2.detId());
           unsigned int arm2 = rpId2.arm();
           unsigned int stNum2 = rpId2.station();
           unsigned int rpNum2 = rpId2.rp();
           if (stNum2 != 0 || (rpNum2 != 2 && rpNum2 != 3))
             continue;
           unsigned int idx2 = arm2*2 + rpNum2-2;
   
           globalPlots.h_trackCorr_hor->Fill(idx1, idx2); 
         }
       }
     }
   }
 
   //------------------------------
   // Status Plots
 
   for (auto &ds : *status)
   {
     TotemRPDetId detId(ds.detId());
     unsigned int plNum = detId.plane();
     CTPPSDetId rpId = detId.getRPId();
 
     auto &plots = potPlots[rpId];
 
     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());
     for (DetSet<TotemRPDigi>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
       planePlots[detId].digi_profile_cumulative->Fill(dit->getStripNumber());
   }
 
   // cluster profile cumulative
   for (DetSetVector<TotemRPCluster>::const_iterator it = digCluster->begin(); it != digCluster->end(); it++)
   {
     TotemRPDetId detId(it->detId());
     for (DetSet<TotemRPCluster>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
       planePlots[detId].cluster_profile_cumulative->Fill(dit->getCenterStripPosition());
   }
 
   // hit multiplicity
   for (DetSetVector<TotemRPCluster>::const_iterator it = digCluster->begin(); it != digCluster->end(); it++)
   {
     TotemRPDetId detId(it->detId());
     planePlots[detId].hit_multiplicity->Fill(it->size());
   }
 
   // cluster size
   for (DetSetVector<TotemRPCluster>::const_iterator it = digCluster->begin(); it != digCluster->end(); it++)
   {
     TotemRPDetId detId(it->detId());
     for (DetSet<TotemRPCluster>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
       planePlots[detId].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->GetRPGlobalTranslation(rpId).z();
 
       for (unsigned int plNum = 0; plNum < 10; ++plNum)
       {
         TotemRPDetId plId = rpId;
         plId.setPlane(plNum);
 
         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;
             }
           }
         }
 
         auto &pp = planePlots[plId];
 
         pp.efficiency_den->Fill(ft_v);
         if (hasMatchingHit)
           pp.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();
 
     PotPlots &pp = potPlots[rpId];
     for (DetSet<TotemRPCluster>::const_iterator dit = it->begin(); dit != it->end(); ++dit)
       pp.hit_plane_hist->Fill(planeNum, dit->getCenterStripPosition());   
   }
 
   // recognized pattern histograms
   for (auto &ds : *patterns)
   {
     CTPPSDetId rpId(ds.detId());
 
     PotPlots &pp = potPlots[rpId];
 
     // 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++;
     }
 
     pp.patterns_u->Fill(u);
     pp.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
   for (auto &ds : *tracks)
   {
     CTPPSDetId rpId(ds.detId());
 
     PotPlots &pp = potPlots[rpId];
 
     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++;
         }
       }
 
       pp.h_planes_fit_u->Fill(n_pl_in_fit_u);
       pp.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->GetDetector(plId_V)->translation().x() +
                       geometry->GetDetector(plId_U)->translation().x() ) / 2.;
       double rp_y = ( geometry->GetDetector(plId_V)->translation().y() +
                       geometry->GetDetector(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;
   
       pp.trackHitsCumulativeHist->Fill(x, y);
   
       double U = x * rod_U.x() + y * rod_U.y();
       double V = x * rod_V.x() + y * rod_V.y();
   
       pp.track_u_profile->Fill(U);
       pp.track_v_profile->Fill(V);
     }
   }
 
   //------------------------------
   // Station Plots
 
   
   //------------------------------
   // Arm Plots
   {
     map<unsigned int, unsigned int> mTop, mHor, mBot;
 
     for (auto p : armPlots)
     {
       mTop[p.first] = 0;
       mHor[p.first] = 0;
       mBot[p.first] = 0;
     }
 
     for (auto &ds : *tracks)
     {
       CTPPSDetId rpId(ds.detId());
       unsigned int rpNum = rpId.rp();
       CTPPSDetId armId = rpId.getArmId();
 
       for (auto &tr : ds)
       {
         if (! tr.isValid())
           continue;
   
         if (rpNum == 0 || rpNum == 4)
           mTop[armId]++;
         if (rpNum == 2 || rpNum == 3)
           mHor[armId]++;
         if (rpNum == 1 || rpNum == 5)
           mBot[armId]++;
       }
     }
 
     for (auto &p : armPlots)
     {
       p.second.h_numRPWithTrack_top->Fill(mTop[p.first]);
       p.second.h_numRPWithTrack_hor->Fill(mHor[p.first]);
       p.second.h_numRPWithTrack_bot->Fill(mBot[p.first]);
     }
 
     // track RP correlation
     for (auto &ds1 : *tracks)
     {
       for (auto &tr1 : ds1)
       {
         if (! tr1.isValid())
           continue;
   
         CTPPSDetId rpId1(ds1.detId());
         unsigned int arm1 = rpId1.arm();
         unsigned int stNum1 = rpId1.station();
         unsigned int rpNum1 = rpId1.rp();
         unsigned int idx1 = stNum1/2 * 7 + rpNum1;
         bool hor1 = (rpNum1 == 2 || rpNum1 == 3);
   
         CTPPSDetId armId = rpId1.getArmId();
         ArmPlots &ap = armPlots[armId];
   
         for (auto &ds2 : *tracks)
         {
           for (auto &tr2 : ds2)
           {
             if (! tr2.isValid())
               continue;
           
             CTPPSDetId rpId2(ds2.detId());
             unsigned int arm2 = rpId2.arm();
             unsigned int stNum2 = rpId2.station();
             unsigned int rpNum2 = rpId2.rp();
             unsigned int idx2 = stNum2/2 * 7 + rpNum2;
             bool hor2 = (rpNum2 == 2 || rpNum2 == 3);
     
             if (arm1 != arm2)
               continue;
     
             ap.h_trackCorr->Fill(idx1, idx2); 
             
             if (hor1 != hor2)
               ap.h_trackCorr_overlap->Fill(idx1, idx2); 
           }
         }
       }
     }
   }
   
   //------------------------------
   // RP-system plots
   // TODO: this code needs
   //    * generalization for more than two RPs per arm
   //    * updating for tracks as DetSetVector
   /*
   for (auto &dp : diagonalPlots)
   {
     unsigned int id = dp.first;
     bool top45 = id & 2;
     bool top56 = id & 1;
 
     unsigned int id_45_n = (top45) ? 20 : 21;
     unsigned int id_45_f = (top45) ? 24 : 25;
     unsigned int id_56_n = (top56) ? 120 : 121;
     unsigned int id_56_f = (top56) ? 124 : 125;
   
     bool h_45_n = (tracks->find(id_45_n) != tracks->end() && tracks->find(id_45_n)->second.IsValid());
     bool h_45_f = (tracks->find(id_45_f) != tracks->end() && tracks->find(id_45_f)->second.IsValid());
     bool h_56_n = (tracks->find(id_56_n) != tracks->end() && tracks->find(id_56_n)->second.IsValid());
     bool h_56_f = (tracks->find(id_56_f) != tracks->end() && tracks->find(id_56_f)->second.IsValid());
   
     if (! (h_45_n && h_45_f && h_56_n && h_56_f) )
       continue;
 
     double x_45_n = tracks->find(id_45_n)->second.X0(), y_45_n = tracks->find(id_45_n)->second.Y0();
     double x_45_f = tracks->find(id_45_f)->second.X0(), y_45_f = tracks->find(id_45_f)->second.Y0();
     double x_56_n = tracks->find(id_56_n)->second.X0(), y_56_n = tracks->find(id_56_n)->second.Y0();
     double x_56_f = tracks->find(id_56_f)->second.X0(), y_56_f = tracks->find(id_56_f)->second.Y0();
 
     double dx_45 = x_45_f - x_45_n;
     double dy_45 = y_45_f - y_45_n;
     double dx_56 = x_56_f - x_56_n;
     double dy_56 = y_56_f - y_56_n;
 
     DiagonalPlots &pl = dp.second;
 
     pl.h_lrc_x_d->Fill(dx_45, dx_56);  
     pl.h_lrc_y_d->Fill(dy_45, dy_56);  
     
     pl.h_lrc_x_n->Fill(x_45_n, x_56_n);  
     pl.h_lrc_y_n->Fill(y_45_n, y_56_n);  
     
     pl.h_lrc_x_f->Fill(x_45_f, x_56_f);  
     pl.h_lrc_y_f->Fill(y_45_f, y_56_f);
   }
   */
 }

void TotemRPDQMSource::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 418 of file TotemRPDQMSource.cc.

420 {

421 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 357 of file TotemRPDQMSource.cc.

References armPlots, DQMStore::IBooker::cd(), globalPlots, TotemRPDQMSource::GlobalPlots::Init(), planePlots, potPlots, DQMStore::IBooker::setCurrentFolder(), and stationPlots.

 {
   ibooker.cd();
   ibooker.setCurrentFolder("CTPPS");
 
   // global plots
   globalPlots.Init(ibooker);
 
   // temporarily disabled
   /*
   // initialize diagonals
   diagonalPlots[1] = DiagonalPlots(ibooker, 1);  // 45 bot - 56 top
   diagonalPlots[2] = DiagonalPlots(ibooker, 2);  // 45 top - 45 bot
 
   // initialize anti-diagonals
   diagonalPlots[0] = DiagonalPlots(ibooker, 0);  // 45 bot - 56 bot
   diagonalPlots[3] = DiagonalPlots(ibooker, 3);  // 45 top - 56 top
   */
 
   // loop over arms
   for (unsigned int arm = 0; arm < 2; arm++)
   {
     TotemRPDetId armId(arm, 0);
     armPlots[armId] = ArmPlots(ibooker, armId);
 
     // loop over stations
     for (unsigned int st = 0; st < 3; st += 2)
     {
       TotemRPDetId stId(arm, st);
       stationPlots[stId] = StationPlots(ibooker, stId);
 
       // loop over RPs
       for (unsigned int rp = 0; rp < 6; ++rp)
       {
         if (st == 2)
         {
           // unit 220-nr is not equipped
           if (rp <= 2)
             continue;
 
           // RP 220-fr-hr contains pixels
           if (rp == 3)
             continue;
         }
 
         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);
         }
       }
     }
   }
 }