Inheritance diagram for CTPPSDiamondDQMSource:

Classes
struct	ChannelPlots
	plots related to one Diamond channel More...

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

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

struct	PotPlots
	plots related to one Diamond detector package More...

Public Member Functions
	CTPPSDiamondDQMSource (const edm::ParameterSet &)

	~CTPPSDiamondDQMSource () override

Public Member Functions inherited from one::DQMEDAnalyzer< edm::LuminosityBlockCache< dds::Cache > >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

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

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

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

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

std::shared_ptr< dds::Cache >	globalBeginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) const override

void	globalEndLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override

Private Attributes
int	centralOOT_

std::unordered_map< unsigned int, ChannelPlots >	channelPlots_

int	EC_difference_45_

int	EC_difference_56_

bool	excludeMultipleHits_

GlobalPlots	globalPlot_

double	horizontalShiftBwDiamondPixels_

double	horizontalShiftOfDiamond_

std::unordered_map< unsigned int, PlanePlots >	planePlots_

std::unordered_map< unsigned int, PotPlots >	potPlots_

std::vector< std::pair< edm::EventRange, int > >	runParameters_

edm::EDGetTokenT< edm::DetSetVector< CTPPSDiamondRecHit > >	tokenDiamondHit_

edm::EDGetTokenT< edm::DetSetVector< CTPPSDiamondLocalTrack > >	tokenDiamondTrack_

edm::EDGetTokenT< edm::DetSetVector< CTPPSDiamondDigi > >	tokenDigi_

edm::EDGetTokenT< std::vector< TotemFEDInfo > >	tokenFEDInfo_

edm::EDGetTokenT< edm::DetSetVector< CTPPSPixelLocalTrack > >	tokenPixelTrack_

edm::EDGetTokenT< edm::DetSetVector< TotemVFATStatus > >	tokenStatus_

unsigned int	verbosity_

Static Private Attributes
static const int	CHANNEL_OF_VFAT_CLOCK = 30

static const int	CTPPS_DIAMOND_NUM_OF_CHANNELS = 12

static const int	CTPPS_DIAMOND_NUM_OF_PLANES = 4

static const int	CTPPS_DIAMOND_RP_ID = 6

static const int	CTPPS_DIAMOND_STATION_ID = 1

static const int	CTPPS_FAR_RP_ID = 3

static const int	CTPPS_FED_ID_45 = 583

static const int	CTPPS_FED_ID_56 = 582

static const int	CTPPS_NEAR_RP_ID = 2

static const int	CTPPS_NUM_OF_ARMS = 2

static const int	CTPPS_PIXEL_STATION_ID = 2

static const double	DISPLAY_RESOLUTION_FOR_HITS_MM = 0.1

static const double	HPTDC_BIN_WIDTH_NS = 25. / 1024

static const double	INV_DISPLAY_RESOLUTION_FOR_HITS_MM = 1. / DISPLAY_RESOLUTION_FOR_HITS_MM

static const double	SEC_PER_LUMI_SECTION = 23.31

Detailed Description

Definition at line 67 of file CTPPSDiamondDQMSource.cc.

Constructor & Destructor Documentation

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

Definition at line 475 of file CTPPSDiamondDQMSource.cc.

References edm::ParameterSet::getParameter(), muonDTDigis_cfi::pset, and runParameters_.

     : tokenStatus_(consumes<edm::DetSetVector<TotemVFATStatus>>(ps.getParameter<edm::InputTag>("tagStatus"))),
       tokenPixelTrack_(
           consumes<edm::DetSetVector<CTPPSPixelLocalTrack>>(ps.getParameter<edm::InputTag>("tagPixelLocalTracks"))),
       tokenDigi_(consumes<edm::DetSetVector<CTPPSDiamondDigi>>(ps.getParameter<edm::InputTag>("tagDigi"))),
       tokenDiamondHit_(
           consumes<edm::DetSetVector<CTPPSDiamondRecHit>>(ps.getParameter<edm::InputTag>("tagDiamondRecHits"))),
       tokenDiamondTrack_(
           consumes<edm::DetSetVector<CTPPSDiamondLocalTrack>>(ps.getParameter<edm::InputTag>("tagDiamondLocalTracks"))),
       tokenFEDInfo_(consumes<std::vector<TotemFEDInfo>>(ps.getParameter<edm::InputTag>("tagFEDInfo"))),
       excludeMultipleHits_(ps.getParameter<bool>("excludeMultipleHits")),
       centralOOT_(-999),
       verbosity_(ps.getUntrackedParameter<unsigned int>("verbosity", 0)),
       EC_difference_56_(-500),
       EC_difference_45_(-500) {
   for (const auto& pset : ps.getParameter<std::vector<edm::ParameterSet>>("offsetsOOT")) {
     runParameters_.emplace_back(
         std::make_pair(pset.getParameter<edm::EventRange>("validityRange"), pset.getParameter<int>("centralOOT")));
   }
 }

CTPPSDiamondDQMSource::~CTPPSDiamondDQMSource ( )

override

Definition at line 498 of file CTPPSDiamondDQMSource.cc.

498 {}

Member Function Documentation

void CTPPSDiamondDQMSource::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 563 of file CTPPSDiamondDQMSource.cc.

