DTDigiTask Class Reference

#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 one::DQMEDAnalyzer< edm::one::WatchLuminosityBlocks >
	DQMEDAnalyzer ()=default
	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete
	~DQMEDAnalyzer () override=default

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

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

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

References DTStatusFlag::cellStatus(), DTSuperLayerId::chamberId(), DTTimeUnits::counts, spr::find(), edm::EventSetup::get(), createfilelist::int, DTAnalyzerDetailed_cfi::kFactor, LogTrace, SiStripPI::max, min(), DetId::rawId(), edm::second(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superlayer(), genVertex_cff::t0, edm::EventBase::time(), 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 193 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, label, LogTrace, edm::LuminosityBlockID::luminosityBlock(), DetId::rawId(), DTChamberId::sector(), DQMStore::IBooker::setCurrentFolder(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), DTChamber::superLayers(), runGCPTkAlMap::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  )

overrideprotected

Definition at line 139 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 755 of file DTDigiTask.cc.

References 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 116 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 ( edm::LuminosityBlock const &  lumiSeg, edm::EventSetup const &  context  )

inlinefinalprotected

Definition at line 77 of file DTDigiTask.h.

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

{}

string DTDigiTask::topFolder ( ) const

private

Definition at line 743 of file DTDigiTask.cc.

References 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 719 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 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 162 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 165 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 164 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::sliceTestMode

private

Definition at line 159 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::tdcPedestal

private

Definition at line 160 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.