#include <DTDigiTask.h>

Inheritance diagram for DTDigiTask:

Public Member Functions
	DTDigiTask (const edm::ParameterSet &ps)
	Constructor. More...

	~DTDigiTask () override
	Destructor. More...

Public Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

	DQMOneEDAnalyzer ()

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

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::Accumulator, Args... >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
	Analyze. More...

void	beginLuminosityBlock (edm::LuminosityBlock const &lumiSeg, edm::EventSetup const &context) override
	To reset the MEs. More...

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

void	bookHistos (DQMStore::IBooker &ibooker, const DTSuperLayerId &dtSL, std::string folder, std::string histoTag)
	Book the ME. More...

void	bookHistos (DQMStore::IBooker &ibooker, const DTChamberId &dtCh, std::string folder, std::string histoTag)

void	bookHistos (DQMStore::IBooker &ibooker, const int wheelId, std::string folder, std::string histoTag)

void	channelsMap (const DTChamberId &dtCh, std::string histoTag)
	To map real channels. More...

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

void	endLuminosityBlock (edm::LuminosityBlock const &lumiSeg, edm::EventSetup const &context) final

std::string	triggerSource ()
	get the L1A source More...

Protected Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
virtual void	analyze (edm::Event const &, edm::EventSetup const &)

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

virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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 Member Functions
std::string	topFolder () const

Private Attributes
bool	checkNoisyChannels

int	defaultTmax

int	defaultTTrig

std::map< std::string, std::map< uint32_t, MonitorElement * > >	digiHistos

bool	doAllHitsOccupancies

bool	doInTimeOccupancies

bool	doLayerTimeBoxes

bool	doNoiseOccupancies

bool	doStaticBooking

edm::EDGetTokenT< DTDigiCollection >	dtDigiToken_

bool	filterSyncNoise

std::map< DTChamberId, int >	hitMap

int	inTimeHitsLowerBound

int	inTimeHitsUpperBound

bool	isLocalRun

float	kFactor

bool	lookForSyncNoise

edm::EDGetTokenT< LTCDigiCollection >	ltcDigiCollectionToken_

edm::Handle< LTCDigiCollection >	ltcdigis

edm::ESHandle< DTReadOutMapping >	mapping

int	maxTDCHits

int	maxTTMounts

edm::ESHandle< DTGeometry >	muonGeom

MonitorElement *	nEventMonitor

int	nevents

std::map< DTChamberId, int >	nSynchNoiseEvents

bool	readTTrigDB

int	resetCycle

bool	sliceTestMode

bool	subtractT0

std::set< DTChamberId >	syncNoisyChambers

int	syncNum

int	syncNumTot

edm::ESHandle< DTT0 >	t0Map

int	tdcPedestal

int	timeBoxGranularity

int	tMax
	no needs to be precise. Value from PSets will always be used More...

bool	tpMode

float	tTrig
	tTrig from the DB More...

edm::ESHandle< DTTtrig >	tTrigMap

float	tTrigRMS

std::map< std::string, std::map< int, MonitorElement * > >	wheelHistos

Additional Inherited Members
Public Types inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 47 of file DTDigiTask.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 43 of file DTDigiTask.cc.