References funct::abs(), edm::EventBase::bunchCrossing(), centralOOT_, CHANNEL_OF_VFAT_CLOCK, channelAlignedWithTrack(), channelPlots_, CTPPS_DIAMOND_RP_ID, CTPPS_DIAMOND_STATION_ID, CTPPS_FAR_RP_ID, CTPPS_FED_ID_45, CTPPS_FED_ID_56, CTPPS_PIXEL_STATION_ID, TauDecayModes::dec, EC_difference_45_, EC_difference_56_, excludeMultipleHits_, HcalObjRepresent::Fill(), edm::EventSetup::get(), HPTDCErrorFlags::getErrorId(), edm::Event::getLuminosityBlock(), horizontalShiftBwDiamondPixels_, horizontalShiftOfDiamond_, HPTDC_BIN_WIDTH_NS, mps_fire::i, edm::LuminosityBlock::index(), edm::eventsetup::heterocontainer::insert(), INV_DISPLAY_RESOLUTION_FOR_HITS_MM, edm::HandleBase::isValid(), PixelTracks_cff::pixelTracks, planePlots_, potPlots_, edm::ESHandle< T >::product(), TrackInfoProducer_cfi::rechits, CTPPSDiamondDetId::setChannel(), CTPPSDiamondDetId::setPlane(), mps_update::status, CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING, tokenDiamondHit_, tokenDiamondTrack_, tokenDigi_, tokenFEDInfo_, tokenPixelTrack_, tokenStatus_, HiIsolationCommonParameters_cff::track, l1t::tracks, and verbosity_.

                                                                                       {
   // get event data
   edm::Handle<edm::DetSetVector<TotemVFATStatus>> diamondVFATStatus;
   event.getByToken(tokenStatus_, diamondVFATStatus);
 
   edm::Handle<edm::DetSetVector<CTPPSPixelLocalTrack>> pixelTracks;
   event.getByToken(tokenPixelTrack_, pixelTracks);
 
   edm::Handle<edm::DetSetVector<CTPPSDiamondDigi>> diamondDigis;
   event.getByToken(tokenDigi_, diamondDigis);
 
   edm::Handle<std::vector<TotemFEDInfo>> fedInfo;
   event.getByToken(tokenFEDInfo_, fedInfo);
 
   edm::Handle<edm::DetSetVector<CTPPSDiamondRecHit>> diamondRecHits;
   event.getByToken(tokenDiamondHit_, diamondRecHits);
 
   edm::Handle<edm::DetSetVector<CTPPSDiamondLocalTrack>> diamondLocalTracks;
   event.getByToken(tokenDiamondTrack_, diamondLocalTracks);
 
   edm::ESHandle<CTPPSGeometry> geometry_;
   iSetup.get<VeryForwardRealGeometryRecord>().get(geometry_);
 
   // check validity
   bool valid = true;
   valid &= diamondVFATStatus.isValid();
   valid &= pixelTracks.isValid();
   valid &= diamondDigis.isValid();
   valid &= fedInfo.isValid();
   valid &= diamondRecHits.isValid();
   valid &= diamondLocalTracks.isValid();
 
   if (!valid) {
     if (verbosity_) {
       edm::LogProblem("CTPPSDiamondDQMSource")
           << "ERROR in CTPPSDiamondDQMSource::analyze > some of the required inputs are not valid. Skipping this "
              "event.\n"
           << "    diamondVFATStatus.isValid = " << diamondVFATStatus.isValid() << "\n"
           << "    pixelTracks.isValid = " << pixelTracks.isValid() << "\n"
           << "    diamondDigis.isValid = " << diamondDigis.isValid() << "\n"
           << "    fedInfo.isValid = " << fedInfo.isValid() << "\n"
           << "    diamondRecHits.isValid = " << diamondRecHits.isValid() << "\n"
           << "    diamondLocalTracks.isValid = " << diamondLocalTracks.isValid();
     }
 
     return;
   }
 
   //------------------------------
   // RP Plots
   //------------------------------
 
   //------------------------------
   // Correlation Plots
   //------------------------------
 
   // Using CTPPSDiamondDigi
   for (const auto& digis : *diamondDigis) {
     const CTPPSDiamondDetId detId(digis.detId());
     CTPPSDiamondDetId detId_pot(digis.detId());
 
     for (const auto& digi : digis) {
       detId_pot.setPlane(0);
       detId_pot.setChannel(0);
       if (detId.channel() == CHANNEL_OF_VFAT_CLOCK)
         continue;
       if (potPlots_.find(detId_pot) == potPlots_.end())
         continue;
       //Leading without trailing investigation
       if (digi.getLeadingEdge() != 0 || digi.getTrailingEdge() != 0) {
         ++(potPlots_[detId_pot].HitCounter);
         if (digi.getLeadingEdge() != 0) {
           potPlots_[detId_pot].leadingEdgeCumulative_all->Fill(HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge());
         }
         if (digi.getLeadingEdge() != 0 && digi.getTrailingEdge() == 0) {
           ++(potPlots_[detId_pot].LeadingOnlyCounter);
           potPlots_[detId_pot].leadingEdgeCumulative_le->Fill(HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge());
         }
         if (digi.getLeadingEdge() == 0 && digi.getTrailingEdge() != 0) {
           ++(potPlots_[detId_pot].TrailingOnlyCounter);
           potPlots_[detId_pot].trailingEdgeCumulative_te->Fill(HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge());
         }
         if (digi.getLeadingEdge() != 0 && digi.getTrailingEdge() != 0) {
           ++(potPlots_[detId_pot].CompleteCounter);
           potPlots_[detId_pot].leadingTrailingCorrelationPot->Fill(HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge(),
                                                                    HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge());
         }
       }
 
       // HPTDC Errors
       const HPTDCErrorFlags hptdcErrors = digi.getHPTDCErrorFlags();
       if (detId.channel() == 6 || detId.channel() == 7)  // ch6 for HPTDC 0 and ch7 for HPTDC 1
       {
         int verticalIndex = 2 * detId.plane() + (detId.channel() - 6);
         for (unsigned short hptdcErrorIndex = 1; hptdcErrorIndex < 16; ++hptdcErrorIndex)
           if (hptdcErrors.getErrorId(hptdcErrorIndex - 1))
             potPlots_[detId_pot].HPTDCErrorFlags_2D->Fill(hptdcErrorIndex, verticalIndex);
       }
       if (digi.getMultipleHit())
         ++(potPlots_[detId_pot].MHCounter);
     }
   }
 
   // EC Errors
   for (const auto& vfat_status : *diamondVFATStatus) {
     const CTPPSDiamondDetId detId(vfat_status.detId());
     CTPPSDiamondDetId detId_pot(vfat_status.detId());
     detId_pot.setPlane(0);
     detId_pot.setChannel(0);
     for (const auto& status : vfat_status) {
       if (!status.isOK())
         continue;
       if (potPlots_.find(detId_pot) == potPlots_.end())
         continue;
       if (channelPlots_.find(detId) == channelPlots_.end())
         continue;
 
       // Check Event Number
       for (const auto& optorx : *fedInfo) {
         if (detId.arm() == 1 && optorx.getFEDId() == CTPPS_FED_ID_56) {
           potPlots_[detId_pot].ECCheck->Fill((int)((optorx.getLV1() & 0xFF) - ((unsigned int)status.getEC() & 0xFF)) &
                                              0xFF);
           if ((static_cast<int>((optorx.getLV1() & 0xFF) - status.getEC()) != EC_difference_56_) &&
               (static_cast<uint8_t>((optorx.getLV1() & 0xFF) - status.getEC()) < 128))
             EC_difference_56_ =
                 static_cast<int>(optorx.getLV1() & 0xFF) - (static_cast<unsigned int>(status.getEC()) & 0xFF);
           if (EC_difference_56_ != 1 && EC_difference_56_ != -500 && std::abs(EC_difference_56_) < 127) {
             if (detId.channel() == 6 || detId.channel() == 7)
               potPlots_[detId_pot].HPTDCErrorFlags_2D->Fill(16, 2 * detId.plane() + (detId.channel() - 6));
             if (verbosity_)
               edm::LogProblem("CTPPSDiamondDQMSource")
                   << "FED " << CTPPS_FED_ID_56 << ": ECError at EV: 0x" << std::hex << optorx.getLV1()
                   << "\t\tVFAT EC: 0x" << static_cast<unsigned int>(status.getEC()) << "\twith ID: " << std::dec
                   << detId << "\tdiff: " << EC_difference_56_;
           }
         } else if (detId.arm() == 0 && optorx.getFEDId() == CTPPS_FED_ID_45) {
           potPlots_[detId_pot].ECCheck->Fill((int)((optorx.getLV1() & 0xFF) - status.getEC()) & 0xFF);
           if ((static_cast<int>((optorx.getLV1() & 0xFF) - status.getEC()) != EC_difference_45_) &&
               (static_cast<uint8_t>((optorx.getLV1() & 0xFF) - status.getEC()) < 128))
             EC_difference_45_ =
                 static_cast<int>(optorx.getLV1() & 0xFF) - (static_cast<unsigned int>(status.getEC()) & 0xFF);
           if (EC_difference_45_ != 1 && EC_difference_45_ != -500 && std::abs(EC_difference_45_) < 127) {
             if (detId.channel() == 6 || detId.channel() == 7)
               potPlots_[detId_pot].HPTDCErrorFlags_2D->Fill(16, 2 * detId.plane() + (detId.channel() - 6));
             if (verbosity_)
               edm::LogProblem("CTPPSDiamondDQMSource")
                   << "FED " << CTPPS_FED_ID_45 << ": ECError at EV: 0x" << std::hex << optorx.getLV1()
                   << "\t\tVFAT EC: 0x" << static_cast<unsigned int>(status.getEC()) << "\twith ID: " << std::dec
                   << detId << "\tdiff: " << EC_difference_45_;
           }
         }
       }
     }
   }
 
   // Using CTPPSDiamondRecHit
   std::unordered_map<unsigned int, std::set<unsigned int>> planes;
   std::unordered_map<unsigned int, std::set<unsigned int>> planes_inclusive;
 
   auto lumiCache = luminosityBlockCache(event.getLuminosityBlock().index());
   for (const auto& rechits : *diamondRecHits) {
     CTPPSDiamondDetId detId_pot(rechits.detId());
     detId_pot.setPlane(0);
     detId_pot.setChannel(0);
     const CTPPSDiamondDetId detId(rechits.detId());
 
     for (const auto& rechit : rechits) {
       planes_inclusive[detId_pot].insert(detId.plane());
       if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
         continue;
       if (rechit.getToT() != 0 && centralOOT_ != -999 && rechit.getOOTIndex() == centralOOT_)
         planes[detId_pot].insert(detId.plane());
 
       if (potPlots_.find(detId_pot) == potPlots_.end())
         continue;
 
       float UFSDShift = 0.0;
       if (rechit.getYWidth() < 3)
         UFSDShift = 0.5;  // Display trick for UFSD that have 2 pixels with same X
 
       if (rechit.getToT() != 0 && centralOOT_ != -999 && rechit.getOOTIndex() == centralOOT_) {
         TH2F* hitHistoTmp = potPlots_[detId_pot].hitDistribution2d->getTH2F();
         TAxis* hitHistoTmpYAxis = hitHistoTmp->GetYaxis();
         int startBin = hitHistoTmpYAxis->FindBin(rechit.getX() - horizontalShiftOfDiamond_ - 0.5 * rechit.getXWidth());
         int numOfBins = rechit.getXWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
         for (int i = 0; i < numOfBins; ++i) {
           hitHistoTmp->Fill(detId.plane() + UFSDShift, hitHistoTmpYAxis->GetBinCenter(startBin + i));
         }
 
         hitHistoTmp = lumiCache->hitDistribution2dMap[detId_pot].get();
         hitHistoTmpYAxis = hitHistoTmp->GetYaxis();
         startBin = hitHistoTmpYAxis->FindBin(rechit.getX() - horizontalShiftOfDiamond_ - 0.5 * rechit.getXWidth());
         numOfBins = rechit.getXWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
         for (int i = 0; i < numOfBins; ++i) {
           hitHistoTmp->Fill(detId.plane() + UFSDShift, hitHistoTmpYAxis->GetBinCenter(startBin + i));
         }
       }
 
       if (rechit.getToT() != 0) {
         // Both
         potPlots_[detId_pot].leadingEdgeCumulative_both->Fill(rechit.getT() + 25 * rechit.getOOTIndex());
         potPlots_[detId_pot].timeOverThresholdCumulativePot->Fill(rechit.getToT());
 
         TH2F* hitHistoOOTTmp = potPlots_[detId_pot].hitDistribution2dOOT->getTH2F();
         TAxis* hitHistoOOTTmpYAxis = hitHistoOOTTmp->GetYaxis();
         int startBin =
             hitHistoOOTTmpYAxis->FindBin(rechit.getX() - horizontalShiftOfDiamond_ - 0.5 * rechit.getXWidth());
         int numOfBins = rechit.getXWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
         for (int i = 0; i < numOfBins; ++i) {
           hitHistoOOTTmp->Fill(detId.plane() + 0.25 * rechit.getOOTIndex(),
                                hitHistoOOTTmpYAxis->GetBinCenter(startBin + i));
         }
       } else {
         if (rechit.getOOTIndex() != CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING) {
           // Only leading
           TH2F* hitHistoOOTTmp = potPlots_[detId_pot].hitDistribution2dOOT_le->getTH2F();
           TAxis* hitHistoOOTTmpYAxis = hitHistoOOTTmp->GetYaxis();
           int startBin =
               hitHistoOOTTmpYAxis->FindBin(rechit.getX() - horizontalShiftOfDiamond_ - 0.5 * rechit.getXWidth());
           int numOfBins = rechit.getXWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
           for (int i = 0; i < numOfBins; ++i) {
             hitHistoOOTTmp->Fill(detId.plane() + 0.25 * rechit.getOOTIndex(),
                                  hitHistoOOTTmpYAxis->GetBinCenter(startBin + i));
           }
         }
       }
       if (rechit.getOOTIndex() != CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING &&
           potPlots_[detId_pot].activity_per_bx.count(rechit.getOOTIndex()) > 0)
         potPlots_[detId_pot].activity_per_bx.at(rechit.getOOTIndex())->Fill(event.bunchCrossing());
     }
   }
 
   for (const auto& plt : potPlots_) {
     plt.second.activePlanes->Fill(planes[plt.first].size());
     plt.second.activePlanesInclusive->Fill(planes_inclusive[plt.first].size());
   }
 
   // Using CTPPSDiamondLocalTrack
   for (const auto& tracks : *diamondLocalTracks) {
     CTPPSDiamondDetId detId_pot(tracks.detId());
     detId_pot.setPlane(0);
     detId_pot.setChannel(0);
     const CTPPSDiamondDetId detId(tracks.detId());
 
     for (const auto& track : tracks) {
       if (!track.isValid())
         continue;
       if (track.getOOTIndex() == CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING)
         continue;
       if (excludeMultipleHits_ && track.getMultipleHits() > 0)
         continue;
       if (potPlots_.find(detId_pot) == potPlots_.end())
         continue;
 
       TH2F* trackHistoOOTTmp = potPlots_[detId_pot].trackDistributionOOT->getTH2F();
       TAxis* trackHistoOOTTmpYAxis = trackHistoOOTTmp->GetYaxis();
       int startBin = trackHistoOOTTmpYAxis->FindBin(track.getX0() - horizontalShiftOfDiamond_ - track.getX0Sigma());
       int numOfBins = 2 * track.getX0Sigma() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
       for (int i = 0; i < numOfBins; ++i) {
         trackHistoOOTTmp->Fill(track.getOOTIndex(), trackHistoOOTTmpYAxis->GetBinCenter(startBin + i));
       }
 
       if (centralOOT_ != -999 && track.getOOTIndex() == centralOOT_) {
         TH1F* trackHistoInTimeTmp = potPlots_[detId_pot].trackDistribution->getTH1F();
         int startBin = trackHistoInTimeTmp->FindBin(track.getX0() - horizontalShiftOfDiamond_ - track.getX0Sigma());
         int numOfBins = 2 * track.getX0Sigma() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
         for (int i = 0; i < numOfBins; ++i) {
           trackHistoInTimeTmp->Fill(trackHistoInTimeTmp->GetBinCenter(startBin + i));
         }
       }
     }
   }
 
   // Channel efficiency using CTPPSDiamondLocalTrack
   for (const auto& tracks : *diamondLocalTracks) {
     CTPPSDiamondDetId detId_pot(tracks.detId());
     detId_pot.setPlane(0);
     detId_pot.setChannel(0);
     for (const auto& track : tracks) {
       // Find hits and planes in the track
       int numOfHits = 0;
       std::set<int> planesInTrackSet;
       for (const auto& vec : *diamondRecHits) {
         const CTPPSDiamondDetId detid(vec.detId());
         if (detid.arm() != detId_pot.arm())
           continue;
 
         for (const auto& hit : vec) {
           // first check if the hit contributes to the track
           if (track.containsHit(hit)) {
             ++numOfHits;
             planesInTrackSet.insert(detid.plane());
           }
         }
       }
 
       if (numOfHits > 0 && numOfHits <= 10 && planesInTrackSet.size() > 2) {
         for (int plane = 0; plane < 4; ++plane) {
           for (int channel = 0; channel < 12; ++channel) {
             int map_index = plane * 100 + channel;
             if (potPlots_[detId_pot].effDoublecountingChMap.find(map_index) ==
                 potPlots_[detId_pot].effDoublecountingChMap.end()) {
               potPlots_[detId_pot].effTriplecountingChMap[map_index] = 0;
               potPlots_[detId_pot].effDoublecountingChMap[map_index] = 0;
             }
             CTPPSDiamondDetId detId(detId_pot.arm(), CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID, plane, channel);
             if (channelAlignedWithTrack(geometry_.product(), detId, track, 0.2)) {
               // Channel should fire
               ++(potPlots_[detId_pot].effDoublecountingChMap[map_index]);
               for (const auto& rechits : *diamondRecHits) {
                 CTPPSDiamondDetId detId_hit(rechits.detId());
                 if (detId_hit == detId) {
                   for (const auto& rechit : rechits) {
                     if (track.containsHit(rechit, 1)) {
                       // Channel fired
                       ++(potPlots_[detId_pot].effTriplecountingChMap[map_index]);
                     }
                   }
                 }
               }
             }
           }
         }
       }
     }
   }
 
   // Tomography of diamonds using pixel
   for (const auto& rechits : *diamondRecHits) {
     CTPPSDiamondDetId detId_pot(rechits.detId());
     detId_pot.setPlane(0);
     detId_pot.setChannel(0);
     const CTPPSDiamondDetId detId(rechits.detId());
     for (const auto& rechit : rechits) {
       if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
         continue;
       if (rechit.getToT() == 0)
         continue;
       if (!pixelTracks.isValid())
         continue;
       if (potPlots_.find(detId_pot) == potPlots_.end())
         continue;
 
       for (const auto& ds : *pixelTracks) {
         if (ds.size() > 1)
           continue;
         const CTPPSPixelDetId pixId(ds.detId());
         if (pixId.station() != CTPPS_PIXEL_STATION_ID || pixId.rp() != CTPPS_FAR_RP_ID)
           continue;
         for (const auto& lt : ds) {
           if (lt.isValid() && pixId.arm() == detId_pot.arm()) {
             if (rechit.getOOTIndex() != CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING && rechit.getOOTIndex() >= 0 &&
                 potPlots_[detId_pot].pixelTomographyAll.count(rechit.getOOTIndex()) > 0 &&
                 lt.getX0() - horizontalShiftBwDiamondPixels_ < 24)
               potPlots_[detId_pot]
                   .pixelTomographyAll.at(rechit.getOOTIndex())
                   ->Fill(lt.getX0() - horizontalShiftBwDiamondPixels_ + 25 * detId.plane(), lt.getY0());
           }
         }
       }
     }
   }
 
   //------------------------------
   // Clock Plots
   //------------------------------
   // Commented out to save space in the DQM files, but code should be kept
   // for ( const auto& digis : *diamondDigis ) {
   //   const CTPPSDiamondDetId detId( digis.detId() );
   //   CTPPSDiamondDetId detId_pot( digis.detId() );
   //   if ( detId.channel() == CHANNEL_OF_VFAT_CLOCK ) {
   //     detId_pot.setPlane( 0 );
   //     detId_pot.setChannel( 0 );
   //     for ( const auto& digi : digis ) {
   //       if ( digi.getLeadingEdge() != 0 )  {
   //         if ( detId.plane() == 1 ) {
   //           potPlots_[detId_pot].clock_Digi1_le->Fill( HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge() );
   //           potPlots_[detId_pot].clock_Digi1_te->Fill( HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge() );
   //         }
   //         if ( detId.plane() == 3 ) {
   //           potPlots_[detId_pot].clock_Digi3_le->Fill( HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge() );
   //           potPlots_[detId_pot].clock_Digi3_te->Fill( HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge() );
   //         }
   //       }
   //     }
   //   }
   // }
 
   //------------------------------
   // Plane Plots
   //------------------------------
 
   // Using CTPPSDiamondDigi
   std::unordered_map<unsigned int, unsigned int> channelsPerPlane;
   for (const auto& digis : *diamondDigis) {
     const CTPPSDiamondDetId detId(digis.detId());
     CTPPSDiamondDetId detId_plane(digis.detId());
     for (const auto& digi : digis) {
       detId_plane.setChannel(0);
       if (detId.channel() == CHANNEL_OF_VFAT_CLOCK)
         continue;
       if (planePlots_.find(detId_plane) == planePlots_.end())
         continue;
 
       if (digi.getLeadingEdge() != 0) {
         planePlots_[detId_plane].digiProfileCumulativePerPlane->Fill(detId.channel());
         if (channelsPerPlane.find(detId_plane) != channelsPerPlane.end())
           channelsPerPlane[detId_plane]++;
         else
           channelsPerPlane[detId_plane] = 0;
       }
     }
   }
 
   for (const auto& plt : channelsPerPlane) {
     planePlots_[plt.first].hit_multiplicity->Fill(plt.second);
   }
 
   // Using CTPPSDiamondRecHit
   for (const auto& rechits : *diamondRecHits) {
     CTPPSDiamondDetId detId_plane(rechits.detId());
     detId_plane.setChannel(0);
     for (const auto& rechit : rechits) {
       if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
         continue;
       if (rechit.getToT() == 0)
         continue;
       if (planePlots_.find(detId_plane) != planePlots_.end()) {
         if (centralOOT_ != -999 && rechit.getOOTIndex() == centralOOT_) {
           TH1F* hitHistoTmp = planePlots_[detId_plane].hitProfile->getTH1F();
           int startBin = hitHistoTmp->FindBin(rechit.getX() - horizontalShiftOfDiamond_ - 0.5 * rechit.getXWidth());
           int numOfBins = rechit.getXWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
           for (int i = 0; i < numOfBins; ++i) {
             hitHistoTmp->Fill(hitHistoTmp->GetBinCenter(startBin + i));
           }
         }
       }
     }
   }
 
   //Tomography of diamonds using pixel and Efficiency WRT Pixels
   for (const auto& ds : *pixelTracks) {
     const CTPPSPixelDetId pixId(ds.detId());
     if (pixId.station() != CTPPS_PIXEL_STATION_ID || pixId.rp() != CTPPS_FAR_RP_ID)
       continue;
     if (ds.size() > 1)
       continue;
     for (const auto& lt : ds) {
       if (lt.isValid()) {
         // For efficieny
         CTPPSDiamondDetId detId_pot(pixId.arm(), CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID);
         potPlots_[detId_pot].pixelTracksMap.Fill(lt.getX0() - horizontalShiftBwDiamondPixels_, lt.getY0());
 
         std::set<CTPPSDiamondDetId> planesWitHits_set;
         for (const auto& rechits : *diamondRecHits) {
           CTPPSDiamondDetId detId_plane(rechits.detId());
           detId_plane.setChannel(0);
           for (const auto& rechit : rechits) {
             if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
               continue;
             if (rechit.getOOTIndex() == CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING || rechit.getToT() == 0)
               continue;
             if (planePlots_.find(detId_plane) == planePlots_.end())
               continue;
             if (pixId.arm() == detId_plane.arm() && lt.getX0() - horizontalShiftBwDiamondPixels_ < 24) {
               planePlots_[detId_plane].pixelTomography_far->Fill(
                   lt.getX0() - horizontalShiftBwDiamondPixels_ + 25 * rechit.getOOTIndex(), lt.getY0());
               if (centralOOT_ != -999 && rechit.getOOTIndex() == centralOOT_)
                 planesWitHits_set.insert(detId_plane);
             }
           }
         }
 
         for (auto& planeId : planesWitHits_set)
           planePlots_[planeId].pixelTracksMapWithDiamonds.Fill(lt.getX0() - horizontalShiftBwDiamondPixels_,
                                                                lt.getY0());
       }
     }
   }
 
   //------------------------------
   // Channel Plots
   //------------------------------
 
   // digi profile cumulative
   for (const auto& digis : *diamondDigis) {
     const CTPPSDiamondDetId detId(digis.detId());
     for (const auto& digi : digis) {
       if (detId.channel() == CHANNEL_OF_VFAT_CLOCK)
         continue;
       if (channelPlots_.find(detId) != channelPlots_.end()) {
         // HPTDC Errors
         const HPTDCErrorFlags hptdcErrors = digi.getHPTDCErrorFlags();
         for (unsigned short hptdcErrorIndex = 1; hptdcErrorIndex < 16; ++hptdcErrorIndex)
           if (hptdcErrors.getErrorId(hptdcErrorIndex - 1))
             channelPlots_[detId].HPTDCErrorFlags->Fill(hptdcErrorIndex);
         if (digi.getMultipleHit())
           ++(channelPlots_[detId].MHCounter);
 
         // Check dropped trailing edges
         if (digi.getLeadingEdge() != 0 || digi.getTrailingEdge() != 0) {
           ++(channelPlots_[detId].HitCounter);
           if (digi.getLeadingEdge() != 0 && digi.getTrailingEdge() == 0) {
             ++(channelPlots_[detId].LeadingOnlyCounter);
             channelPlots_[detId].leadingEdgeCumulative_le->Fill(HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge());
           }
           if (digi.getLeadingEdge() == 0 && digi.getTrailingEdge() != 0) {
             ++(channelPlots_[detId].TrailingOnlyCounter);
             channelPlots_[detId].trailingEdgeCumulative_te->Fill(HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge());
           }
           if (digi.getLeadingEdge() != 0 && digi.getTrailingEdge() != 0) {
             ++(channelPlots_[detId].CompleteCounter);
             channelPlots_[detId].LeadingTrailingCorrelationPerChannel->Fill(
                 HPTDC_BIN_WIDTH_NS * digi.getLeadingEdge(), HPTDC_BIN_WIDTH_NS * digi.getTrailingEdge());
           }
         }
       }
     }
   }
 
   // Using CTPPSDiamondRecHit
 
   for (const auto& rechits : *diamondRecHits) {
     CTPPSDiamondDetId detId(rechits.detId());
     for (const auto& rechit : rechits) {
       if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
         continue;
       if (channelPlots_.find(detId) != channelPlots_.end()) {
         if (rechit.getOOTIndex() != CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING && rechit.getToT() != 0) {
           channelPlots_[detId].leadingEdgeCumulative_both->Fill(rechit.getT() + 25 * rechit.getOOTIndex());
           channelPlots_[detId].TimeOverThresholdCumulativePerChannel->Fill(rechit.getToT());
         }
         ++(lumiCache->hitsCounterMap[detId]);
       }
 
       if (rechit.getOOTIndex() != CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING &&
           channelPlots_[detId].activity_per_bx.count(rechit.getOOTIndex()) > 0)
         channelPlots_[detId].activity_per_bx.at(rechit.getOOTIndex())->Fill(event.bunchCrossing());
     }
   }
 
   // Tomography of diamonds using pixel
   for (const auto& rechits : *diamondRecHits) {
     const CTPPSDiamondDetId detId(rechits.detId());
     for (const auto& rechit : rechits) {
       if (excludeMultipleHits_ && rechit.getMultipleHits() > 0)
         continue;
       if (rechit.getOOTIndex() == CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING || rechit.getToT() == 0)
         continue;
       if (!pixelTracks.isValid())
         continue;
       if (channelPlots_.find(detId) == channelPlots_.end())
         continue;
 
       for (const auto& ds : *pixelTracks) {
         const CTPPSPixelDetId pixId(ds.detId());
         if (pixId.station() != CTPPS_PIXEL_STATION_ID || pixId.rp() != CTPPS_FAR_RP_ID)
           continue;
         if (ds.size() > 1)
           continue;
         for (const auto& lt : ds) {
           if (lt.isValid() && pixId.arm() == detId.arm() && lt.getX0() - horizontalShiftBwDiamondPixels_ < 24)
             channelPlots_[detId].pixelTomography_far->Fill(
                 lt.getX0() - horizontalShiftBwDiamondPixels_ + 25 * rechit.getOOTIndex(), lt.getY0());
         }
       }
     }
   }
 }

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

