#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 final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const 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

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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::alpakatools::config::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::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), 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