References dtDigiTask_cfi::checkNoisyChannels, dt_dqm_sourceclient_common_cff::defaultTmax, dtDigiTask_cfi::doAllHitsOccupancies, dtDigiTask_cfi::doInTimeOccupancies, dtDigiTask_cfi::doLayerTimeBoxes, dtDigiTask_cfi::doNoiseOccupancies, dt_dqm_sourceclient_common_cff::filterSyncNoise, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), dt_dqm_sourceclient_common_cff::inTimeHitsLowerBound, dt_dqm_sourceclient_common_cff::inTimeHitsUpperBound, LogTrace, dt_dqm_sourceclient_common_cff::lookForSyncNoise, dtDigiTask_cfi::maxTTMounts, dtDigiTask_cfi::sliceTestMode, dtDigiTask_cfi::tdcPedestal, and dtDigiTask_cfi::timeBoxGranularity.

                                                 {
   // switch for the verbosity
   LogTrace("DTDQM|DTMonitorModule|DTDigiTask") << "[DTDigiTask]: Constructor" << endl;
 
   // The label to retrieve the digis
   dtDigiToken_ = consumes<DTDigiCollection>(ps.getParameter<InputTag>("dtDigiLabel"));
   // Read the configuration parameters
   maxTDCHits = ps.getUntrackedParameter<int>("maxTDCHitsPerChamber", 30000);
   // Set to true to read the ttrig from DB (useful to determine in-time and out-of-time hits)
   readTTrigDB = ps.getUntrackedParameter<bool>("readDB", false);
   // Set to true to subtract t0 from test pulses
   subtractT0 = ps.getParameter<bool>("performPerWireT0Calibration");
   // Tmax value (TDC counts)
   defaultTmax = ps.getParameter<int>("defaultTmax");
   // Switch from static to dinamic histo booking
   doStaticBooking = ps.getUntrackedParameter<bool>("staticBooking", true);
 
   // Switch for local/global runs
   isLocalRun = ps.getUntrackedParameter<bool>("localrun", true);
   if (!isLocalRun) {
     ltcDigiCollectionToken_ = consumes<LTCDigiCollection>(ps.getParameter<edm::InputTag>("ltcDigiCollectionTag"));
   }
 
   // Setting for the reset of the ME after n (= ResetCycle) luminosity sections
   resetCycle = ps.getUntrackedParameter<int>("ResetCycle", 3);
   // Check the DB of noisy channels
   checkNoisyChannels = ps.getUntrackedParameter<bool>("checkNoisyChannels", false);
   // Default TTrig to be used when not reading the TTrig DB
   defaultTTrig = ps.getParameter<int>("defaultTtrig");
   inTimeHitsLowerBound = ps.getParameter<int>("inTimeHitsLowerBound");
   inTimeHitsUpperBound = ps.getParameter<int>("inTimeHitsUpperBound");
   timeBoxGranularity = ps.getUntrackedParameter<int>("timeBoxGranularity", 4);
   maxTTMounts = ps.getUntrackedParameter<int>("maxTTMounts", 6400);
 
   doAllHitsOccupancies = ps.getUntrackedParameter<bool>("doAllHitsOccupancies", true);
   doNoiseOccupancies = ps.getUntrackedParameter<bool>("doNoiseOccupancies", false);
   doInTimeOccupancies = ps.getUntrackedParameter<bool>("doInTimeOccupancies", false);
 
   // switch on the mode for running on test pulses (different top folder)
   tpMode = ps.getUntrackedParameter<bool>("testPulseMode", false);
   // switch on/off the filtering of synchronous noise events (cutting on the # of digis)
   // time-boxes and occupancy plots are not filled and summary plots are created to report the problem
   filterSyncNoise = ps.getUntrackedParameter<bool>("filterSyncNoise", false);
   // look for synch noisy events, produce histograms but do not filter them
   lookForSyncNoise = ps.getUntrackedParameter<bool>("lookForSyncNoise", false);
 
   // switch on the mode for running on slice test (different top folder and other customizations)
   sliceTestMode = ps.getUntrackedParameter<bool>("sliceTestMode", false);
   // time pedestal to be subtracted if sliceTestMode is true
   tdcPedestal = ps.getUntrackedParameter<int>("tdcPedestal", 105100);
 
   // switch on production of time-boxes with layer granularity
   doLayerTimeBoxes = ps.getUntrackedParameter<bool>("doLayerTimeBoxes", false);
 
   syncNumTot = 0;
   syncNum = 0;
 }

DTDigiTask::~DTDigiTask ( )

override

Destructor.

Definition at line 102 of file DTDigiTask.cc.

References LogTrace, and cmsHarvester::nevents.

                         {
   LogTrace("DTDQM|DTMonitorModule|DTDigiTask") << "DTDigiTask: analyzed " << nevents << " events" << endl;
 }

Member Function Documentation

void DTDigiTask::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

overrideprotected

Analyze.

Definition at line 433 of file DTDigiTask.cc.

References DTStatusFlag::cellStatus(), DTSuperLayerId::chamberId(), dtDigiTask_cfi::checkNoisyChannels, DTTimeUnits::counts, dtDigiTask_cfi::doAllHitsOccupancies, dtDigiTask_cfi::doInTimeOccupancies, dtDigiTask_cfi::doLayerTimeBoxes, dtDigiTask_cfi::doNoiseOccupancies, dt_dqm_sourceclient_common_cff::filterSyncNoise, spr::find(), edm::EventSetup::get(), dtResolutionTest_cfi::histoTag, createfilelist::int, dt_dqm_sourceclient_common_cff::inTimeHitsLowerBound, dt_dqm_sourceclient_common_cff::inTimeHitsUpperBound, dttriganalyzer_cfi::kFactor, LogTrace, dt_dqm_sourceclient_common_cff::lookForSyncNoise, SiStripPI::max, dtDigiTask_cfi::maxTTMounts, min(), cmsHarvester::nevents, DetId::rawId(), edm::second(), DTChamberId::sector(), dtDigiTask_cfi::sliceTestMode, DTChamberId::station(), DTSuperLayerId::superlayer(), FrontierCondition_GT_autoExpress_cfi::t0, dtDigiTask_cfi::tdcPedestal, edm::EventBase::time(), dttriganalyzer_cfi::tTrig, edm::Timestamp::value(), and DTChamberId::wheel().