overrideprotected

Definition at line 529 of file CTPPSDiamondDQMSource.cc.

References DQMStore::IBooker::cd(), channelPlots_, CTPPS_DIAMOND_NUM_OF_CHANNELS, CTPPS_DIAMOND_NUM_OF_PLANES, CTPPS_DIAMOND_RP_ID, CTPPS_DIAMOND_STATION_ID, CTPPS_NUM_OF_ARMS, globalPlot_, planePlots_, potPlots_, year_2016_postTS2_cff::rpId, and DQMStore::IBooker::setCurrentFolder().

                                                                                                         {
   ibooker.cd();
   ibooker.setCurrentFolder("CTPPS");
 
   globalPlot_ = GlobalPlots(ibooker);
 
   for (unsigned short arm = 0; arm < CTPPS_NUM_OF_ARMS; ++arm) {
     const CTPPSDiamondDetId rpId(arm, CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID);
     potPlots_[rpId] = PotPlots(ibooker, rpId);
     for (unsigned short pl = 0; pl < CTPPS_DIAMOND_NUM_OF_PLANES; ++pl) {
       const CTPPSDiamondDetId plId(arm, CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID, pl);
       planePlots_[plId] = PlanePlots(ibooker, plId);
       for (unsigned short ch = 0; ch < CTPPS_DIAMOND_NUM_OF_CHANNELS; ++ch) {
         const CTPPSDiamondDetId chId(arm, CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID, pl, ch);
         channelPlots_[chId] = ChannelPlots(ibooker, chId);
       }
     }
   }
 }

