#include <DTNoiseCalibration.h>

Inheritance diagram for DTNoiseCalibration:

Classes
class	DTNoiseCalibration

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c)

void	beginJob ()

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

	DTNoiseCalibration (const edm::ParameterSet &ps)
	Constructor. More...

void	endJob ()

virtual	~DTNoiseCalibration ()
	Destructor. More...

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
std::string	getChamberName (const DTChamberId &) const

std::string	getChannelName (const DTWireId &) const

std::string	getLayerName (const DTLayerId &) const

std::string	getSuperLayerName (const DTSuperLayerId &) const

Private Attributes
std::map< DTChamberId, TH1F * >	chamberOccupancyVsLumiMap_

std::map< DTChamberId, TH1F * >	chamberOccupancyVsTimeMap_

std::string	dbLabel_

int	defaultTtrig_

edm::InputTag	digiLabel_

edm::ESHandle< DTGeometry >	dtGeom_

TH1F *	hTDCTriggerWidth_

unsigned int	lumiMax_

double	maximumNoiseRate_

int	nevents_

bool	readDB_

TFile *	rootFile_

time_t	runBeginTime_

time_t	runEndTime_

std::map< DTLayerId, TH1F * >	theHistoOccupancyMap_

std::map< DTWireId, TH1F * >	theHistoOccupancyVsLumiMap_

int	timeWindowOffset_

double	triggerWidth_

edm::ESHandle< DTTtrig >	tTrigMap_

bool	useAbsoluteRate_

bool	useTimeWindow_

std::vector< DTWireId >	wireIdWithHisto_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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)

Detailed Description

Definition at line 31 of file DTNoiseCalibration.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 42 of file DTNoiseCalibration.cc.

References defaultTtrig_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), readDB_, rootFile_, dtT0Analyzer_cfg::rootFileName, relativeConstraints::station, and wireIdWithHisto_.

                                                                  :
   digiLabel_( pset.getParameter<InputTag>("digiLabel") ),
   useTimeWindow_( pset.getParameter<bool>("useTimeWindow") ),
   triggerWidth_( pset.getParameter<double>("triggerWidth") ),
   timeWindowOffset_( pset.getParameter<int>("timeWindowOffset") ),
   maximumNoiseRate_( pset.getParameter<double>("maximumNoiseRate") ),
   useAbsoluteRate_( pset.getParameter<bool>("useAbsoluteRate") ), 
   readDB_(true), defaultTtrig_(0), 
   dbLabel_( pset.getUntrackedParameter<string>("dbLabel", "") ),
   //fastAnalysis_( pset.getParameter<bool>("fastAnalysis", true) ),
   wireIdWithHisto_( std::vector<DTWireId>() ),
   lumiMax_(3000)
   {
 
   // Get the debug parameter for verbose output
   //debug = ps.getUntrackedParameter<bool>("debug");
   /*// The analysis type
   // The wheel & sector interested for the time-dependent analysis
   wh = ps.getUntrackedParameter<int>("wheel", 0);
   sect = ps.getUntrackedParameter<int>("sector", 6);*/
 
   if( pset.exists("defaultTtrig") ){
      readDB_ = false;
      defaultTtrig_ = pset.getParameter<int>("defaultTtrig");
   }
 
   if( pset.exists("cellsWithHisto") ){
      vector<string> cellsWithHisto = pset.getParameter<vector<string> >("cellsWithHisto");
      for(vector<string>::const_iterator cell = cellsWithHisto.begin(); cell != cellsWithHisto.end(); ++cell){
         //FIXME: Use regex to check whether format is right
         if( (*cell) != "" && (*cell) != "None"){
            stringstream linestr;
            int wheel,station,sector,sl,layer,wire;
            linestr << (*cell);
            linestr >> wheel >> station >> sector >> sl >> layer >> wire;
            wireIdWithHisto_.push_back(DTWireId(wheel,station,sector,sl,layer,wire));
         }
      }
   }
 
   // The root file which will contain the histos
   string rootFileName = pset.getUntrackedParameter<string>("rootFileName","noise.root");
   rootFile_ = new TFile(rootFileName.c_str(), "RECREATE");
   rootFile_->cd();
 }