Referenced by endLuminosityBlock().

                                                                       {
   nevents++;
   nEventMonitor->Fill(nevents);
   if (nevents % 1000 == 0) {
     LogTrace("DTDQM|DTMonitorModule|DTDigiTask")
         << "[DTDigiTask] Analyze #Run: " << event.id().run() << " #Event: " << event.id().event() << endl;
   }
 
   // Get the ingredients from the event
 
   // Digi collection
   edm::Handle<DTDigiCollection> dtdigis;
   event.getByToken(dtDigiToken_, dtdigis);
 
   // LTC digis
   if (!isLocalRun)
     event.getByToken(ltcDigiCollectionToken_, ltcdigis);
 
   // Status map (for noisy channels)
   ESHandle<DTStatusFlag> statusMap;
   if (checkNoisyChannels) {
     // Get the map of noisy channels
     c.get<DTStatusFlagRcd>().get(statusMap);
   }
 
   string histoTag;
 
   // Check if the digi container is empty
   if (dtdigis->begin() == dtdigis->end()) {
     LogTrace("DTDQM|DTMonitorModule|DTDigiTask") << "Event " << nevents << " empty." << endl;
   }
 
   if (lookForSyncNoise || filterSyncNoise) {  // dosync
     // Count the # of digis per chamber
     DTDigiCollection::DigiRangeIterator dtLayerId_It;
     for (dtLayerId_It = dtdigis->begin(); dtLayerId_It != dtdigis->end(); dtLayerId_It++) {
       DTChamberId chId = ((*dtLayerId_It).first).chamberId();
       if (hitMap.find(chId) == hitMap.end()) {  // new chamber
         hitMap[chId] = 0;
       }
       hitMap[chId] += (((*dtLayerId_It).second).second - ((*dtLayerId_It).second).first);
     }
 
     // check chamber with # of digis above threshold and flag them as noisy
     map<DTChamberId, int>::const_iterator hitMapIt = hitMap.begin();
     map<DTChamberId, int>::const_iterator hitMapEnd = hitMap.end();
 
     map<int, int> chMap;
 
     for (; hitMapIt != hitMapEnd; ++hitMapIt) {
       if ((hitMapIt->second) > maxTDCHits) {
         DTChamberId chId = hitMapIt->first;
         int wh = chId.wheel();
 
         LogTrace("DTDQM|DTMonitorModule|DTDigiTask")
             << "[DTDigiTask] Synch noise in chamber: " << chId << " with # digis: " << hitMapIt->second << endl;
 
         if (chMap.find(wh) == chMap.end()) {
           chMap[wh] = 0;
         }
         chMap[wh]++;
 
         syncNoisyChambers.insert(chId);
 
         wheelHistos["SyncNoiseEvents"][wh]->Fill(chId.sector(), chId.station());
       }
     }
 
     // fill # of noisy ch per wheel plot
     map<int, int>::const_iterator chMapIt = chMap.begin();
     map<int, int>::const_iterator chMapEnd = chMap.end();
     for (; chMapIt != chMapEnd; ++chMapIt) {
       wheelHistos["SyncNoiseChambs"][(*chMapIt).first]->Fill((*chMapIt).second);
     }
 
     // clear the map of # of digis per chamber: not needed anymore
     hitMap.clear();
 
     if (!syncNoisyChambers.empty()) {
       LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask") << "[DTDigiTask] Synch Noise in event: " << nevents;
       if (filterSyncNoise)
         LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask")
             << "\tnoisy time-boxes and occupancy will not be filled!" << endl;
       syncNumTot++;
       syncNum++;
     }
 
     // Logging of "large" synch Noisy events in private DQM
     if (syncNoisyChambers.size() > 3) {
       time_t eventTime = time_t(event.time().value() >> 32);
 
       LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask|DTSynchNoise")
           << "[DTDigiTask] At least 4 Synch Noisy chambers in Run : " << event.id().run()
           << " Lumi : " << event.id().luminosityBlock() << " Event : " << event.id().event()
           << " at time : " << ctime(&eventTime) << endl;
 
       set<DTChamberId>::const_iterator chIt = syncNoisyChambers.begin();
       set<DTChamberId>::const_iterator chEnd = syncNoisyChambers.end();
 
       stringstream synchNoisyCh;
       for (; chIt != chEnd; ++chIt) {
         synchNoisyCh << " " << (*chIt);
       }
       LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask|DTSynchNoise")
           << "[DTDigiTask] Chamber List :" << synchNoisyCh.str() << endl;
     }
 
     if (nevents % 1000 == 0) {
       LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask")
           << (syncNumTot * 100. / nevents) << "% sync noise events since the beginning \n"
           << (syncNum * 0.1) << "% sync noise events in the last 1000 events " << endl;
       syncNum = 0;
     }
   }
 
   bool isSyncNoisy = false;
 
   DTDigiCollection::DigiRangeIterator dtLayerId_It;
   for (dtLayerId_It = dtdigis->begin(); dtLayerId_It != dtdigis->end(); ++dtLayerId_It) {  // Loop over layers
     isSyncNoisy = false;
     // check if chamber labeled as synch noisy
     if (filterSyncNoise) {
       DTChamberId chId = ((*dtLayerId_It).first).chamberId();
       if (syncNoisyChambers.find(chId) != syncNoisyChambers.end()) {
         isSyncNoisy = true;
       }
     }
 
     for (DTDigiCollection::const_iterator digiIt = ((*dtLayerId_It).second).first;
          digiIt != ((*dtLayerId_It).second).second;
          ++digiIt) {  // Loop over all digis
 
       bool isNoisy = false;
       bool isFEMasked = false;
       bool isTDCMasked = false;
       bool isTrigMask = false;
       bool isDead = false;
       bool isNohv = false;
       if (checkNoisyChannels) {
         const DTWireId wireId(((*dtLayerId_It).first), (*digiIt).wire());
         statusMap->cellStatus(wireId, isNoisy, isFEMasked, isTDCMasked, isTrigMask, isDead, isNohv);
       }
 
       // Get the useful IDs
       const DTSuperLayerId dtSLId = ((*dtLayerId_It).first).superlayerId();
       uint32_t indexSL = dtSLId.rawId();
       const DTChamberId dtChId = dtSLId.chamberId();
       uint32_t indexCh = dtChId.rawId();
       int layer_number = ((*dtLayerId_It).first).layer();
       int superlayer_number = dtSLId.superlayer();
 
       // Read the ttrig DB or set a rough value from config
       // ttrig and rms are TDC counts
       if (readTTrigDB)
         tTrigMap->get(((*dtLayerId_It).first).superlayerId(), tTrig, tTrigRMS, kFactor, DTTimeUnits::counts);
       else
         tTrig = defaultTTrig;
 
       int inTimeHitsLowerBoundCorr = int(round(tTrig)) - inTimeHitsLowerBound;
       int inTimeHitsUpperBoundCorr = int(round(tTrig)) + tMax + inTimeHitsUpperBound;
 
       float t0;
       float t0RMS;
       int tdcTime = (*digiIt).countsTDC();
 
       if (subtractT0) {
         const DTWireId dtWireId(((*dtLayerId_It).first), (*digiIt).wire());
         // t0s and rms are TDC counts
         t0Map->get(dtWireId, t0, t0RMS, DTTimeUnits::counts);
         tdcTime += int(round(t0));
       }
 
       if (sliceTestMode) {
         tdcTime -= tdcPedestal;
         tdcTime = std::max(1, std::min(maxTTMounts - 1, tdcTime));
         // std::cout << tdcTime << std::endl;
       }
 
       // Fill Time-Boxes
       // NOTE: avoid to fill TB and PhotoPeak with noise. Occupancy are filled anyway
       if ((!isNoisy) && (!isSyncNoisy)) {  // Discard noisy channels
         // TimeBoxes per SL
         histoTag = "TimeBox" + triggerSource();
 
         (digiHistos.find(histoTag)->second).find(indexSL)->second->Fill(tdcTime);
         if (doLayerTimeBoxes)
           (digiHistos.find(histoTag)->second).find((*dtLayerId_It).first.rawId())->second->Fill(tdcTime);
       }
 
       // Fill Occupancies
       if (!isSyncNoisy) {  // Discard synch noisy channels
 
         if (doAllHitsOccupancies) {  // fill occupancies for all hits
           //Occupancies per chamber & layer
           histoTag = "OccupancyAllHits_perCh";
           map<uint32_t, MonitorElement*>::const_iterator mappedHisto = digiHistos[histoTag].find(indexCh);
 
           //FR comment the following cannot pass ibooker to analyze method!
           /*
           if (mappedHisto == digiHistos[histoTag].end()) { // dynamic booking
             bookHistos(ibooker, dtChId, string("Occupancies"), histoTag);
             mappedHisto = digiHistos[histoTag].find(indexCh);
           }
       */
           mappedHisto->second->Fill((*digiIt).wire(), (layer_number + (superlayer_number - 1) * 4) - 1);
 
           // Fill the chamber occupancy
           histoTag = "OccupancyAllHits";
           map<int, MonitorElement*>::const_iterator histoPerWheel = wheelHistos[histoTag].find(dtChId.wheel());
 
           histoPerWheel->second->Fill(dtChId.sector(), dtChId.station());  // FIXME: normalize to # of layers
         }
 
         if (doNoiseOccupancies) {  // fill occupancies for hits before the ttrig
           if (tdcTime < inTimeHitsLowerBoundCorr) {
             // FIXME: what about tdcTime > inTimeHitsUpperBoundCorr ???
 
             // Noise: Before tTrig
             //Occupancies Noise per chamber & layer
             histoTag = "OccupancyNoise_perCh";
             map<uint32_t, MonitorElement*>::const_iterator mappedHisto = digiHistos[histoTag].find(indexCh);
 
             mappedHisto->second->Fill((*digiIt).wire(), (layer_number + (superlayer_number - 1) * 4) - 1);
 
             // Fill the chamber occupancy
 
             histoTag = "OccupancyNoise";
             map<int, MonitorElement*>::const_iterator histoPerWheel = wheelHistos[histoTag].find(dtChId.wheel());
 
             histoPerWheel->second->Fill(dtChId.sector(), dtChId.station());  // FIXME: normalize to # of layers
           }
         }
 
         if (doInTimeOccupancies) {  // fill occpunacies for in-time hits only
           if (tdcTime > inTimeHitsLowerBoundCorr && tdcTime < inTimeHitsUpperBoundCorr) {
             // Physical hits: within the time window
 
             //Occupancies Signal per chamber & layer
             histoTag = "OccupancyInTimeHits_perCh";
             map<uint32_t, MonitorElement*>::const_iterator mappedHisto = digiHistos[histoTag].find(indexCh);
 
             mappedHisto->second->Fill((*digiIt).wire(), (layer_number + (superlayer_number - 1) * 4) - 1);
 
             // Fill the chamber occupancy
             histoTag = "OccupancyInTimeHits";
             map<int, MonitorElement*>::const_iterator histoPerWheel = wheelHistos[histoTag].find(dtChId.wheel());
 
             histoPerWheel->second->Fill(dtChId.sector(), dtChId.station());  // FIXME: normalize to # of layers
           }
         }
       }
     }
   }
 
   syncNoisyChambers.clear();
 }