void CTPPSDiamondDQMSource::dqmBeginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 502 of file CTPPSDiamondDQMSource.cc.

References centralOOT_, edm::contains(), CTPPS_DIAMOND_RP_ID, CTPPS_DIAMOND_STATION_ID, CTPPS_FAR_RP_ID, CTPPS_PIXEL_STATION_ID, relativeConstraints::geom, edm::EventSetup::get(), CTPPSGeometry::getSensor(), horizontalShiftBwDiamondPixels_, horizontalShiftOfDiamond_, DetGeomDesc::params(), edm::ESHandle< T >::product(), edm::RunBase::run(), runParameters_, and DetGeomDesc::translation().

                                                                                        {
   centralOOT_ = -999;
   for (const auto& oot : runParameters_) {
     if (edm::contains(oot.first, edm::EventID(iRun.run(), 0, 1))) {
       centralOOT_ = oot.second;
       break;
     }
   }
 
   // Get detector shifts from the geometry
   edm::ESHandle<CTPPSGeometry> geometry_;
   iSetup.get<VeryForwardRealGeometryRecord>().get(geometry_);
   const CTPPSGeometry* geom = geometry_.product();
   const CTPPSDiamondDetId detid(0, CTPPS_DIAMOND_STATION_ID, CTPPS_DIAMOND_RP_ID, 0, 0);
   const DetGeomDesc* det = geom->getSensor(detid);
   horizontalShiftOfDiamond_ = det->translation().x() - det->params().at(0);
 
   // Rough alignement of pixel detector for diamond thomography
   const CTPPSPixelDetId pixid(0, CTPPS_PIXEL_STATION_ID, CTPPS_FAR_RP_ID, 0);
   if (iRun.run() > 300000) {  //Pixel installed
     det = geom->getSensor(pixid);
     horizontalShiftBwDiamondPixels_ = det->translation().x() - det->params().at(0) - horizontalShiftOfDiamond_ - 1;
   }
 }