DTNoiseCalibration::~DTNoiseCalibration ( )

virtual

Destructor.

Definition at line 416 of file DTNoiseCalibration.cc.

                                        {
   rootFile_->Close();
 }

Member Function Documentation

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

virtual

Implements edm::EDAnalyzer.

Definition at line 118 of file DTNoiseCalibration.cc.

References DTSuperLayerId::chamberId(), DTTimeUnits::counts, edm::hlt::Exception, spr::find(), DTTopology::firstChannel(), hltbtagharvestinganalyzer_cfi::histoName, relval_steps::k, DTTopology::lastChannel(), LogTrace, edm::second(), ntuplemaker::status, edm::EventBase::time(), and edm::Timestamp::value().

                                                                                  {
   ++nevents_;
   
   // Get the digis from the event
   Handle<DTDigiCollection> dtdigis;
   event.getByLabel(digiLabel_, dtdigis);
 
   /*TH1F *hOccupancyHisto;
   TH2F *hEvtPerWireH;
   string Histo2Name;*/
 
   //RunNumber_t runNumber = event.id().run(); 
   time_t eventTime = time_t(event.time().value()>>32);
   unsigned int lumiSection = event.luminosityBlock();
 
   // Loop over digis
   DTDigiCollection::DigiRangeIterator dtLayerId_It;
   for (dtLayerId_It=dtdigis->begin(); dtLayerId_It!=dtdigis->end(); ++dtLayerId_It){
      // Define time window
      float upperLimit = 0.;
      if(useTimeWindow_){
         if( readDB_ ){
            float tTrig,tTrigRMS,kFactor;
            DTSuperLayerId slId = ((*dtLayerId_It).first).superlayerId();
            int status = tTrigMap_->get( slId, tTrig, tTrigRMS, kFactor, DTTimeUnits::counts );
            if(status != 0) throw cms::Exception("DTNoiseCalibration") << "Could not find tTrig entry in DB for" << slId << endl;
            upperLimit = tTrig - timeWindowOffset_;
         } else {
            upperLimit = defaultTtrig_ - timeWindowOffset_;
         }
      }
 
      double triggerWidth_s = 0.;
      if(useTimeWindow_) triggerWidth_s = ( (upperLimit*25)/32 )/1e9;
      else               triggerWidth_s = double(triggerWidth_/1e9);
      LogTrace("Calibration") << ((*dtLayerId_It).first).superlayerId() << " Trigger width (s): " << triggerWidth_s;
 
      for (DTDigiCollection::const_iterator digiIt = ((*dtLayerId_It).second).first;
      digiIt!=((*dtLayerId_It).second).second; ++digiIt){
 
         //Check the TDC trigger width
         int tdcTime = (*digiIt).countsTDC();
         if( !useTimeWindow_ ){
        if( ( ((float)tdcTime*25)/32 ) > triggerWidth_ ){
               LogError("Calibration") << "Digi has a TDC time (ns) higher than the pre-defined TDC trigger width: " << ((float)tdcTime*25)/32;
               continue;
            }
         }   
 
         hTDCTriggerWidth_->Fill(tdcTime);
 
         if( useTimeWindow_ && tdcTime > upperLimit) continue;
 
         /*LogTrace("Calibration") << "TDC time (ns): " << ((float)tdcTime*25)/32
                                 <<" --- trigger width (ns): " << ((float)upperLimit*25)/32;*/
 
         const DTLayerId dtLId = (*dtLayerId_It).first;
         const DTTopology& dtTopo = dtGeom_->layer(dtLId)->specificTopology();
         const int firstWire = dtTopo.firstChannel();
         const int lastWire = dtTopo.lastChannel();
         //const int nWires = dtTopo.channels();
         const int nWires = lastWire - firstWire + 1;
 
         // Book the occupancy histos
         if( theHistoOccupancyMap_.find(dtLId) == theHistoOccupancyMap_.end() ){
            string histoName = "DigiOccupancy_" + getLayerName(dtLId);
        rootFile_->cd();
        TH1F* hOccupancyHisto = new TH1F(histoName.c_str(), histoName.c_str(), nWires, firstWire, lastWire+1);
        LogTrace("Calibration") << "  Created occupancy Histo: " << hOccupancyHisto->GetName();
        theHistoOccupancyMap_[dtLId] = hOccupancyHisto;
         }
         theHistoOccupancyMap_[dtLId]->Fill( (*digiIt).wire(), 1./triggerWidth_s );
 
         // Histos vs lumi section
         const DTChamberId dtChId = dtLId.chamberId();
         if( chamberOccupancyVsLumiMap_.find(dtChId) == chamberOccupancyVsLumiMap_.end() ){
            string histoName = "OccupancyVsLumi_" + getChamberName(dtChId);
            rootFile_->cd();
            TH1F* hOccupancyVsLumiHisto = new TH1F(histoName.c_str(), histoName.c_str(), lumiMax_, 0, lumiMax_);
            LogTrace("Calibration") << "  Created occupancy histo: " << hOccupancyVsLumiHisto->GetName();
            chamberOccupancyVsLumiMap_[dtChId] = hOccupancyVsLumiHisto;
         }
         chamberOccupancyVsLumiMap_[dtChId]->Fill( lumiSection, 1./triggerWidth_s );
 
         const DTWireId wireId(dtLId, (*digiIt).wire());
         if( find(wireIdWithHisto_.begin(),wireIdWithHisto_.end(),wireId) != wireIdWithHisto_.end() ){
            if( theHistoOccupancyVsLumiMap_.find(wireId) == theHistoOccupancyVsLumiMap_.end() ){
               string histoName = "OccupancyVsLumi_" + getChannelName(wireId);
               rootFile_->cd();
               TH1F* hOccupancyVsLumiHisto = new TH1F(histoName.c_str(), histoName.c_str(), lumiMax_, 0, lumiMax_);
               LogTrace("Calibration") << "  Created occupancy histo: " << hOccupancyVsLumiHisto->GetName();
               theHistoOccupancyVsLumiMap_[wireId] = hOccupancyVsLumiHisto;
            }
            theHistoOccupancyVsLumiMap_[wireId]->Fill( lumiSection, 1./triggerWidth_s );
         }
 
         // Histos vs time
         if( chamberOccupancyVsTimeMap_.find(dtChId) == chamberOccupancyVsTimeMap_.end() ){
            string histoName = "OccupancyVsTime_" + getChamberName(dtChId);
            float secPerBin = 20.0; 
            unsigned int nBins = ( (unsigned int)(runEndTime_ - runBeginTime_) )/secPerBin;
            rootFile_->cd(); 
            TH1F* hOccupancyVsTimeHisto = new TH1F(histoName.c_str(), histoName.c_str(),
                                                                      nBins, (unsigned int)runBeginTime_,
                                                                             (unsigned int)runEndTime_);
            for(int k = 0; k < hOccupancyVsTimeHisto->GetNbinsX(); ++k){
               if( k%10 == 0 ){
                  unsigned int binLowEdge = hOccupancyVsTimeHisto->GetBinLowEdge(k+1);
                  time_t timeValue = time_t(binLowEdge); 
                  hOccupancyVsTimeHisto->GetXaxis()->SetBinLabel( (k+1),ctime(&timeValue) );
               }
            }
            size_t lastBin = hOccupancyVsTimeHisto->GetNbinsX();
            unsigned int binUpperEdge = hOccupancyVsTimeHisto->GetBinLowEdge(lastBin) +
                                        hOccupancyVsTimeHisto->GetBinWidth(lastBin);
            time_t timeValue = time_t(binUpperEdge);
            hOccupancyVsTimeHisto->GetXaxis()->SetBinLabel( (lastBin),ctime(&timeValue) ); 
 
            LogTrace("Calibration") << "  Created occupancy histo: " << hOccupancyVsTimeHisto->GetName();
            chamberOccupancyVsTimeMap_[dtChId] = hOccupancyVsTimeHisto; 
         }
         chamberOccupancyVsTimeMap_[dtChId]->Fill( (unsigned int)eventTime, 1./triggerWidth_s );               
 
         /*// Book the digi event plot every 1000 events if the analysis is not "fast" and if is the correct sector
     if(!fastAnalysis &&
        dtLId.superlayerId().chamberId().wheel()==wh &&
        dtLId.superlayerId().chamberId().sector()==sect) {
       if(theHistoEvtPerWireMap.find(dtLId) == theHistoEvtPerWireMap.end() ||
          (theHistoEvtPerWireMap.find(dtLId) != theHistoEvtPerWireMap.end() &&
           skippedPlot[dtLId] != counter)){ 
         skippedPlot[dtLId] = counter;
         stringstream toAppend; toAppend << counter;
         Histo2Name = "DigiPerWirePerEvent_" + getLayerName(dtLId) + "_" + toAppend.str();
         theFile->cd();
         hEvtPerWireH = new TH2F(Histo2Name.c_str(), Histo2Name.c_str(), 1000,0.5,1000.5,nWires, firstWire, lastWire+1);
         if(hEvtPerWireH){
           if(debug)
         cout << "  New Histo with the number of digi per evt per wire: " << hEvtPerWireH->GetName() << endl;
           theHistoEvtPerWireMap[dtLId]=hEvtPerWireH;
         }
       }
     }*/
      }
   }
     
   /*//Fill the plot of the number of digi per event per wire
   std::map<int,int > DigiPerWirePerEvent;
   // LOOP OVER ALL THE CHAMBERS
   vector<DTChamber*>::const_iterator ch_it = dtGeom->chambers().begin();
   vector<DTChamber*>::const_iterator ch_end = dtGeom->chambers().end();
   for (; ch_it != ch_end; ++ch_it) {
     DTChamberId ch = (*ch_it)->id();
     vector<const DTSuperLayer*>::const_iterator sl_it = (*ch_it)->superLayers().begin(); 
     vector<const DTSuperLayer*>::const_iterator sl_end = (*ch_it)->superLayers().end();
     // Loop over the SLs
     for(; sl_it != sl_end; ++sl_it) {
       DTSuperLayerId sl = (*sl_it)->id();
       vector<const DTLayer*>::const_iterator l_it = (*sl_it)->layers().begin(); 
       vector<const DTLayer*>::const_iterator l_end = (*sl_it)->layers().end();
       // Loop over the Ls
       for(; l_it != l_end; ++l_it) {
     DTLayerId layerId = (*l_it)->id();
     
     // Get the number of wires
     const DTTopology& dtTopo = dtGeom->layer(layerId)->specificTopology();
     const int firstWire = dtTopo.firstChannel();
     const int lastWire = dtTopo.lastChannel();
       
     if (theHistoEvtPerWireMap.find(layerId) != theHistoEvtPerWireMap.end() &&
         skippedPlot[layerId] == counter) {
       
       for (int wire=firstWire; wire<=lastWire; wire++) {
         DigiPerWirePerEvent[wire]= 0;
       } 
       // loop over all the digis of the event
       DTDigiCollection::Range layerDigi= dtdigis->get(layerId);
       for (DTDigiCollection::const_iterator digi = layerDigi.first;
            digi!=layerDigi.second;
            ++digi){
         if((cosmicRun && (*digi).countsTDC()<upperLimit) || (!cosmicRun))
           DigiPerWirePerEvent[(*digi).wire()]+=1;
       }
       // fill the digi event histo
       for (int wire=firstWire; wire<=lastWire; wire++) {
         theFile->cd();
         int histoEvents = nevents - (counter*1000);
         theHistoEvtPerWireMap[layerId]->Fill(histoEvents,wire,DigiPerWirePerEvent[wire]);
       }
     }
       } //Loop Ls
     } //Loop SLs
   } //Loop chambers
   
   
   if(nevents % 1000 == 0) {
     counter++;
     // save the digis event plot on file
     for(map<DTLayerId,  TH2F* >::const_iterator lHisto = theHistoEvtPerWireMap.begin();
     lHisto != theHistoEvtPerWireMap.end();
     lHisto++) {
       theFile->cd();
       if((*lHisto).second)
     (*lHisto).second->Write();
     }
     theHistoEvtPerWireMap.clear();
   }*/
   
 }

void DTNoiseCalibration::beginJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 88 of file DTNoiseCalibration.cc.

                                   {
   LogVerbatim("Calibration") << "[DTNoiseCalibration]: Begin job";
   
   nevents_ = 0;
   
   TH1::SetDefaultSumw2(true);
   int numBin = (triggerWidth_*32/25)/50;
   hTDCTriggerWidth_ = new TH1F("TDC_Time_Distribution", "TDC_Time_Distribution", numBin, 0, triggerWidth_*32/25);
 }

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

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 98 of file DTNoiseCalibration.cc.

References edm::RunBase::beginTime(), edm::RunBase::endTime(), edm::EventSetup::get(), and edm::Timestamp::value().

                                                                                 {
 
   // Get the DT Geometry
   setup.get<MuonGeometryRecord>().get(dtGeom_);
 
   // tTrig 
   if( readDB_ ) setup.get<DTTtrigRcd>().get(dbLabel_,tTrigMap_);
 
   runBeginTime_ = time_t(run.beginTime().value()>>32);
   runEndTime_ = time_t(run.endTime().value()>>32);
   /*
   nevents = 0;
   counter = 0;
 
   // TDC time distribution
   int numBin = (triggerWidth_*(32/25))/50;
   hTDCTriggerWidth = new TH1F("TDC_Time_Distribution", "TDC_Time_Distribution", numBin, 0, triggerWidth_*(32/25));*/
 
 }

void DTNoiseCalibration::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 327 of file DTNoiseCalibration.cc.

References newFWLiteAna::bin, DTTopology::firstChannel(), DTTopology::lastChannel(), LogTrace, record, DTStatusFlag::setCellNoise(), and crabStatusFromReport::statusMap.

                                {
 
   //LogVerbatim("Calibration") << "[DTNoiseCalibration] endjob called!";
   LogVerbatim("Calibration") << "[DTNoiseCalibration] Total number of events analyzed: " << nevents_;
 
   // Save the TDC digi plot
   rootFile_->cd();
   hTDCTriggerWidth_->Write();
 
   double normalization = 1./double(nevents_);
 
   for(map<DTWireId, TH1F*>::const_iterator wHisto = theHistoOccupancyVsLumiMap_.begin();
                                            wHisto != theHistoOccupancyVsLumiMap_.end(); ++wHisto){
      (*wHisto).second->Scale(normalization);
      (*wHisto).second->Write();
   }
   
   for(map<DTChamberId, TH1F*>::const_iterator chHisto = chamberOccupancyVsLumiMap_.begin();
                                               chHisto != chamberOccupancyVsLumiMap_.end(); ++chHisto){
      (*chHisto).second->Scale(normalization);
      (*chHisto).second->Write();
   }
 
   for(map<DTChamberId, TH1F*>::const_iterator chHisto = chamberOccupancyVsTimeMap_.begin();
                                               chHisto != chamberOccupancyVsTimeMap_.end(); ++chHisto){
      (*chHisto).second->Scale(normalization);
      (*chHisto).second->Write();
   }
 
   // Save on file the occupancy histos and write the list of noisy cells
   DTStatusFlag *statusMap = new DTStatusFlag();
   for(map<DTLayerId, TH1F*>::const_iterator lHisto = theHistoOccupancyMap_.begin();
       lHisto != theHistoOccupancyMap_.end();
       ++lHisto){
      /*double triggerWidth_s = 0.;
      if( useTimeWindow_ ){
         double triggerWidth_ns = 0.;
         if( readDB_ ){
            float tTrig, tTrigRMS, kFactor;
            DTSuperLayerId slId = ((*lHisto).first).superlayerId();
            int status = tTrigMap_->get( slId, tTrig, tTrigRMS, kFactor, DTTimeUnits::counts );
            if(status != 0) throw cms::Exception("DTNoiseCalibration") << "Could not find tTrig entry in DB for" << slId << endl;
            triggerWidth_ns = tTrig - timeWindowOffset_;
         } else{
            triggerWidth_ns = defaultTtrig_ - timeWindowOffset_;
         }
         triggerWidth_ns = (triggerWidth_ns*25)/32;
         triggerWidth_s = triggerWidth_ns/1e9;
      } else{
         triggerWidth_s = double(triggerWidth_/1e9);
      }
      LogTrace("Calibration") << (*lHisto).second->GetName() << " trigger width (s): " << triggerWidth_s;*/
 
      //double normalization = 1./(nevents_*triggerWidth_s);
      if((*lHisto).second){
         (*lHisto).second->Scale(normalization);
         rootFile_->cd();
         (*lHisto).second->Write();
         const DTTopology& dtTopo = dtGeom_->layer((*lHisto).first)->specificTopology();
         const int firstWire = dtTopo.firstChannel();
         const int lastWire = dtTopo.lastChannel();
         //const int nWires = dtTopo.channels();
         const int nWires = lastWire - firstWire + 1;
         // Find average in layer
         double averageRate = 0.;  
         for(int bin = 1; bin <= (*lHisto).second->GetNbinsX(); ++bin)
            averageRate += (*lHisto).second->GetBinContent(bin);
 
         if(nWires) averageRate /= nWires;  
         LogTrace("Calibration") << "  Average rate = " << averageRate;
 
         for(int i_wire = firstWire; i_wire <= lastWire; ++i_wire){
        // From definition of "noisy cell"
            int bin = i_wire - firstWire + 1;
            double channelRate = (*lHisto).second->GetBinContent(bin);
            double rateOffset = (useAbsoluteRate_) ? 0. : averageRate;
        if( (channelRate - rateOffset) > maximumNoiseRate_ ){
           DTWireId wireID((*lHisto).first, i_wire);
           statusMap->setCellNoise(wireID,1);
               LogVerbatim("Calibration") << ">>> Channel noisy: " << wireID;
        }
         }
      }
   }
   LogVerbatim("Calibration") << "Writing noise map object to DB";
   string record = "DTStatusFlagRcd";
   DTCalibDBUtils::writeToDB<DTStatusFlag>(record, statusMap);
 }

string DTNoiseCalibration::getChamberName ( const DTChamberId & dtChId ) const

private

Definition at line 465 of file DTNoiseCalibration.cc.

References DTChamberId::sector(), DTChamberId::station(), relativeConstraints::station, and DTChamberId::wheel().

                                                                         {
 
   stringstream wheel; wheel << dtChId.wheel();
   stringstream station; station << dtChId.station();
   stringstream sector; sector << dtChId.sector();
 
   string chamberName =
     "W" + wheel.str()
     + "_St" + station.str()
     + "_Sec" + sector.str();
 
   return chamberName;
 }

string DTNoiseCalibration::getChannelName ( const DTWireId & wId ) const

private

Definition at line 420 of file DTNoiseCalibration.cc.

References ecaldqm::binning::channelName(), DTLayerId::layer(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superlayer(), DTChamberId::wheel(), and DTWireId::wire().

                                                                   {
   stringstream channelName;
   channelName << "Wh" << wId.wheel() << "_St" << wId.station() << "_Sec" << wId.sector()
           << "_SL" << wId.superlayer() << "_L" << wId.layer() << "_W"<< wId.wire();
 
   return channelName.str();
 }

string DTNoiseCalibration::getLayerName ( const DTLayerId & lId ) const

private

Definition at line 428 of file DTNoiseCalibration.cc.

References DTSuperLayerId::chamberId(), DTLayerId::layer(), DTChamberId::sector(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), DTLayerId::superlayerId(), and DTChamberId::wheel().

                                                                  {
 
   const  DTSuperLayerId dtSLId = lId.superlayerId();
   const  DTChamberId dtChId = dtSLId.chamberId(); 
   stringstream Layer; Layer << lId.layer();
   stringstream superLayer; superLayer << dtSLId.superlayer();
   stringstream wheel; wheel << dtChId.wheel();  
   stringstream station; station << dtChId.station();    
   stringstream sector; sector << dtChId.sector();
   
   string layerName = 
     "W" + wheel.str()
     + "_St" + station.str() 
     + "_Sec" + sector.str() 
     + "_SL" + superLayer.str()
     + "_L" + Layer.str();
   
   return layerName;
 }

string DTNoiseCalibration::getSuperLayerName ( const DTSuperLayerId & dtSLId ) const

private

Definition at line 448 of file DTNoiseCalibration.cc.

References DTSuperLayerId::chamberId(), DTChamberId::sector(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), and DTChamberId::wheel().

                                                                               {
 
   const  DTChamberId dtChId = dtSLId.chamberId(); 
   stringstream superLayer; superLayer << dtSLId.superlayer();
   stringstream wheel; wheel << dtChId.wheel();  
   stringstream station; station << dtChId.station();    
   stringstream sector; sector << dtChId.sector();
   
   string superLayerName = 
     "W" + wheel.str()
     + "_St" + station.str() 
     + "_Sec" + sector.str() 
     + "_SL" + superLayer.str();
   
   return superLayerName;
 }

Member Data Documentation

std::map<DTChamberId, TH1F*> DTNoiseCalibration::chamberOccupancyVsLumiMap_

private

Definition at line 89 of file DTNoiseCalibration.h.

std::map<DTChamberId, TH1F*> DTNoiseCalibration::chamberOccupancyVsTimeMap_

private

Definition at line 91 of file DTNoiseCalibration.h.

std::string DTNoiseCalibration::dbLabel_

private

Definition at line 66 of file DTNoiseCalibration.h.

int DTNoiseCalibration::defaultTtrig_

private

Definition at line 65 of file DTNoiseCalibration.h.

Referenced by DTNoiseCalibration().

edm::InputTag DTNoiseCalibration::digiLabel_

private

Definition at line 53 of file DTNoiseCalibration.h.

edm::ESHandle<DTGeometry> DTNoiseCalibration::dtGeom_

private

Definition at line 77 of file DTNoiseCalibration.h.

TH1F* DTNoiseCalibration::hTDCTriggerWidth_

private

Definition at line 83 of file DTNoiseCalibration.h.

unsigned int DTNoiseCalibration::lumiMax_

private

Definition at line 69 of file DTNoiseCalibration.h.

double DTNoiseCalibration::maximumNoiseRate_

private

Definition at line 57 of file DTNoiseCalibration.h.

int DTNoiseCalibration::nevents_

private

Definition at line 71 of file DTNoiseCalibration.h.

bool DTNoiseCalibration::readDB_

private

Definition at line 64 of file DTNoiseCalibration.h.

Referenced by DTNoiseCalibration().

TFile* DTNoiseCalibration::rootFile_

private

Definition at line 81 of file DTNoiseCalibration.h.

Referenced by DTNoiseCalibration().

time_t DTNoiseCalibration::runBeginTime_

private

Definition at line 73 of file DTNoiseCalibration.h.

time_t DTNoiseCalibration::runEndTime_

private

Definition at line 74 of file DTNoiseCalibration.h.

std::map<DTLayerId, TH1F*> DTNoiseCalibration::theHistoOccupancyMap_

private

Definition at line 85 of file DTNoiseCalibration.h.

std::map<DTWireId, TH1F*> DTNoiseCalibration::theHistoOccupancyVsLumiMap_

private

Definition at line 87 of file DTNoiseCalibration.h.

int DTNoiseCalibration::timeWindowOffset_

private

Definition at line 56 of file DTNoiseCalibration.h.

double DTNoiseCalibration::triggerWidth_

private

Definition at line 55 of file DTNoiseCalibration.h.

edm::ESHandle<DTTtrig> DTNoiseCalibration::tTrigMap_

private

Definition at line 79 of file DTNoiseCalibration.h.

bool DTNoiseCalibration::useAbsoluteRate_

private

Definition at line 58 of file DTNoiseCalibration.h.

bool DTNoiseCalibration::useTimeWindow_

private

Definition at line 54 of file DTNoiseCalibration.h.

std::vector<DTWireId> DTNoiseCalibration::wireIdWithHisto_

private

Definition at line 68 of file DTNoiseCalibration.h.

Referenced by DTNoiseCalibration().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation