#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 DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

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

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

	~EDAnalyzerBase () 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

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 (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 (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &setup) override

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

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 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	subtractT0

std::set< DTChamberId >	syncNoisyChambers

int	syncNum

int	syncNumTot

edm::ESHandle< DTT0 >	t0Map

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 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 52 of file DTDigiTask.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 46 of file DTDigiTask.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and LogTrace.

                                                {
   // 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 production of time-boxes with layer granularity
   doLayerTimeBoxes = ps.getUntrackedParameter<bool>("doLayerTimeBoxes", false);
 
   syncNumTot = 0;
   syncNum = 0;
 
 }

DTDigiTask::~DTDigiTask ( )

override

Destructor.

Definition at line 104 of file DTDigiTask.cc.

References LogTrace.

                        {
   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 449 of file DTDigiTask.cc.

References DTStatusFlag::cellStatus(), DTSuperLayerId::chamberId(), DTTimeUnits::counts, spr::find(), edm::EventSetup::get(), createfilelist::int, DTAnalyzerDetailed_cfi::kFactor, LogTrace, DetId::rawId(), edm::second(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superlayer(), cscNeutronWriter_cfi::t0, edm::EventBase::time(), edm::Timestamp::value(), and DTChamberId::wheel().

                                                                       {
   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));
       }
 
 
 
       // 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
	)

overrideprotectedvirtual

To reset the MEs.

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 187 of file DTDigiTask.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), bookHistos(), DTTimeUnits::counts, printsummarytable::folder, mps_fire::i, edm::LuminosityBlockBase::id(), createfilelist::int, DTAnalyzerDetailed_cfi::kFactor, diffTwoXMLs::label, LogTrace, edm::LuminosityBlockID::luminosityBlock(), DetId::rawId(), DTChamberId::sector(), DQMStore::IBooker::setCurrentFolder(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), DTChamber::superLayers(), fftjetcommon_cfi::title, 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 DQMEDAnalyzer.

Definition at line 133 of file DTDigiTask.cc.

References DQMStore::IBooker::bookFloat(), bookHistos(), and 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 746 of file DTDigiTask.cc.

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

                                                                      {
 
       // 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 110 of file DTDigiTask.cc.

References edm::EventSetup::get(), LogTrace, and taus_updatedMVAIds_cff::mapping.

                                                                             {
 
  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	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	setup
	)

overrideprotected

Definition at line 742 of file DTDigiTask.cc.

                                                                                                  {
 
 }

string DTDigiTask::topFolder ( ) const

private

Definition at line 732 of file DTDigiTask.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

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

string DTDigiTask::triggerSource ( )

protected

get the L1A source

Definition at line 708 of file DTDigiTask.cc.

References mps_fire::i.

                                  {
 
   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 143 of file DTDigiTask.h.

int DTDigiTask::defaultTmax

private

Definition at line 134 of file DTDigiTask.h.

int DTDigiTask::defaultTTrig

private

Definition at line 145 of file DTDigiTask.h.

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

private

Definition at line 119 of file DTDigiTask.h.

bool DTDigiTask::doAllHitsOccupancies

private

Definition at line 151 of file DTDigiTask.h.

bool DTDigiTask::doInTimeOccupancies

private

Definition at line 153 of file DTDigiTask.h.

bool DTDigiTask::doLayerTimeBoxes

private

Definition at line 159 of file DTDigiTask.h.

bool DTDigiTask::doNoiseOccupancies

private

Definition at line 152 of file DTDigiTask.h.

bool DTDigiTask::doStaticBooking

private

Definition at line 137 of file DTDigiTask.h.

edm::EDGetTokenT<DTDigiCollection> DTDigiTask::dtDigiToken_

private

Definition at line 125 of file DTDigiTask.h.

bool DTDigiTask::filterSyncNoise

private

Definition at line 157 of file DTDigiTask.h.

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

private

Definition at line 106 of file DTDigiTask.h.

int DTDigiTask::inTimeHitsLowerBound

private

Definition at line 147 of file DTDigiTask.h.

int DTDigiTask::inTimeHitsUpperBound

private

Definition at line 148 of file DTDigiTask.h.

bool DTDigiTask::isLocalRun

private

Definition at line 139 of file DTDigiTask.h.

float DTDigiTask::kFactor

private

Definition at line 102 of file DTDigiTask.h.

bool DTDigiTask::lookForSyncNoise

private

Definition at line 156 of file DTDigiTask.h.

edm::EDGetTokenT<LTCDigiCollection> DTDigiTask::ltcDigiCollectionToken_

private

Definition at line 127 of file DTDigiTask.h.

edm::Handle<LTCDigiCollection> DTDigiTask::ltcdigis

private

Definition at line 111 of file DTDigiTask.h.

edm::ESHandle<DTReadOutMapping> DTDigiTask::mapping

private

Definition at line 114 of file DTDigiTask.h.

int DTDigiTask::maxTDCHits

private

Definition at line 97 of file DTDigiTask.h.

int DTDigiTask::maxTTMounts

private

Definition at line 150 of file DTDigiTask.h.

edm::ESHandle<DTGeometry> DTDigiTask::muonGeom

private

Definition at line 113 of file DTDigiTask.h.

MonitorElement* DTDigiTask::nEventMonitor

private

Definition at line 162 of file DTDigiTask.h.

int DTDigiTask::nevents

private

Definition at line 93 of file DTDigiTask.h.

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

private

Definition at line 161 of file DTDigiTask.h.

bool DTDigiTask::readTTrigDB

private

Definition at line 130 of file DTDigiTask.h.

int DTDigiTask::resetCycle

private

Definition at line 141 of file DTDigiTask.h.

bool DTDigiTask::subtractT0

private

Definition at line 132 of file DTDigiTask.h.

std::set<DTChamberId> DTDigiTask::syncNoisyChambers

private

Definition at line 107 of file DTDigiTask.h.

int DTDigiTask::syncNum

private

Definition at line 109 of file DTDigiTask.h.

int DTDigiTask::syncNumTot

private

Definition at line 108 of file DTDigiTask.h.

edm::ESHandle<DTT0> DTDigiTask::t0Map

private

Definition at line 117 of file DTDigiTask.h.

int DTDigiTask::timeBoxGranularity

private

Definition at line 149 of file DTDigiTask.h.

int DTDigiTask::tMax

private

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

Definition at line 96 of file DTDigiTask.h.

bool DTDigiTask::tpMode

private

Definition at line 155 of file DTDigiTask.h.

float DTDigiTask::tTrig

private

tTrig from the DB

Definition at line 100 of file DTDigiTask.h.

edm::ESHandle<DTTtrig> DTDigiTask::tTrigMap

private

Definition at line 116 of file DTDigiTask.h.

float DTDigiTask::tTrigRMS

private

Definition at line 101 of file DTDigiTask.h.

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

private

Definition at line 120 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