void CTPPSDiamondDQMSource::endRun	(	const edm::Run &	,
		const edm::EventSetup &
	)

overrideprotected

Definition at line 1206 of file CTPPSDiamondDQMSource.cc.

References DEFINE_FWK_MODULE.

1206 {}

std::shared_ptr< dds::Cache > CTPPSDiamondDQMSource::globalBeginLuminosityBlock	(	const edm::LuminosityBlock &	,
		const edm::EventSetup &
	)		const

overrideprotected

Definition at line 551 of file CTPPSDiamondDQMSource.cc.

References edmIntegrityCheck::d, plotFactory::plot, and potPlots_.

                                                                                                           {
   auto d = std::make_shared<dds::Cache>();
   d->hitDistribution2dMap.reserve(potPlots_.size());
   for (auto& plot : potPlots_)
     d->hitDistribution2dMap[plot.first] =
         std::unique_ptr<TH2F>(static_cast<TH2F*>(plot.second.hitDistribution2d_lumisection->getTH2F()->Clone()));
   return d;
 }

void CTPPSDiamondDQMSource::globalEndLuminosityBlock	(	const edm::LuminosityBlock &	iLumi,
		const edm::EventSetup &
	)

overrideprotected

Definition at line 1135 of file CTPPSDiamondDQMSource.cc.

References CTPPSDetId::arm(), CTPPSDiamondDetId::channel(), channelPlots_, PostProcessor_cff::efficiency, edm::LuminosityBlock::index(), CTPPSDiamondDetId::plane(), planePlots_, plotFactory::plot, potPlots_, CTPPSDetId::rp(), year_2016_postTS2_cff::rpId, SEC_PER_LUMI_SECTION, CTPPSDiamondDetId::setPlane(), and pileupDistInMC::total.

                                                                                                           {
   auto lumiCache = luminosityBlockCache(iLumi.index());
   for (auto& plot : potPlots_) {
     *(plot.second.hitDistribution2d_lumisection->getTH2F()) = *(lumiCache->hitDistribution2dMap[plot.first]);
   }
   for (auto& plot : channelPlots_) {
     auto hitsCounterPerLumisection = lumiCache->hitsCounterMap[plot.first];
     if (hitsCounterPerLumisection != 0) {
       plot.second.hit_rate->Fill((double)hitsCounterPerLumisection / SEC_PER_LUMI_SECTION);
     }
 
     double HundredOverHitCounter = .0;
     if (plot.second.HitCounter != 0)
       HundredOverHitCounter = 100. / plot.second.HitCounter;
     plot.second.HPTDCErrorFlags->setBinContent(16, HundredOverHitCounter * plot.second.MHCounter);
     plot.second.leadingWithoutTrailing->setBinContent(1, HundredOverHitCounter * plot.second.LeadingOnlyCounter);
     plot.second.leadingWithoutTrailing->setBinContent(2, HundredOverHitCounter * plot.second.TrailingOnlyCounter);
     plot.second.leadingWithoutTrailing->setBinContent(3, HundredOverHitCounter * plot.second.CompleteCounter);
   }
 
   for (auto& plot : potPlots_) {
     double HundredOverHitCounterPot = 0.;
     if (plot.second.HitCounter != 0)
       HundredOverHitCounterPot = 100. / plot.second.HitCounter;
     plot.second.leadingWithoutTrailingCumulativePot->setBinContent(
         1, HundredOverHitCounterPot * plot.second.LeadingOnlyCounter);
     plot.second.leadingWithoutTrailingCumulativePot->setBinContent(
         2, HundredOverHitCounterPot * plot.second.TrailingOnlyCounter);
     plot.second.leadingWithoutTrailingCumulativePot->setBinContent(
         3, HundredOverHitCounterPot * plot.second.CompleteCounter);
 
     plot.second.MHComprensive->Reset();
     CTPPSDiamondDetId rpId(plot.first);
     for (auto& chPlot : channelPlots_) {
       CTPPSDiamondDetId chId(chPlot.first);
       if (chId.arm() == rpId.arm() && chId.rp() == rpId.rp()) {
         plot.second.MHComprensive->Fill(chId.plane(), chId.channel(), chPlot.second.HPTDCErrorFlags->getBinContent(16));
       }
     }
   }
 
   // Efficiencies of single channels
   for (auto& plot : potPlots_) {
     plot.second.EfficiencyOfChannelsInPot->Reset();
     for (auto& element : plot.second.effTriplecountingChMap) {
       if (plot.second.effDoublecountingChMap[element.first] > 0) {
         int plane = element.first / 100;
         int channel = element.first % 100;
         double counted = element.second;
         double total = plot.second.effDoublecountingChMap[element.first];
         double efficiency = counted / total;
         //         double error = std::sqrt( efficiency * ( 1 - efficiency ) / total );
 
         plot.second.EfficiencyOfChannelsInPot->Fill(plane, channel, 100 * efficiency);
       }
     }
   }
 
   // Efficeincy wrt pixels  //TODO
   for (auto& plot : planePlots_) {
     TH2F* hitHistoTmp = plot.second.EfficiencyWRTPixelsInPlane->getTH2F();
 
     CTPPSDiamondDetId detId_pot(plot.first);
     detId_pot.setPlane(0);
 
     hitHistoTmp->Divide(&(plot.second.pixelTracksMapWithDiamonds), &(potPlots_[detId_pot].pixelTracksMap));
   }
 }