void DTDigiTask::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumiSeg,
		edm::EventSetup const &	context
	)

overrideprotected

To reset the MEs.

Definition at line 185 of file DTDigiTask.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), bookHistos(), DTTimeUnits::counts, dt_dqm_sourceclient_common_cff::defaultTmax, dtDigiTask_cfi::doLayerTimeBoxes, printsummarytable::folder, HltBtagPostValidation_cff::histoName, dtResolutionTest_cfi::histoTag, mps_fire::i, edm::LuminosityBlockBase::id(), createfilelist::int, dt_dqm_sourceclient_common_cff::inTimeHitsLowerBound, dt_dqm_sourceclient_common_cff::inTimeHitsUpperBound, dttriganalyzer_cfi::kFactor, label, LogTrace, edm::LuminosityBlockID::luminosityBlock(), dtDigiTask_cfi::maxTTMounts, DetId::rawId(), DTChamberId::sector(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), DTChamber::superLayers(), dtDigiTask_cfi::timeBoxGranularity, overlapproblemtsosanalyzer_cfi::title, dttriganalyzer_cfi::tTrig, DTChamberId::wheel(), and makeMuonMisalignmentScenario::wheel.

                                                                                                {
   LogTrace("DTDQM|DTMonitorModule|DTDigiTask") << "[DTDigiTask]: Begin of LS transition" << endl;
 
   // Reset the MonitorElements every n (= ResetCycle) Lumi Blocks
   int lumiBlock = lumiSeg.id().luminosityBlock();
   if (lumiBlock % resetCycle == 0) {
     LogVerbatim("DTDQM|DTMonitorModule|DTDigiTask")
         << "[DTDigiTask]: Reset at the LS transition : " << lumiBlock << endl;
     // Loop over all ME
     map<string, map<uint32_t, MonitorElement*> >::const_iterator histosIt = digiHistos.begin();
     map<string, map<uint32_t, MonitorElement*> >::const_iterator histosEnd = digiHistos.end();
     for (; histosIt != histosEnd; ++histosIt) {
       map<uint32_t, MonitorElement*>::const_iterator histoIt = (*histosIt).second.begin();
       map<uint32_t, MonitorElement*>::const_iterator histoEnd = (*histosIt).second.end();
       for (; histoIt != histoEnd; ++histoIt) {
         (*histoIt).second->Reset();
       }
     }
 
     // re-set mapping for not real channels in the occupancyHits per chamber
     for (int wh = -2; wh <= 2; wh++) {
       for (int sect = 1; sect <= 14; sect++) {
         for (int st = 1; st <= 4; st++) {
           if ((sect == 13 || sect == 14) && st != 4) {
             continue;
           }
           const DTChamberId dtChId(wh, st, sect);
           channelsMap(dtChId, "OccupancyAllHits_perCh");
         }
       }
     }
 
     // loop over wheel summaries
     map<string, map<int, MonitorElement*> >::const_iterator whHistosIt = wheelHistos.begin();
     map<string, map<int, MonitorElement*> >::const_iterator whHistosEnd = wheelHistos.end();
     for (; whHistosIt != whHistosEnd; ++whHistosIt) {
       if ((*whHistosIt).first.find("Sync") == string::npos) {  // FIXME skips synch noise plots
         map<int, MonitorElement*>::const_iterator histoIt = (*whHistosIt).second.begin();
         map<int, MonitorElement*>::const_iterator histoEnd = (*whHistosIt).second.end();
         for (; histoIt != histoEnd; ++histoIt) {
           (*histoIt).second->Reset();
         }
       }
     }
   }
 }

void DTDigiTask::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	run,
		edm::EventSetup const &	context
	)

overrideprotectedvirtual

Implements DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >.

Definition at line 128 of file DTDigiTask.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::bookFloat(), bookHistos(), dtDigiTask_cfi::doAllHitsOccupancies, dtDigiTask_cfi::doInTimeOccupancies, dtDigiTask_cfi::doNoiseOccupancies, dt_dqm_sourceclient_common_cff::filterSyncNoise, dt_dqm_sourceclient_common_cff::lookForSyncNoise, and dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder().

                                                                                                          {
   if (doStaticBooking) {  // Static histo booking
     // book the event counter
     ibooker.setCurrentFolder("DT/EventInfo/Counters");
     nEventMonitor = ibooker.bookFloat(tpMode ? "nProcessedEventsDigiTP" : "nProcessedEventsDigi");
     ibooker.setCurrentFolder(topFolder());
     for (int wh = -2; wh <= 2; ++wh) {  // loop over wheels
       if (doAllHitsOccupancies)
         bookHistos(ibooker, wh, string("Occupancies"), "OccupancyAllHits");
 
       if (doNoiseOccupancies)
         bookHistos(ibooker, wh, string("Occupancies"), "OccupancyNoise");
       if (doInTimeOccupancies)
         bookHistos(ibooker, wh, string("Occupancies"), "OccupancyInTimeHits");
 
       if (lookForSyncNoise || filterSyncNoise) {
         bookHistos(ibooker, wh, string("SynchNoise"), "SyncNoiseEvents");
         bookHistos(ibooker, wh, string("SynchNoise"), "SyncNoiseChambs");
       }
 
       for (int st = 1; st <= 4; ++st) {           // loop over stations
         for (int sect = 1; sect <= 14; ++sect) {  // loop over sectors
           if ((sect == 13 || sect == 14) && st != 4)
             continue;
           // Get the chamber ID
           const DTChamberId dtChId(wh, st, sect);
 
           // Occupancies
           if (doAllHitsOccupancies) {
             bookHistos(ibooker, dtChId, string("Occupancies"), "OccupancyAllHits_perCh");
             // set channel mapping
             channelsMap(dtChId, "OccupancyAllHits_perCh");
           }
           if (doNoiseOccupancies)
             bookHistos(ibooker, dtChId, string("Occupancies"), "OccupancyNoise_perCh");
           if (doInTimeOccupancies)
             bookHistos(ibooker, dtChId, string("Occupancies"), "OccupancyInTimeHits_perCh");
 
           for (int sl = 1; sl <= 3; ++sl) {  // Loop over SLs
             if (st == 4 && sl == 2)
               continue;
             const DTSuperLayerId dtSLId(wh, st, sect, sl);
             if (isLocalRun) {
               bookHistos(ibooker, dtSLId, string("TimeBoxes"), "TimeBox");
             } else {
               // TimeBoxes for different triggers
               bookHistos(ibooker, dtSLId, string("TimeBoxes"), "TimeBoxDTonly");
               bookHistos(ibooker, dtSLId, string("TimeBoxes"), "TimeBoxNoDT");
               bookHistos(ibooker, dtSLId, string("TimeBoxes"), "TimeBoxDTalso");
             }
           }
         }
       }
     }
   }
 }

void DTDigiTask::bookHistos	(	DQMStore::IBooker &	ibooker,
		const DTSuperLayerId &	dtSL,
		std::string	folder,
		std::string	histoTag
	)

protected

Book the ME.

Referenced by beginLuminosityBlock().

void DTDigiTask::bookHistos	(	DQMStore::IBooker &	ibooker,
		const DTChamberId &	dtCh,
		std::string	folder,
		std::string	histoTag
	)

protected

void DTDigiTask::bookHistos	(	DQMStore::IBooker &	ibooker,
		const int	wheelId,
		std::string	folder,
		std::string	histoTag
	)

protected

void DTDigiTask::channelsMap	(	const DTChamberId &	dtCh,
		std::string	histoTag
	)

protected

To map real channels.

Definition at line 719 of file DTDigiTask.cc.

References dtResolutionTest_cfi::histoTag, taus_updatedMVAIds_cff::mapping, DetId::rawId(), DTChamberId::sector(), DTChamberId::station(), and DTChamberId::wheel().

Referenced by endLuminosityBlock().

                                                                      {
   // n max channels
   int nWires_max = (digiHistos[histoTag])[dtCh.rawId()]->getNbinsX();
 
   // set bin content = -1 for each not real channel. For visualization purposes
   for (int sl = 1; sl <= 3; sl++) {
     for (int ly = 1; ly <= 4; ly++) {
       for (int ch = 1; ch <= nWires_max; ch++) {
         int dduId = -1, rosId = -1, robId = -1, tdcId = -1, channelId = -1;
         int realCh = mapping->geometryToReadOut(
             dtCh.wheel(), dtCh.station(), dtCh.sector(), sl, ly, ch, dduId, rosId, robId, tdcId, channelId);
 
         // realCh = 0 if the channel exists, while realCh = 1 if it does not exist
         if (realCh) {
           int lybin = (4 * sl - 4) + ly;
           (digiHistos[histoTag])[dtCh.rawId()]->setBinContent(ch, lybin, -1.);
         }
       }
     }
   }
 }

void DTDigiTask::dqmBeginRun	(	const edm::Run &	run,
		const edm::EventSetup &	context
	)

overrideprotected

Definition at line 106 of file DTDigiTask.cc.

References dt_dqm_sourceclient_common_cff::defaultTmax, edm::EventSetup::get(), LogTrace, taus_updatedMVAIds_cff::mapping, and cmsHarvester::nevents.

                                                                             {
   LogTrace("DTDQM|DTMonitorModule|DTDigiTask") << "[DTDigiTask]: begin run" << endl;
   nevents = 0;
 
   // Get the geometry
   context.get<MuonGeometryRecord>().get(muonGeom);
 
   // map of the channels
   context.get<DTReadOutMappingRcd>().get(mapping);
 
   // tTrig
   if (readTTrigDB)
     context.get<DTTtrigRcd>().get(tTrigMap);
   // t0s
   if (subtractT0)
     context.get<DTT0Rcd>().get(t0Map);
   // FIXME: tMax (not yet from the DB)
   tMax = defaultTmax;
 
   // ----------------------------------------------------------------------
 }

void DTDigiTask::endLuminosityBlock	(	edm::LuminosityBlock const &	lumiSeg,
		edm::EventSetup const &	context
	)

inlinefinalprotected

Definition at line 68 of file DTDigiTask.h.

References analyze(), HltBtagPostValidation_cff::c, channelsMap(), MillePedeFileConverter_cfg::e, AlCaHLTBitMon_QueryRunRegistry::string, topFolder(), and triggerSource().

68 {}

string DTDigiTask::topFolder ( ) const

private

Definition at line 711 of file DTDigiTask.cc.

References dtDigiTask_cfi::sliceTestMode, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by endLuminosityBlock().

                                    {
   if (tpMode)
     return string("DT/10-TestPulses/");
   else if (sliceTestMode)
     return string("DT/01-SliceTestDigi/");
   return string("DT/01-Digi/");
 }

string DTDigiTask::triggerSource ( )

protected

get the L1A source

Definition at line 690 of file DTDigiTask.cc.

References mps_fire::i.

Referenced by endLuminosityBlock().

                                  {
   string l1ASource;
   if (isLocalRun)
     return l1ASource;
 
   for (std::vector<LTCDigi>::const_iterator ltc_it = ltcdigis->begin(); ltc_it != ltcdigis->end(); ltc_it++) {
     size_t otherTriggerSum = 0;
     for (size_t i = 1; i < 6; i++)
       otherTriggerSum += size_t((*ltc_it).HasTriggered(i));
 
     if ((*ltc_it).HasTriggered(0) && otherTriggerSum == 0)
       l1ASource = "DTonly";
     else if (!(*ltc_it).HasTriggered(0))
       l1ASource = "NoDT";
     else if ((*ltc_it).HasTriggered(0) && otherTriggerSum > 0)
       l1ASource = "DTalso";
   }
 
   return l1ASource;
 }

Member Data Documentation

bool DTDigiTask::checkNoisyChannels

private

Definition at line 132 of file DTDigiTask.h.

int DTDigiTask::defaultTmax

private

Definition at line 123 of file DTDigiTask.h.

int DTDigiTask::defaultTTrig

private

Definition at line 134 of file DTDigiTask.h.

std::map<std::string, std::map<uint32_t, MonitorElement*> > DTDigiTask::digiHistos

private

Definition at line 108 of file DTDigiTask.h.

bool DTDigiTask::doAllHitsOccupancies

private

Definition at line 140 of file DTDigiTask.h.

bool DTDigiTask::doInTimeOccupancies

private

Definition at line 142 of file DTDigiTask.h.

bool DTDigiTask::doLayerTimeBoxes

private

Definition at line 151 of file DTDigiTask.h.

bool DTDigiTask::doNoiseOccupancies

private

Definition at line 141 of file DTDigiTask.h.

bool DTDigiTask::doStaticBooking

private

Definition at line 126 of file DTDigiTask.h.

edm::EDGetTokenT<DTDigiCollection> DTDigiTask::dtDigiToken_

private

Definition at line 114 of file DTDigiTask.h.

bool DTDigiTask::filterSyncNoise

private

Definition at line 146 of file DTDigiTask.h.

std::map<DTChamberId, int> DTDigiTask::hitMap

private

Definition at line 95 of file DTDigiTask.h.

int DTDigiTask::inTimeHitsLowerBound

private

Definition at line 136 of file DTDigiTask.h.

int DTDigiTask::inTimeHitsUpperBound

private

Definition at line 137 of file DTDigiTask.h.

bool DTDigiTask::isLocalRun

private

Definition at line 128 of file DTDigiTask.h.

float DTDigiTask::kFactor

private

Definition at line 91 of file DTDigiTask.h.

bool DTDigiTask::lookForSyncNoise

private

Definition at line 145 of file DTDigiTask.h.

edm::EDGetTokenT<LTCDigiCollection> DTDigiTask::ltcDigiCollectionToken_

private

Definition at line 116 of file DTDigiTask.h.

edm::Handle<LTCDigiCollection> DTDigiTask::ltcdigis

private

Definition at line 100 of file DTDigiTask.h.

edm::ESHandle<DTReadOutMapping> DTDigiTask::mapping

private

Definition at line 103 of file DTDigiTask.h.

int DTDigiTask::maxTDCHits

private

Definition at line 86 of file DTDigiTask.h.

int DTDigiTask::maxTTMounts

private

Definition at line 139 of file DTDigiTask.h.

edm::ESHandle<DTGeometry> DTDigiTask::muonGeom

private

Definition at line 102 of file DTDigiTask.h.

MonitorElement* DTDigiTask::nEventMonitor

private

Definition at line 154 of file DTDigiTask.h.

int DTDigiTask::nevents

private

Definition at line 82 of file DTDigiTask.h.

std::map<DTChamberId, int> DTDigiTask::nSynchNoiseEvents

private

Definition at line 153 of file DTDigiTask.h.

bool DTDigiTask::readTTrigDB

private

Definition at line 119 of file DTDigiTask.h.

int DTDigiTask::resetCycle

private

Definition at line 130 of file DTDigiTask.h.

bool DTDigiTask::sliceTestMode

private

Definition at line 148 of file DTDigiTask.h.

bool DTDigiTask::subtractT0

private

Definition at line 121 of file DTDigiTask.h.

std::set<DTChamberId> DTDigiTask::syncNoisyChambers

private

Definition at line 96 of file DTDigiTask.h.

int DTDigiTask::syncNum

private

Definition at line 98 of file DTDigiTask.h.

int DTDigiTask::syncNumTot

private

Definition at line 97 of file DTDigiTask.h.

edm::ESHandle<DTT0> DTDigiTask::t0Map

private

Definition at line 106 of file DTDigiTask.h.

int DTDigiTask::tdcPedestal

private

Definition at line 149 of file DTDigiTask.h.

int DTDigiTask::timeBoxGranularity

private

Definition at line 138 of file DTDigiTask.h.

int DTDigiTask::tMax

private

no needs to be precise. Value from PSets will always be used

Definition at line 85 of file DTDigiTask.h.

bool DTDigiTask::tpMode

private

Definition at line 144 of file DTDigiTask.h.

float DTDigiTask::tTrig

private

tTrig from the DB

Definition at line 89 of file DTDigiTask.h.

edm::ESHandle<DTTtrig> DTDigiTask::tTrigMap

private

Definition at line 105 of file DTDigiTask.h.

float DTDigiTask::tTrigRMS

private

Definition at line 90 of file DTDigiTask.h.

std::map<std::string, std::map<int, MonitorElement*> > DTDigiTask::wheelHistos

private

Definition at line 109 of file DTDigiTask.h.

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation