#include <DTNoiseComputation.h>

Inheritance diagram for DTNoiseComputation:

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &setup) override

void	beginJob () override
	BeginJob. More...

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

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

void	endJob () override
	Endjob. More...

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

	~DTNoiseComputation () override
	Destructor. More...

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~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

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

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
std::string	getChamberName (const DTLayerId &lId) const
	Get the name of the chamber. More...

std::string	getLayerName (const DTLayerId &lId) const
	Get the name of the layer. More...

int	getMaxNumBins (const DTChamberId &chId) const

std::string	getSuperLayerName (const DTSuperLayerId &slId) const
	Get the name of the superLayer. More...

double	getYMaximum (const DTSuperLayerId &slId) const

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

std::map< DTSuperLayerId, TH1F * >	AvNoiseIntegratedPerSuperLayer

std::map< DTChamberId, TH1F * >	AvNoisePerChamber

std::map< DTSuperLayerId, TH1F * >	AvNoisePerSuperLayer

int	counter

bool	debug

edm::ESHandle< DTGeometry >	dtGeom

const edm::ESGetToken< DTGeometry, MuonGeometryRecord >	dtGeomToken_

bool	fastAnalysis

int	MaxEvents

std::map< std::pair< int, int >, TH1F * >	noisyC

std::map< std::pair< int, int >, TH1F * >	someHowNoisyC

std::map< DTWireId, double >	theAverageNoise

std::map< DTLayerId, std::vector< TH2F * > >	theEvtMap

TFile *	theFile

std::map< DTWireId, TH1F * >	theHistoEvtDistancePerWire

TFile *	theNewFile

std::map< DTWireId, double >	theTimeConstant

std::map< DTLayerId, bool >	toComputeNoiseAverage

std::map< DTWireId, bool >	toDel

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 34 of file DTNoiseComputation.h.

Constructor & Destructor Documentation

◆ DTNoiseComputation()

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

Constructor.

Definition at line 41 of file DTNoiseComputation.cc.

References gather_cfg::cout, debug, fastAnalysis, edm::ParameterSet::getUntrackedParameter(), MaxEvents, CSCSkim_cfi::rootFileName, theFile, and theNewFile.

                                                                 : dtGeomToken_(esConsumes()) {
   cout << "[DTNoiseComputation]: Constructor" << endl;
 
   // Get the debug parameter for verbose output
   debug = ps.getUntrackedParameter<bool>("debug");
 
   // The analysis type
   fastAnalysis = ps.getUntrackedParameter<bool>("fastAnalysis", true);
 
   // The root file which contain the histos
   string rootFileName = ps.getUntrackedParameter<string>("rootFileName");
   theFile = new TFile(rootFileName.c_str(), "READ");
 
   // The new root file which contain the histos
   string newRootFileName = ps.getUntrackedParameter<string>("newRootFileName");
   theNewFile = new TFile(newRootFileName.c_str(), "RECREATE");
 
   // The maximum number of events to analyze
   MaxEvents = ps.getUntrackedParameter<int>("MaxEvents");
 }

◆ ~DTNoiseComputation()

DTNoiseComputation::~DTNoiseComputation ( )

override

Destructor.

Definition at line 376 of file DTNoiseComputation.cc.

References theFile, and theNewFile.

                                         {
   theFile->Close();
   theNewFile->Close();
 }

Member Function Documentation

◆ analyze()

void DTNoiseComputation::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

inlineoverridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 47 of file DTNoiseComputation.h.

47 {}

◆ beginJob()

void DTNoiseComputation::beginJob ( )

inlineoverridevirtual

BeginJob.

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 43 of file DTNoiseComputation.h.

43 {}

◆ beginRun()

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

override

Definition at line 62 of file DTNoiseComputation.cc.

References AvNoiseIntegratedPerChamber, AvNoiseIntegratedPerSuperLayer, AvNoisePerChamber, AvNoisePerSuperLayer, newFWLiteAna::bin, DTSuperLayerId::chamberId(), DTGeometry::chambers(), submitPVResolutionJobs::count, gather_cfg::cout, debug, dtGeom, dtGeomToken_, HcalObjRepresent::Fill(), getChamberName(), getLayerName(), getMaxNumBins(), getSuperLayerName(), MaxEvents, noisyC, singleTopDQM_cfi::setup, someHowNoisyC, DTChamberId::station(), relativeConstraints::station, DTLayerId::superlayerId(), theAverageNoise, theEvtMap, theFile, to_string(), DTChamberId::wheel(), and makeMuonMisalignmentScenario::wheel.

                                                                          {
   // Get the DT Geometry
   dtGeom = setup.getHandle(dtGeomToken_);
 
   static int count = 0;
 
   if (count == 0) {
     string CheckHistoName;
 
     TH1F *hOccHisto;
     TH1F *hAverageNoiseHisto;
     TH1F *hAverageNoiseIntegratedHisto;
     TH1F *hAverageNoiseHistoPerCh;
     TH1F *hAverageNoiseIntegratedHistoPerCh;
     TH2F *hEvtHisto;
     string HistoName;
     string Histo2Name;
     string AverageNoiseName;
     string AverageNoiseIntegratedName;
     string AverageNoiseNamePerCh;
     string AverageNoiseIntegratedNamePerCh;
     TH1F *hnoisyC;
     TH1F *hsomeHowNoisyC;
 
     // Loop over all the chambers
     vector<const DTChamber *>::const_iterator ch_it = dtGeom->chambers().begin();
     vector<const DTChamber *>::const_iterator ch_end = dtGeom->chambers().end();
     // Loop over the SLs
     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 dtLId = (*l_it)->id();
 
           //check if the layer has digi
           theFile->cd();
           CheckHistoName = "DigiOccupancy_" + getLayerName(dtLId);
           TH1F *hCheckHisto = (TH1F *)theFile->Get(CheckHistoName.c_str());
           if (hCheckHisto) {
             delete hCheckHisto;
             string wheel = std::to_string(ch.wheel());
             string station = std::to_string(ch.station());
 
             if (someHowNoisyC.find(make_pair(ch.wheel(), ch.station())) == someHowNoisyC.end()) {
               TString histoName_someHowNoisy = "somehowNoisyCell_W" + wheel + "_St" + station;
               hsomeHowNoisyC =
                   new TH1F(histoName_someHowNoisy, histoName_someHowNoisy, getMaxNumBins(ch), 1, getMaxNumBins(ch) + 1);
               someHowNoisyC[make_pair(ch.wheel(), ch.station())] = hsomeHowNoisyC;
             }
 
             if (noisyC.find(make_pair(ch.wheel(), ch.station())) == noisyC.end()) {
               TString histoName_noisy = "noisyCell_W" + wheel + "_St" + station;
               hnoisyC = new TH1F(histoName_noisy, histoName_noisy, getMaxNumBins(ch), 1, getMaxNumBins(ch) + 1);
               noisyC[make_pair(ch.wheel(), ch.station())] = hnoisyC;
             }
 
             //to fill a map with the average noise per wire and fill new noise histo
             if (AvNoisePerSuperLayer.find(dtLId.superlayerId()) == AvNoisePerSuperLayer.end()) {
               AverageNoiseName = "AverageNoise_" + getSuperLayerName(dtLId.superlayerId());
               hAverageNoiseHisto = new TH1F(AverageNoiseName.c_str(), AverageNoiseName.c_str(), 200, 0, 10000);
               AverageNoiseIntegratedName = "AverageNoiseIntegrated_" + getSuperLayerName(dtLId.superlayerId());
               hAverageNoiseIntegratedHisto =
                   new TH1F(AverageNoiseIntegratedName.c_str(), AverageNoiseIntegratedName.c_str(), 200, 0, 10000);
               AvNoisePerSuperLayer[dtLId.superlayerId()] = hAverageNoiseHisto;
               AvNoiseIntegratedPerSuperLayer[dtLId.superlayerId()] = hAverageNoiseIntegratedHisto;
               if (debug) {
                 cout << "  New Average Noise Histo per SuperLayer : " << hAverageNoiseHisto->GetName() << endl;
                 cout << "  New Average Noise Integrated Histo per SuperLayer : " << hAverageNoiseHisto->GetName()
                      << endl;
               }
             }
             if (AvNoisePerChamber.find(dtLId.superlayerId().chamberId()) == AvNoisePerChamber.end()) {
               AverageNoiseNamePerCh = "AverageNoise_" + getChamberName(dtLId);
               hAverageNoiseHistoPerCh =
                   new TH1F(AverageNoiseNamePerCh.c_str(), AverageNoiseNamePerCh.c_str(), 200, 0, 10000);
               AverageNoiseIntegratedNamePerCh = "AverageNoiseIntegrated_" + getChamberName(dtLId);
               hAverageNoiseIntegratedHistoPerCh = new TH1F(
                   AverageNoiseIntegratedNamePerCh.c_str(), AverageNoiseIntegratedNamePerCh.c_str(), 200, 0, 10000);
               AvNoisePerChamber[dtLId.superlayerId().chamberId()] = hAverageNoiseHistoPerCh;
               AvNoiseIntegratedPerChamber[dtLId.superlayerId().chamberId()] = hAverageNoiseIntegratedHistoPerCh;
               if (debug)
                 cout << "  New Average Noise Histo per chamber : " << hAverageNoiseHistoPerCh->GetName() << endl;
             }
 
             HistoName = "DigiOccupancy_" + getLayerName(dtLId);
             theFile->cd();
             hOccHisto = (TH1F *)theFile->Get(HistoName.c_str());
             int numBin = hOccHisto->GetXaxis()->GetNbins();
             for (int bin = 1; bin <= numBin; bin++) {
               DTWireId wireID(dtLId, bin);
               theAverageNoise[wireID] = hOccHisto->GetBinContent(bin);
               if (theAverageNoise[wireID] != 0) {
                 AvNoisePerSuperLayer[dtLId.superlayerId()]->Fill(theAverageNoise[wireID]);
                 AvNoisePerChamber[dtLId.superlayerId().chamberId()]->Fill(theAverageNoise[wireID]);
               }
             }
 
             //to compute the average noise per layer (excluding the noisy cells)
             double numCell = 0;
             double AvNoise = 0;
             HistoName = "DigiOccupancy_" + getLayerName(dtLId);
             theFile->cd();
             hOccHisto = (TH1F *)theFile->Get(HistoName.c_str());
             numBin = hOccHisto->GetXaxis()->GetNbins();
             for (int bin = 1; bin <= numBin; bin++) {
               DTWireId wireID(dtLId, bin);
               theAverageNoise[wireID] = hOccHisto->GetBinContent(bin);
               if (hOccHisto->GetBinContent(bin) < 100) {
                 numCell++;
                 AvNoise += hOccHisto->GetBinContent(bin);
               }
               if (hOccHisto->GetBinContent(bin) > 100 && hOccHisto->GetBinContent(bin) < 500) {
                 someHowNoisyC[make_pair(ch.wheel(), ch.station())]->Fill(bin);
                 cout << "filling somehow noisy cell" << endl;
               }
               if (hOccHisto->GetBinContent(bin) > 500) {
                 noisyC[make_pair(ch.wheel(), ch.station())]->Fill(bin);
                 cout << "filling noisy cell" << endl;
               }
             }
             AvNoise = AvNoise / numCell;
             cout << "theAverageNoise for layer " << getLayerName(dtLId) << " is : " << AvNoise << endl;
 
             // book the digi event plots every 1000 events
             int updates = MaxEvents / 1000;
             for (int evt = 0; evt < updates; evt++) {
               Histo2Name = "DigiPerWirePerEvent_" + getLayerName(dtLId) + "_" + std::to_string(evt);
               theFile->cd();
               hEvtHisto = (TH2F *)theFile->Get(Histo2Name.c_str());
               if (hEvtHisto) {
                 if (debug)
                   cout << "  New Histo with the number of events per evt per wire: " << hEvtHisto->GetName() << endl;
                 theEvtMap[dtLId].push_back(hEvtHisto);
               }
             }
 
           }  // done if the layer has digi
         }    // loop over layers
       }      // loop over superlayers
     }        // loop over chambers
 
     count++;
   }
 }

◆ endJob()

void DTNoiseComputation::endJob ( void )

overridevirtual

Endjob.

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 214 of file DTNoiseComputation.cc.

References AvNoiseIntegratedPerChamber, AvNoiseIntegratedPerSuperLayer, AvNoisePerChamber, AvNoisePerSuperLayer, newFWLiteAna::bin, alignmentValidation::c1, DTGeometry::chambers(), gather_cfg::cout, dtGeom, fastAnalysis, getLayerName(), getSuperLayerName(), getYMaximum(), timingPdfMaker::histo, mps_fire::i, createfilelist::int, DTLayerId::layer(), genParticles_cff::map, cms::cuda::allocator::maxBin, noisyC, pfMETCorrectionType0_cfi::par0, pfMETCorrectionType0_cfi::par1, someHowNoisyC, theAverageNoise, theEvtMap, theFile, theHistoEvtDistancePerWire, theNewFile, theTimeConstant, to_string(), toDel, and nano_mu_digi_cff::wire.

Referenced by o2olib.O2ORunMgr::executeJob().

                                 {
   cout << "[DTNoiseComputation] endjob called!" << endl;
   TH1F *hEvtDistance = nullptr;
   TF1 *ExpoFit = new TF1("ExpoFit", "expo", 0.5, 1000.5);
   ExpoFit->SetMarkerColor();  //just silence gcc complaining about unused vars
   TProfile *theNoiseHisto = new TProfile("theNoiseHisto", "Time Constant versus Average Noise", 100000, 0, 100000);
 
   //compute the time constant
   for (map<DTLayerId, vector<TH2F *> >::const_iterator lHisto = theEvtMap.begin(); lHisto != theEvtMap.end();
        ++lHisto) {
     for (int bin = 1; bin < (*lHisto).second[0]->GetYaxis()->GetNbins(); bin++) {
       int distanceEvt = 1;
       DTWireId wire((*lHisto).first, bin);
       for (int i = 0; i < int((*lHisto).second.size()); i++) {
         for (int evt = 1; evt <= (*lHisto).second[i]->GetXaxis()->GetNbins(); evt++) {
           if ((*lHisto).second[i]->GetBinContent(evt, bin) == 0)
             distanceEvt++;
           else {
             if (toDel.find(wire) == toDel.end()) {
               toDel[wire] = false;
               string Histo = "EvtDistancePerWire_" + getLayerName((*lHisto).first) + "_" + std::to_string(bin);
               hEvtDistance = new TH1F(Histo.c_str(), Histo.c_str(), 50000, 0.5, 50000.5);
             }
             hEvtDistance->Fill(distanceEvt);
             distanceEvt = 1;
           }
         }
       }
       if (toDel.find(wire) != toDel.end()) {
         theHistoEvtDistancePerWire[wire] = hEvtDistance;
         theNewFile->cd();
         theHistoEvtDistancePerWire[wire]->Fit("ExpoFit", "R");
         TF1 *funct = theHistoEvtDistancePerWire[wire]->GetFunction("ExpoFit");
         double par0 = funct->GetParameter(0);
         double par1 = funct->GetParameter(1);
         cout << "par0: " << par0 << "  par1: " << par1 << endl;
         double chi2rid = funct->GetChisquare() / funct->GetNDF();
         if (chi2rid > 10)
           theTimeConstant[wire] = 1;
         else
           theTimeConstant[wire] = par1;
         toDel[wire] = true;
         theHistoEvtDistancePerWire[wire]->Write();
         delete hEvtDistance;
       }
     }
   }
 
   if (!fastAnalysis) {
     //fill the histo with the time constant as a function of the average noise
     for (map<DTWireId, double>::const_iterator AvNoise = theAverageNoise.begin(); AvNoise != theAverageNoise.end();
          ++AvNoise) {
       DTWireId wire = (*AvNoise).first;
       theNoiseHisto->Fill((*AvNoise).second, theTimeConstant[wire]);
       cout << "Layer: " << getLayerName(wire.layerId()) << "  wire: " << wire.wire() << endl;
       cout << "The Average noise: " << (*AvNoise).second << endl;
       cout << "The time constant: " << theTimeConstant[wire] << endl;
     }
     theNewFile->cd();
     theNoiseHisto->Write();
   }
 
   // histos with the integrated noise per layer
   int numBin;
   double integratedNoise, bin, halfBin, maxBin;
   for (map<DTSuperLayerId, TH1F *>::const_iterator AvNoiseHisto = AvNoisePerSuperLayer.begin();
        AvNoiseHisto != AvNoisePerSuperLayer.end();
        ++AvNoiseHisto) {
     integratedNoise = 0;
     numBin = (*AvNoiseHisto).second->GetXaxis()->GetNbins();
     maxBin = (*AvNoiseHisto).second->GetXaxis()->GetXmax();
     bin = double(maxBin / numBin);
     halfBin = double(bin / 2);
     theNewFile->cd();
     (*AvNoiseHisto).second->Write();
     for (int i = 1; i < numBin; i++) {
       integratedNoise += (*AvNoiseHisto).second->GetBinContent(i);
       AvNoiseIntegratedPerSuperLayer[(*AvNoiseHisto).first]->Fill(halfBin, integratedNoise);
       halfBin += bin;
     }
     theNewFile->cd();
     AvNoiseIntegratedPerSuperLayer[(*AvNoiseHisto).first]->Write();
   }
   // histos with the integrated noise per chamber
   for (map<DTChamberId, TH1F *>::const_iterator AvNoiseHisto = AvNoisePerChamber.begin();
        AvNoiseHisto != AvNoisePerChamber.end();
        ++AvNoiseHisto) {
     integratedNoise = 0;
     numBin = (*AvNoiseHisto).second->GetXaxis()->GetNbins();
     maxBin = (*AvNoiseHisto).second->GetXaxis()->GetXmax();
     bin = maxBin / numBin;
     halfBin = bin / 2;
     theNewFile->cd();
     (*AvNoiseHisto).second->Write();
     for (int i = 1; i < numBin; i++) {
       integratedNoise += (*AvNoiseHisto).second->GetBinContent(i);
       AvNoiseIntegratedPerChamber[(*AvNoiseHisto).first]->Fill(halfBin, integratedNoise);
       halfBin += bin;
     }
     theNewFile->cd();
     AvNoiseIntegratedPerChamber[(*AvNoiseHisto).first]->Write();
   }
 
   //overimpose the average noise histo
   bool histo = false;
   vector<const DTChamber *>::const_iterator chamber_it = dtGeom->chambers().begin();
   vector<const DTChamber *>::const_iterator chamber_end = dtGeom->chambers().end();
   // Loop over the chambers
   for (; chamber_it != chamber_end; ++chamber_it) {
     vector<const DTSuperLayer *>::const_iterator sl_it = (*chamber_it)->superLayers().begin();
     vector<const DTSuperLayer *>::const_iterator sl_end = (*chamber_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();
 
       string canvasName = "c" + getSuperLayerName(sl);
       TCanvas c1(canvasName.c_str(), canvasName.c_str(), 600, 780);
       TLegend *leg = new TLegend(0.5, 0.6, 0.7, 0.8);
       for (; l_it != l_end; ++l_it) {
         DTLayerId layerId = (*l_it)->id();
         string HistoName = "DigiOccupancy_" + getLayerName(layerId);
         theFile->cd();
         TH1F *hOccHisto = (TH1F *)theFile->Get(HistoName.c_str());
         if (hOccHisto) {
           string TitleHisto = "AverageNoise_" + getSuperLayerName(sl);
           cout << "TitleHisto : " << TitleHisto << endl;
           hOccHisto->SetTitle(TitleHisto.c_str());
           string legendHisto = "layer " + std::to_string(layerId.layer());
           leg->AddEntry(hOccHisto, legendHisto.c_str(), "L");
           hOccHisto->SetMaximum(getYMaximum(sl));
           histo = true;
           if (layerId.layer() == 1)
             hOccHisto->Draw();
           else
             hOccHisto->Draw("same");
           hOccHisto->SetLineColor(layerId.layer());
         }
       }
       if (histo) {
         leg->Draw("same");
         theNewFile->cd();
         c1.Write();
       }
     }
     histo = false;
   }
 
   //write on file the noisy plots
   for (map<pair<int, int>, TH1F *>::const_iterator nCell = noisyC.begin(); nCell != noisyC.end(); ++nCell) {
     theNewFile->cd();
     (*nCell).second->Write();
   }
   for (map<pair<int, int>, TH1F *>::const_iterator somehownCell = someHowNoisyC.begin();
        somehownCell != someHowNoisyC.end();
        ++somehownCell) {
     theNewFile->cd();
     (*somehownCell).second->Write();
   }
 }

◆ endRun()

void DTNoiseComputation::endRun	(	const edm::Run &	,
		const edm::EventSetup &	setup
	)

inlineoverride

Definition at line 49 of file DTNoiseComputation.h.

49 {};

◆ getChamberName()

string DTNoiseComputation::getChamberName ( const DTLayerId & lId ) const

private

Get the name of the chamber.

Definition at line 400 of file DTNoiseComputation.cc.

References DTSuperLayerId::chamberId(), DTChamberId::sector(), DTChamberId::station(), DTLayerId::superlayerId(), to_string(), and DTChamberId::wheel().

Referenced by beginRun().

                                                                     {
   const DTSuperLayerId dtSLId = lId.superlayerId();
   const DTChamberId dtChId = dtSLId.chamberId();
   string chamberName = "W" + std::to_string(dtChId.wheel()) + "_St" + std::to_string(dtChId.station()) + "_Sec" +
                        std::to_string(dtChId.sector());
 
   return chamberName;
 }

◆ getLayerName()

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

private

Get the name of the layer.

Definition at line 381 of file DTNoiseComputation.cc.

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

Referenced by beginRun(), endJob(), getMaxNumBins(), and getYMaximum().

                                                                   {
   const DTSuperLayerId dtSLId = lId.superlayerId();
   const DTChamberId dtChId = dtSLId.chamberId();
   string layerName = "W" + std::to_string(dtChId.wheel()) + "_St" + std::to_string(dtChId.station()) + "_Sec" +
                      std::to_string(dtChId.sector()) + "_SL" + std::to_string(dtSLId.superlayer()) + "_L" +
                      std::to_string(lId.layer());
 
   return layerName;
 }

◆ getMaxNumBins()

int DTNoiseComputation::getMaxNumBins ( const DTChamberId & chId ) const

private

Definition at line 409 of file DTNoiseComputation.cc.

References getLayerName(), dttmaxenums::L, DTChamberId::station(), and theFile.

Referenced by beginRun().

                                                                    {
   int maximum = 0;
 
   for (int SL = 1; SL <= 3; SL++) {
     if (!(chId.station() == 4 && SL == 2)) {
       for (int L = 1; L <= 4; L++) {
         DTLayerId layerId = DTLayerId(chId, SL, L);
         string HistoName = "DigiOccupancy_" + getLayerName(layerId);
         theFile->cd();
         TH1F *hOccHisto = (TH1F *)theFile->Get(HistoName.c_str());
         if (hOccHisto) {
           if (hOccHisto->GetXaxis()->GetXmax() > maximum)
             maximum = hOccHisto->GetXaxis()->GetNbins();
         }
       }
     }
   }
   return maximum;
 }

◆ getSuperLayerName()

string DTNoiseComputation::getSuperLayerName ( const DTSuperLayerId & slId ) const

private

Get the name of the superLayer.

Definition at line 391 of file DTNoiseComputation.cc.

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

Referenced by beginRun(), and endJob().

                                                                                {
   const DTChamberId dtChId = dtSLId.chamberId();
 
   string superLayerName = "W" + std::to_string(dtChId.wheel()) + "_St" + std::to_string(dtChId.station()) + "_Sec" +
                           std::to_string(dtChId.sector()) + "_SL" + std::to_string(dtSLId.superlayer());
 
   return superLayerName;
 }

◆ getYMaximum()

double DTNoiseComputation::getYMaximum ( const DTSuperLayerId & slId ) const

private

Definition at line 429 of file DTNoiseComputation.cc.

References getLayerName(), dttmaxenums::L, funct::pow(), and theFile.

Referenced by endJob().

                                                                        {
   double maximum = 0;
   double dummy = pow(10., 10.);
 
   for (int L = 1; L <= 4; L++) {
     DTLayerId layerId = DTLayerId(slId, L);
     string HistoName = "DigiOccupancy_" + getLayerName(layerId);
     theFile->cd();
     TH1F *hOccHisto = (TH1F *)theFile->Get(HistoName.c_str());
     if (hOccHisto) {
       if (hOccHisto->GetMaximum(dummy) > maximum)
         maximum = hOccHisto->GetMaximum(dummy);
     }
   }
   return maximum;
 }

Member Data Documentation

◆ AvNoiseIntegratedPerChamber

std::map<DTChamberId, TH1F*> DTNoiseComputation::AvNoiseIntegratedPerChamber

private

Definition at line 102 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ AvNoiseIntegratedPerSuperLayer

std::map<DTSuperLayerId, TH1F*> DTNoiseComputation::AvNoiseIntegratedPerSuperLayer

private

Definition at line 108 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ AvNoisePerChamber

std::map<DTChamberId, TH1F*> DTNoiseComputation::AvNoisePerChamber

private

Definition at line 99 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ AvNoisePerSuperLayer

std::map<DTSuperLayerId, TH1F*> DTNoiseComputation::AvNoisePerSuperLayer

private

Definition at line 105 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ counter

int DTNoiseComputation::counter

private

Definition at line 57 of file DTNoiseComputation.h.

Referenced by counter.Counters::__getitem__().

◆ debug

bool DTNoiseComputation::debug

private

Definition at line 56 of file DTNoiseComputation.h.

Referenced by beginRun(), util.rrapi.RRApi::dprint(), rrapi.RRApi::dprint(), DTNoiseComputation(), pkg.AbstractPkg::generate(), util.rrapi.RRApi::get(), rrapi.RRApi::get(), pkg.AbstractPkg::get_kwds(), runTauIdMVA.TauIDEmbedder::load_againstElectronMVA6(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), crabFunctions.CrabController::submit(), and pkg.AbstractPkg::write().

◆ dtGeom

edm::ESHandle<DTGeometry> DTNoiseComputation::dtGeom

private

Definition at line 62 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ dtGeomToken_

const edm::ESGetToken<DTGeometry, MuonGeometryRecord> DTNoiseComputation::dtGeomToken_

private

Definition at line 63 of file DTNoiseComputation.h.

Referenced by beginRun().

◆ fastAnalysis

bool DTNoiseComputation::fastAnalysis

private

Definition at line 59 of file DTNoiseComputation.h.

Referenced by DTNoiseComputation(), and endJob().

◆ MaxEvents

int DTNoiseComputation::MaxEvents

private

Definition at line 58 of file DTNoiseComputation.h.

Referenced by beginRun(), and DTNoiseComputation().

◆ noisyC

std::map<std::pair<int, int>, TH1F*> DTNoiseComputation::noisyC

private

Definition at line 117 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ someHowNoisyC

std::map<std::pair<int, int>, TH1F*> DTNoiseComputation::someHowNoisyC

private

Definition at line 120 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ theAverageNoise

std::map<DTWireId, double> DTNoiseComputation::theAverageNoise

private

Definition at line 75 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ theEvtMap

std::map<DTLayerId, std::vector<TH2F*> > DTNoiseComputation::theEvtMap

private

Definition at line 78 of file DTNoiseComputation.h.

Referenced by beginRun(), and endJob().

◆ theFile

TFile* DTNoiseComputation::theFile

private

Definition at line 66 of file DTNoiseComputation.h.

Referenced by beginRun(), DTNoiseComputation(), endJob(), getMaxNumBins(), getYMaximum(), and ~DTNoiseComputation().

◆ theHistoEvtDistancePerWire

std::map<DTWireId, TH1F*> DTNoiseComputation::theHistoEvtDistancePerWire

private

Definition at line 81 of file DTNoiseComputation.h.

Referenced by endJob().

◆ theNewFile

TFile* DTNoiseComputation::theNewFile

private

Definition at line 69 of file DTNoiseComputation.h.

Referenced by DTNoiseComputation(), endJob(), and ~DTNoiseComputation().

◆ theTimeConstant

std::map<DTWireId, double> DTNoiseComputation::theTimeConstant

private

Definition at line 87 of file DTNoiseComputation.h.

Referenced by endJob().

◆ toComputeNoiseAverage

std::map<DTLayerId, bool> DTNoiseComputation::toComputeNoiseAverage

private

Definition at line 72 of file DTNoiseComputation.h.

◆ toDel

std::map<DTWireId, bool> DTNoiseComputation::toDel

private

Definition at line 84 of file DTNoiseComputation.h.

Referenced by endJob().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DTNoiseComputation()

◆ ~DTNoiseComputation()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ beginRun()

◆ endJob()

◆ endRun()

◆ getChamberName()

◆ getLayerName()

◆ getMaxNumBins()

◆ getSuperLayerName()

◆ getYMaximum()

Member Data Documentation

◆ AvNoiseIntegratedPerChamber

◆ AvNoiseIntegratedPerSuperLayer

◆ AvNoisePerChamber

◆ AvNoisePerSuperLayer

◆ counter

◆ debug

◆ dtGeom

◆ dtGeomToken_

◆ fastAnalysis

◆ MaxEvents

◆ noisyC

◆ someHowNoisyC

◆ theAverageNoise

◆ theEvtMap

◆ theFile

◆ theHistoEvtDistancePerWire

◆ theNewFile

◆ theTimeConstant

◆ toComputeNoiseAverage

◆ toDel