Inheritance diagram for HcalRaddamMuon:

Public Member Functions
	HcalRaddamMuon (const edm::ParameterSet &)

	~HcalRaddamMuon () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	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

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	activeLength (const DetId &)

void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

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

void	clearVectors ()

void	endJob () override

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

int	matchId (const HcalDetId &, const HcalDetId &)

Private Attributes
double	_RecoMuon1TrackIsoSumPtMaxCutValue_03

double	_RecoMuon1TrackIsoSumPtMaxCutValue_04

std::vector < HcalDDDRecConstants::HcalActiveLength >	actHB

std::vector < HcalDDDRecConstants::HcalActiveLength >	actHE

std::vector< bool >	all_ifTriggerpassed

std::vector< std::string >	all_triggers

std::vector< std::string >	all_triggers1

std::vector< std::string >	all_triggers2

std::vector< std::string >	all_triggers3

std::vector< std::string >	all_triggers4

std::vector< std::string >	all_triggers5

unsigned int	BXNumber

std::vector< double >	chiGlobal

std::vector< double >	chiTracker

std::vector< double >	DxyTracker

std::vector< double >	dxyWithBS

std::vector< double >	DzTracker

std::vector< double >	dzWithBS

std::vector< double >	Energy

std::vector< float >	energy_hb

std::vector< double >	EtaGlob

unsigned int	EventNumber

edm::Service< TFileService >	fs

std::vector< double >	GlobalMuonHits

std::vector< bool >	GlobalTrack

std::vector< double >	GlobalTrckEta

std::vector< double >	GlobalTrckPhi

std::vector< double >	GlobalTrckPt

double	h3x3

double	h3x3Calo

std::vector< double >	High_TrackLayers

HLTConfigProvider	hltConfig_

std::string	hltlabel_

std::vector< std::string >	hltpaths

std::vector< int >	hltresults

const edm::InputTag	hlTriggerResults_

std::vector< double >	ImpactParameter

std::vector< bool >	innerTrack

std::vector< double >	innerTracketa

std::vector< double >	innerTrackphi

std::vector< double >	innerTrackpt

const bool	isAOD_

std::vector< bool >	isHB

std::vector< bool >	isHE

std::vector< double >	IsolationR03

std::vector< double >	IsolationR04

unsigned int	LumiNumber

std::vector< double >	MatchedStat

int	maxDepth_

std::vector< bool >	muon_global

std::vector< bool >	muon_is_good

std::vector< bool >	muon_tracker

std::vector< double >	MuonEcal3x3Energy

std::vector< unsigned int >	MuonEcalDetId

std::vector< double >	MuonEcalEnergy

std::vector< unsigned int >	MuonEHcalDetId

std::vector< double >	MuonHcal1x1Energy

std::vector< double >	MuonHcalActiveLength

std::vector< double >	MuonHcalDepth1Energy

std::vector< double >	MuonHcalDepth1EnergyCalo

std::vector< double >	MuonHcalDepth1HotEnergy

std::vector< double >	MuonHcalDepth1HotEnergyCalo

std::vector< double >	MuonHcalDepth2Energy

std::vector< double >	MuonHcalDepth2EnergyCalo

std::vector< double >	MuonHcalDepth2HotEnergy

std::vector< double >	MuonHcalDepth2HotEnergyCalo

std::vector< double >	MuonHcalDepth3Energy

std::vector< double >	MuonHcalDepth3EnergyCalo

std::vector< double >	MuonHcalDepth3HotEnergy

std::vector< double >	MuonHcalDepth3HotEnergyCalo

std::vector< double >	MuonHcalDepth4Energy

std::vector< double >	MuonHcalDepth4EnergyCalo

std::vector< double >	MuonHcalDepth4HotEnergy

std::vector< double >	MuonHcalDepth4HotEnergyCalo

std::vector< double >	MuonHcalDepth5Energy

std::vector< double >	MuonHcalDepth5EnergyCalo

std::vector< double >	MuonHcalDepth5HotEnergy

std::vector< double >	MuonHcalDepth5HotEnergyCalo

std::vector< double >	MuonHcalDepth6Energy

std::vector< double >	MuonHcalDepth6EnergyCalo

std::vector< double >	MuonHcalDepth6HotEnergy

std::vector< double >	MuonHcalDepth6HotEnergyCalo

std::vector< double >	MuonHcalDepth7Energy

std::vector< double >	MuonHcalDepth7EnergyCalo

std::vector< double >	MuonHcalDepth7HotEnergy

std::vector< double >	MuonHcalDepth7HotEnergyCalo

std::vector< unsigned int >	MuonHcalDetId

std::vector< double >	MuonHcalEnergy

std::vector< unsigned int >	MuonHcalHot

std::vector< unsigned int >	MuonHcalHotCalo

std::vector< double >	MuonHOEnergy

const edm::InputTag	muonsrc_

std::vector< double >	No_pixelLayers

std::vector< double >	NormChi2

std::vector< double >	NPvx

std::vector< double >	NPvy

std::vector< double >	NPvz

std::vector< double >	NQOverP

std::vector< double >	NQOverPError

std::vector< double >	NRefPointX

std::vector< double >	NRefPointY

std::vector< double >	NRefPointZ

int	ntriggers

std::vector< double >	NTrkMomentum

std::vector< double >	NumPixelLayers

std::vector< bool >	OuterTrack

std::vector< double >	OuterTrackChi

std::vector< double >	OuterTrackEta

std::vector< double >	OuterTrackHits

std::vector< double >	OuterTrackPhi

std::vector< double >	OuterTrackPt

std::vector< double >	OuterTrackRHits

std::vector< double >	PCharge

std::vector< double >	PChi2

std::vector< double >	PD0

std::vector< double >	PD0Error

std::vector< double >	PdxyTrack

std::vector< double >	PdzTrack

std::vector< double >	PhiGlob

std::vector< double >	PLostHits

std::vector< double >	Pmuon

std::vector< double >	PNDoF

std::vector< double >	PNormalizedChi2

std::vector< double >	PtGlob

std::vector< double >	Pthetha

std::vector< double >	PValidHits

std::vector< double >	PxGlob

std::vector< double >	PyGlob

std::vector< double >	PzGlob

unsigned int	RunNumber

std::vector< double >	Tight_GlobalMuonTrkFit

std::vector< double >	Tight_LongPara

std::vector< double >	Tight_MatchedStations

std::vector< double >	Tight_MuonHits

std::vector< double >	Tight_PixelHits

std::vector< double >	Tight_TransImpara

std::vector< double >	Tight_TrkerLayers

std::vector< float >	time_hb

edm::EDGetTokenT< reco::BeamSpot >	tok_bs_

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	tok_caloTopology_

edm::ESGetToken < HcalDDDRecConstants, HcalRecNumberingRecord >	tok_ddrec_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EB_

edm::ESGetToken < EcalChannelStatus, EcalChannelStatusRcd >	tok_ecalChStatus_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EE_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	tok_geom_

edm::EDGetTokenT < HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT < edm::PCaloHitContainer >	tok_hcal_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	tok_magField_

edm::EDGetTokenT < reco::MuonCollection >	tok_muon_

edm::EDGetTokenT < reco::VertexCollection >	tok_recVtx_

edm::ESGetToken < EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd >	tok_sevlv_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	tok_topo_

edm::EDGetTokenT < edm::TriggerResults >	tok_trigRes_

std::vector< double >	track_cosmic_detid

std::vector< double >	track_cosmic_detIDinner

std::vector< double >	track_cosmic_detIDouter

std::vector< double >	track_cosmic_momentumIX

std::vector< double >	track_cosmic_momentumIY

std::vector< double >	track_cosmic_momentumIZ

std::vector< double >	track_cosmic_momentumOX

std::vector< double >	track_cosmic_momentumOY

std::vector< double >	track_cosmic_momentumOZ

std::vector< double >	track_cosmic_positionIX

std::vector< double >	track_cosmic_positionIY

std::vector< double >	track_cosmic_positionIZ

std::vector< double >	track_cosmic_positionOX

std::vector< double >	track_cosmic_positionOY

std::vector< double >	track_cosmic_positionOZ

std::vector< double >	track_cosmic_rad

std::vector< double >	track_cosmic_xmomentum

std::vector< double >	track_cosmic_xposition

std::vector< double >	track_cosmic_ymomentum

std::vector< double >	track_cosmic_yposition

std::vector< double >	track_cosmic_zmomentum

std::vector< double >	track_cosmic_zposition

std::vector< double >	TrackerLayer

std::vector< double >	trackerlayer_hits

TTree *	TREE

std::vector< std::string >	TrigName_

std::vector< bool >	Trk_match_MuStat

int	type

const int	useRaw_

std::vector< double >	v_RH_h3x3_ene

std::vector< int >	v_RH_h3x3_ieta

std::vector< int >	v_RH_h3x3_iphi

const int	verbosity_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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 () noexcept

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

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 54 of file HcalRaddamMuon.cc.

Constructor & Destructor Documentation

HcalRaddamMuon::HcalRaddamMuon ( const edm::ParameterSet & iConfig )

explicit

Definition at line 153 of file HcalRaddamMuon.cc.

References edm::ParameterSet::getUntrackedParameter(), hlTriggerResults_, HLT_FULL_cff::InputTag, isAOD_, TFileService::kSharedResource, maxDepth_, muonsrc_, tok_bs_, tok_caloTopology_, tok_ddrec_, tok_EB_, tok_ecalChStatus_, tok_EE_, tok_geom_, tok_hbhe_, tok_hcal_, tok_magField_, tok_muon_, tok_recVtx_, tok_sevlv_, tok_topo_, and tok_trigRes_.

     : hlTriggerResults_(iConfig.getUntrackedParameter<edm::InputTag>("hlTriggerResults_")),
       muonsrc_(iConfig.getUntrackedParameter<edm::InputTag>("muonSource")),
       verbosity_(iConfig.getUntrackedParameter<int>("verbosity", 0)),
       useRaw_(iConfig.getUntrackedParameter<int>("UseRaw", 0)),
       isAOD_(iConfig.getUntrackedParameter<bool>("IsAOD", false)) {
   usesResource(TFileService::kSharedResource);
 
   //now do what ever initialization is needed
   maxDepth_ = iConfig.getUntrackedParameter<int>("MaxDepth", 4);
   if (maxDepth_ > 7)
     maxDepth_ = 7;
   else if (maxDepth_ < 1)
     maxDepth_ = 4;
 
   tok_hcal_ = consumes<edm::PCaloHitContainer>(edm::InputTag("g4SimHits", "HcalHits"));
   tok_trigRes_ = consumes<edm::TriggerResults>(hlTriggerResults_);
   tok_recVtx_ = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
   tok_bs_ = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
   if (isAOD_) {
     tok_EB_ = consumes<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEB"));
     tok_EE_ = consumes<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEE"));
     tok_hbhe_ = consumes<HBHERecHitCollection>(edm::InputTag("reducedHcalRecHits", "hbhereco"));
   } else {
     tok_EB_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
     tok_EE_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
     tok_hbhe_ = consumes<HBHERecHitCollection>(edm::InputTag("hbhereco"));
   }
   tok_muon_ = consumes<reco::MuonCollection>(muonsrc_);
 
   tok_ddrec_ = esConsumes<HcalDDDRecConstants, HcalRecNumberingRecord, edm::Transition::BeginRun>();
   tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
   tok_caloTopology_ = esConsumes<CaloTopology, CaloTopologyRecord>();
   tok_topo_ = esConsumes<HcalTopology, HcalRecNumberingRecord>();
   tok_magField_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
   tok_ecalChStatus_ = esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
   tok_sevlv_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
 }

HcalRaddamMuon::~HcalRaddamMuon ( )

override

Definition at line 192 of file HcalRaddamMuon.cc.

                                 {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

double HcalRaddamMuon::activeLength ( const DetId & id_ )

private

Definition at line 838 of file HcalRaddamMuon.cc.

References actHB, actHE, HLT_FULL_cff::depth, HcalBarrel, mps_fire::i, gpuClustering::id, and verbosity_.

Referenced by analyze().

                                                     {
   HcalDetId id(id_);
   int ieta = id.ietaAbs();
   int depth = id.depth();
   double lx(0);
   if (id.subdet() == HcalBarrel) {
     if (((verbosity_ / 10) % 10) > 2)
       edm::LogVerbatim("HBHEMuon") << "actHB.size() " << actHB.size();
     for (unsigned int i = 0; i < actHB.size(); ++i) {
       if (ieta == actHB[i].ieta && depth == actHB[i].depth) {
         lx = actHB[i].thick;
         break;
       }
     }
   } else {
     if (((verbosity_ / 10) % 10) > 2)
       edm::LogVerbatim("HBHEMuon") << "actHE.size() " << actHE.size();
     for (unsigned int i = 0; i < actHE.size(); ++i) {
       if (ieta == actHE[i].ieta && depth == actHE[i].depth) {
         lx = actHE[i].thick;
         break;
       }
     }
   }
   if (((verbosity_ / 10) % 10) > 2)
     edm::LogVerbatim("HBHEMuon") << "active thick " << lx;
   return lx;
 }

void HcalRaddamMuon::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 202 of file HcalRaddamMuon.cc.

                                                                                 {
   clearVectors();
   RunNumber = iEvent.id().run();
   EventNumber = iEvent.id().event();
   LumiNumber = iEvent.id().luminosityBlock();
   BXNumber = iEvent.bunchCrossing();
 
   edm::Handle<edm::PCaloHitContainer> calosimhits;
   iEvent.getByToken(tok_hcal_, calosimhits);
 
   edm::Handle<edm::TriggerResults> _Triggers;
   iEvent.getByToken(tok_trigRes_, _Triggers);
 
   if ((verbosity_ % 10) > 1)
     edm::LogVerbatim("HBHEMuon") << "size of all triggers " << all_triggers.size();
   int Ntriggers = all_triggers.size();
 
   if ((verbosity_ % 10) > 1)
     edm::LogVerbatim("HBHEMuon") << "size of HLT MENU: " << _Triggers->size();
 
   if (_Triggers.isValid()) {
     const edm::TriggerNames& triggerNames_ = iEvent.triggerNames(*_Triggers);
 
     std::vector<int> index;
     for (int i = 0; i < Ntriggers; i++) {
       index.push_back(triggerNames_.triggerIndex(all_triggers[i]));
       int triggerSize = int(_Triggers->size());
       if ((verbosity_ % 10) > 2)
         edm::LogVerbatim("HBHEMuon") << "outside loop " << index[i] << "\ntriggerSize " << triggerSize;
       if (index[i] < triggerSize) {
         hltresults.push_back(_Triggers->accept(index[i]));
         if ((verbosity_ % 10) > 2)
           edm::LogVerbatim("HBHEMuon") << "trigger_info " << triggerSize << " triggerSize " << index[i]
                                        << " trigger_index " << hltresults.at(i) << " hltresult ";
       } else {
         edm::LogVerbatim("HBHEMuon") << "Requested HLT path \""
                                      << "\" does not exist";
       }
     }
   }
 
   // get handles to calogeometry and calotopology
   const CaloGeometry* geo = &iSetup.getData(tok_geom_);
   const MagneticField* bField = &iSetup.getData(tok_magField_);
   const EcalChannelStatus* theEcalChStatus = &iSetup.getData(tok_ecalChStatus_);
   const EcalSeverityLevelAlgo* sevlv = &iSetup.getData(tok_sevlv_);
   const CaloTopology* caloTopology = &iSetup.getData(tok_caloTopology_);
   const HcalTopology* theHBHETopology = &iSetup.getData(tok_topo_);
 
   edm::Handle<reco::BeamSpot> bmspot;
   iEvent.getByToken(tok_bs_, bmspot);
 
   edm::Handle<reco::VertexCollection> vtx;
   iEvent.getByToken(tok_recVtx_, vtx);
 
   edm::Handle<EcalRecHitCollection> barrelRecHitsHandle;
   edm::Handle<EcalRecHitCollection> endcapRecHitsHandle;
   iEvent.getByToken(tok_EB_, barrelRecHitsHandle);
   iEvent.getByToken(tok_EE_, endcapRecHitsHandle);
 
   edm::Handle<HBHERecHitCollection> hbhe;
   iEvent.getByToken(tok_hbhe_, hbhe);
 
   edm::Handle<reco::MuonCollection> _Muon;
   iEvent.getByToken(tok_muon_, _Muon);
   const reco::Vertex& vertex = (*(vtx)->begin());
 
   math::XYZPoint bspot;
   bspot = (bmspot.isValid()) ? bmspot->position() : math::XYZPoint(0, 0, 0);
 
   if (_Muon.isValid()) {
     for (reco::MuonCollection::const_iterator RecMuon = _Muon->begin(); RecMuon != _Muon->end(); ++RecMuon) {
       muon_is_good.push_back(RecMuon->isPFMuon());
       muon_global.push_back(RecMuon->isGlobalMuon());
       muon_tracker.push_back(RecMuon->isTrackerMuon());
       PtGlob.push_back((RecMuon)->pt());
       EtaGlob.push_back(RecMuon->eta());
       PhiGlob.push_back(RecMuon->phi());
       Energy.push_back(RecMuon->energy());
       Pmuon.push_back(RecMuon->p());
       //      if (RecMuon->isPFMuon()) goodEvent = true;
       // acessing tracker hits info
       if (RecMuon->track().isNonnull()) {
         TrackerLayer.push_back(RecMuon->track()->hitPattern().trackerLayersWithMeasurement());
       } else {
         TrackerLayer.push_back(-1);
       }
       if (RecMuon->innerTrack().isNonnull()) {
         innerTrack.push_back(true);
         NumPixelLayers.push_back(RecMuon->innerTrack()->hitPattern().pixelLayersWithMeasurement());
         chiTracker.push_back(RecMuon->innerTrack()->normalizedChi2());
         DxyTracker.push_back(fabs(RecMuon->innerTrack()->dxy((vertex).position())));
         DzTracker.push_back(fabs(RecMuon->innerTrack()->dz((vertex).position())));
         innerTrackpt.push_back(RecMuon->innerTrack()->pt());
         innerTracketa.push_back(RecMuon->innerTrack()->eta());
         innerTrackphi.push_back(RecMuon->innerTrack()->phi());
         Tight_PixelHits.push_back(RecMuon->innerTrack()->hitPattern().numberOfValidPixelHits());
       } else {
         innerTrack.push_back(false);
         NumPixelLayers.push_back(0);
         chiTracker.push_back(0);
         DxyTracker.push_back(0);
         DzTracker.push_back(0);
         innerTrackpt.push_back(0);
         innerTracketa.push_back(0);
         innerTrackphi.push_back(0);
         Tight_PixelHits.push_back(0);
       }
       // outer track info
 
       if (RecMuon->outerTrack().isNonnull()) {
         OuterTrack.push_back(true);
         OuterTrackPt.push_back(RecMuon->outerTrack()->pt());
         OuterTrackEta.push_back(RecMuon->outerTrack()->eta());
         OuterTrackPhi.push_back(RecMuon->outerTrack()->phi());
         OuterTrackChi.push_back(RecMuon->outerTrack()->normalizedChi2());
         OuterTrackHits.push_back(RecMuon->outerTrack()->numberOfValidHits());
         OuterTrackRHits.push_back(RecMuon->outerTrack()->recHitsSize());
       } else {
         OuterTrack.push_back(false);
         OuterTrackPt.push_back(0);
         OuterTrackEta.push_back(0);
         OuterTrackPhi.push_back(0);
         OuterTrackChi.push_back(0);
         OuterTrackHits.push_back(0);
         OuterTrackRHits.push_back(0);
       }
       // Tight Muon cuts
       if (RecMuon->globalTrack().isNonnull()) {
         GlobalTrack.push_back(true);
         chiGlobal.push_back(RecMuon->globalTrack()->normalizedChi2());
         GlobalMuonHits.push_back(RecMuon->globalTrack()->hitPattern().numberOfValidMuonHits());
         MatchedStat.push_back(RecMuon->numberOfMatchedStations());
         GlobalTrckPt.push_back(RecMuon->globalTrack()->pt());
         GlobalTrckEta.push_back(RecMuon->globalTrack()->eta());
         GlobalTrckPhi.push_back(RecMuon->globalTrack()->phi());
         Tight_TransImpara.push_back(fabs(RecMuon->muonBestTrack()->dxy(vertex.position())));
         Tight_LongPara.push_back(fabs(RecMuon->muonBestTrack()->dz(vertex.position())));
       } else {
         GlobalTrack.push_back(false);
         chiGlobal.push_back(0);
         GlobalMuonHits.push_back(0);
         MatchedStat.push_back(0);
         GlobalTrckPt.push_back(0);
         GlobalTrckEta.push_back(0);
         GlobalTrckPhi.push_back(0);
         Tight_TransImpara.push_back(0);
         Tight_LongPara.push_back(0);
       }
 
       IsolationR04.push_back(
           ((RecMuon->pfIsolationR04().sumChargedHadronPt +
             std::max(0.,
                      RecMuon->pfIsolationR04().sumNeutralHadronEt + RecMuon->pfIsolationR04().sumPhotonEt -
                          (0.5 * RecMuon->pfIsolationR04().sumPUPt))) /
            RecMuon->pt()));
 
       IsolationR03.push_back(
           ((RecMuon->pfIsolationR03().sumChargedHadronPt +
             std::max(0.,
                      RecMuon->pfIsolationR03().sumNeutralHadronEt + RecMuon->pfIsolationR03().sumPhotonEt -
                          (0.5 * RecMuon->pfIsolationR03().sumPUPt))) /
            RecMuon->pt()));
 
       MuonEcalEnergy.push_back(RecMuon->calEnergy().emS9);
       MuonHcalEnergy.push_back(RecMuon->calEnergy().hadS9);
       MuonHOEnergy.push_back(RecMuon->calEnergy().hoS9);
 
       double eEcal(0), eHcal(0), activeL(0), eHcalDepth[7], eHcalDepthHot[7], eHcalDepthCalo[7], eHcalDepthHotCalo[7];
       unsigned int isHot = 0;
       unsigned int isHotCalo = 0;
 
       for (int i = 0; i < 7; ++i)
         eHcalDepth[i] = eHcalDepthHot[i] = eHcalDepthCalo[i] = eHcalDepthHotCalo[i] = -10000;
 
       if (RecMuon->innerTrack().isNonnull()) {
         const reco::Track* pTrack = (RecMuon->innerTrack()).get();
         spr::propagatedTrackID trackID = spr::propagateCALO(pTrack, geo, bField, (((verbosity_ / 100) % 10 > 0)));
 
         MuonEcalDetId.push_back((trackID.detIdECAL)());
         MuonHcalDetId.push_back((trackID.detIdHCAL)());
         MuonEHcalDetId.push_back((trackID.detIdEHCAL)());
 
         if (trackID.okECAL) {
           const DetId isoCell(trackID.detIdECAL);
           std::pair<double, bool> e3x3 = spr::eECALmatrix(isoCell,
                                                           barrelRecHitsHandle,
                                                           endcapRecHitsHandle,
                                                           *theEcalChStatus,
                                                           geo,
                                                           caloTopology,
                                                           sevlv,
                                                           1,
                                                           1,
                                                           -100.0,
                                                           -100.0,
                                                           -500.0,
                                                           500.0,
                                                           false);
 
           eEcal = e3x3.first;
           if (((verbosity_ / 10) % 10) > 1)
             edm::LogVerbatim("HBHEMuon") << "eEcal" << eEcal;
         }
 
         if (trackID.okHCAL) {
           const DetId closestCell(trackID.detIdHCAL);
           eHcal = spr::eHCALmatrix(theHBHETopology,
                                    closestCell,
                                    hbhe,
                                    0,
                                    0,
                                    false,
                                    true,
                                    -100.0,
                                    -100.0,
                                    -100.0,
                                    -100.0,
                                    -500.,
                                    500.,
                                    useRaw_);
 
           int iphi = ((HcalDetId)(closestCell)).iphi();
           int zside = ((HcalDetId)(closestCell)).iphi();
           int depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
           if (((verbosity_ / 10) % 10) > 1)
             edm::LogVerbatim("HBHEMuon") << "eHcal " << eHcal;
           std::vector<std::pair<double, int> > ehdepth;
           spr::energyHCALCell((HcalDetId)closestCell,
                               hbhe,
                               ehdepth,
                               maxDepth_,
                               -100.0,
                               -100.0,
                               -100.0,
                               -100.0,
                               -500.0,
                               500.0,
                               useRaw_,
                               depthHE,
                               (((verbosity_ / 1000) % 10) > 0));
           for (unsigned int i = 0; i < ehdepth.size(); ++i) {
             eHcalDepth[ehdepth[i].second - 1] = ehdepth[i].first;
             if (((verbosity_ / 10) % 10) > 1)
               edm::LogVerbatim("HBHEMuon")
                   << "eHcalDepth " << i << ":" << (ehdepth[i].second - 1) << ":" << eHcalDepth[ehdepth[i].second - 1];
           }
 
           eHcal = spr::eHCALmatrix(theHBHETopology,
                                    closestCell,
                                    calosimhits,
                                    0,
                                    0,
                                    false,
                                    true,
                                    -100.0,
                                    -100.0,
                                    -100.0,
                                    -100.0,
                                    -500.,
                                    500.,
                                    useRaw_);
 
           if (((verbosity_ / 10) % 10) > 1)
             edm::LogVerbatim("HBHEMuon") << "eHcal " << eHcal;
           const DetId closestCellCalo(trackID.detIdHCAL);
           iphi = ((HcalDetId)(closestCellCalo)).iphi();
           zside = ((HcalDetId)(closestCellCalo)).iphi();
           depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
           std::vector<std::pair<double, int> > ehdepthCalo;
           spr::energyHCALCell((HcalDetId)closestCellCalo,
                               calosimhits,
                               ehdepthCalo,
                               maxDepth_,
                               -100.0,
                               -100.0,
                               -100.0,
                               -100.0,
                               -500.0,
                               500.0,
                               useRaw_,
                               depthHE,
                               (((verbosity_ / 1000) % 10) > 0));
           for (unsigned int i = 0; i < ehdepthCalo.size(); ++i) {
             eHcalDepthCalo[ehdepthCalo[i].second - 1] = ehdepthCalo[i].first;
             if (((verbosity_ / 10) % 10) > 1)
               edm::LogVerbatim("HBHEMuon") << "eHcalDepthCalo " << i << ":" << (ehdepth[i].second - 1) << ":"
                                            << eHcalDepth[ehdepth[i].second - 1];
           }
 
           HcalDetId hcid0(closestCell.rawId());
           activeL = activeLength(trackID.detIdHCAL);
 
           if (((verbosity_ / 10) % 10) > 0)
             edm::LogVerbatim("HBHEMuon") << "activeL " << activeL;
           HcalDetId hotCell, hotCellCalo;
           h3x3 = spr::eHCALmatrix(geo, theHBHETopology, closestCell, hbhe, 1, 1, hotCell, false, useRaw_, false);
           h3x3Calo = spr::eHCALmatrix(
               geo, theHBHETopology, closestCellCalo, calosimhits, 1, 1, hotCellCalo, false, useRaw_, false);
 
           isHot = matchId(closestCell, hotCell);
           isHotCalo = matchId(closestCellCalo, hotCellCalo);
 
           if (((verbosity_ / 10) % 10) > 1)
             edm::LogVerbatim("HBHEMuon") << "hcal 3X3  < " << h3x3 << ">"
                                          << " ClosestCell <" << (HcalDetId)(closestCell) << "> hotCell id < " << hotCell
                                          << "> isHot" << isHot;
           if (hotCell != HcalDetId()) {
             iphi = ((HcalDetId)(hotCell)).iphi();
             zside = ((HcalDetId)(hotCell)).iphi();
             depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
             std::vector<std::pair<double, int> > ehdepth;
             spr::energyHCALCell(hotCell,
                                 hbhe,
                                 ehdepth,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 depthHE,
                                 false);  //(((verbosity_/1000)%10)>0));
             for (unsigned int i = 0; i < ehdepth.size(); ++i) {
               eHcalDepthHot[ehdepth[i].second - 1] = ehdepth[i].first;
               if (((verbosity_ / 10) % 10) > 1)
                 edm::LogVerbatim("HBHEMuon") << "eHcalDepthHot " << i << ":" << (ehdepth[i].second - 1) << ":"
                                              << eHcalDepthHot[ehdepth[i].second - 1];
             }
           }
 
           if (hotCellCalo != HcalDetId()) {
             iphi = ((HcalDetId)(hotCellCalo)).iphi();
             zside = ((HcalDetId)(hotCellCalo)).iphi();
             depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
             std::vector<std::pair<double, int> > ehdepthCalo;
 
             spr::energyHCALCell(hotCellCalo,
                                 calosimhits,
                                 ehdepthCalo,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 useRaw_,
                                 depthHE,
                                 false);
             for (unsigned int i = 0; i < ehdepthCalo.size(); ++i) {
               eHcalDepthHotCalo[ehdepthCalo[i].second - 1] = ehdepthCalo[i].first;
               if (((verbosity_ / 10) % 10) > 1)
                 edm::LogVerbatim("HBHEMuon") << "eHcalDepthHotCalo " << i << ":" << (ehdepth[i].second - 1) << ":"
                                              << eHcalDepthHot[ehdepth[i].second - 1];
             }
           }
         }
       } else {
         MuonEcalDetId.push_back(0);
         MuonHcalDetId.push_back(0);
         MuonEHcalDetId.push_back(0);
       }
 
       MuonEcal3x3Energy.push_back(eEcal);
       MuonHcal1x1Energy.push_back(eHcal);
       MuonHcalDepth1Energy.push_back(eHcalDepth[0]);
       MuonHcalDepth2Energy.push_back(eHcalDepth[1]);
       MuonHcalDepth3Energy.push_back(eHcalDepth[2]);
       MuonHcalDepth4Energy.push_back(eHcalDepth[3]);
       MuonHcalDepth5Energy.push_back(eHcalDepth[4]);
       MuonHcalDepth6Energy.push_back(eHcalDepth[5]);
       MuonHcalDepth7Energy.push_back(eHcalDepth[6]);
       MuonHcalDepth1HotEnergy.push_back(eHcalDepthHot[0]);
       MuonHcalDepth2HotEnergy.push_back(eHcalDepthHot[1]);
       MuonHcalDepth3HotEnergy.push_back(eHcalDepthHot[2]);
       MuonHcalDepth4HotEnergy.push_back(eHcalDepthHot[3]);
       MuonHcalDepth5HotEnergy.push_back(eHcalDepthHot[4]);
       MuonHcalDepth6HotEnergy.push_back(eHcalDepthHot[5]);
       MuonHcalDepth7HotEnergy.push_back(eHcalDepthHot[6]);
       MuonHcalHot.push_back(isHot);
 
       //
       MuonHcalDepth1EnergyCalo.push_back(eHcalDepthCalo[0]);
       MuonHcalDepth2EnergyCalo.push_back(eHcalDepthCalo[1]);
       MuonHcalDepth3EnergyCalo.push_back(eHcalDepthCalo[2]);
       MuonHcalDepth4EnergyCalo.push_back(eHcalDepthCalo[3]);
       MuonHcalDepth5EnergyCalo.push_back(eHcalDepthCalo[4]);
       MuonHcalDepth6EnergyCalo.push_back(eHcalDepthCalo[5]);
       MuonHcalDepth7EnergyCalo.push_back(eHcalDepthCalo[6]);
       MuonHcalDepth1HotEnergyCalo.push_back(eHcalDepthHotCalo[0]);
       MuonHcalDepth2HotEnergyCalo.push_back(eHcalDepthHotCalo[1]);
       MuonHcalDepth3HotEnergyCalo.push_back(eHcalDepthHotCalo[2]);
       MuonHcalDepth4HotEnergyCalo.push_back(eHcalDepthHotCalo[3]);
       MuonHcalDepth5HotEnergyCalo.push_back(eHcalDepthHotCalo[4]);
       MuonHcalDepth6HotEnergyCalo.push_back(eHcalDepthHotCalo[5]);
       MuonHcalDepth7HotEnergyCalo.push_back(eHcalDepthHotCalo[6]);
       MuonHcalHotCalo.push_back(isHotCalo);
 
       //
       MuonHcalActiveLength.push_back(activeL);
     }
   }
   TREE->Fill();
 }

void HcalRaddamMuon::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 610 of file HcalRaddamMuon.cc.

                               {
   TREE = fs->make<TTree>("TREE", "TREE");
   TREE->Branch("Event_No", &EventNumber);
   TREE->Branch("Run_No", &RunNumber);
   TREE->Branch("LumiNumber", &LumiNumber);
   TREE->Branch("BXNumber", &BXNumber);
   TREE->Branch("pt_of_muon", &PtGlob);
   TREE->Branch("eta_of_muon", &EtaGlob);
   TREE->Branch("phi_of_muon", &PhiGlob);
   TREE->Branch("energy_of_muon", &Energy);
   TREE->Branch("p_of_muon", &Pmuon);
   TREE->Branch("PF_Muon", &muon_is_good);
   TREE->Branch("Global_Muon", &muon_global);
   TREE->Branch("Tracker_muon", &muon_tracker);
 
   TREE->Branch("hcal_3into3", &MuonHcalEnergy);
   TREE->Branch("hcal_1x1", &MuonHcal1x1Energy);
   TREE->Branch("hcal_detID", &MuonHcalDetId);
   TREE->Branch("hcal_edepth1", &MuonHcalDepth1Energy);
   TREE->Branch("hcal_edepth2", &MuonHcalDepth2Energy);
   TREE->Branch("hcal_edepth3", &MuonHcalDepth3Energy);
   TREE->Branch("hcal_edepth4", &MuonHcalDepth4Energy);
   TREE->Branch("hcal_edepthHot1", &MuonHcalDepth1HotEnergy);
   TREE->Branch("hcal_edepthHot2", &MuonHcalDepth2HotEnergy);
   TREE->Branch("hcal_edepthHot3", &MuonHcalDepth3HotEnergy);
   TREE->Branch("hcal_edepthHot4", &MuonHcalDepth4HotEnergy);
 
   TREE->Branch("hcal_edepth1PSim", &MuonHcalDepth1EnergyCalo);
   TREE->Branch("hcal_edepth2PSim", &MuonHcalDepth2EnergyCalo);
   TREE->Branch("hcal_edepth3PSim", &MuonHcalDepth3EnergyCalo);
   TREE->Branch("hcal_edepth4PSim", &MuonHcalDepth4EnergyCalo);
   TREE->Branch("hcal_edepthHot1PSim", &MuonHcalDepth1HotEnergyCalo);
   TREE->Branch("hcal_edepthHot2PSim", &MuonHcalDepth2HotEnergyCalo);
   TREE->Branch("hcal_edepthHot3PSim", &MuonHcalDepth3HotEnergyCalo);
   TREE->Branch("hcal_edepthHot4PSim", &MuonHcalDepth4HotEnergyCalo);
 
   if (maxDepth_ > 4) {
     TREE->Branch("hcal_edepth5PSim", &MuonHcalDepth5EnergyCalo);
     TREE->Branch("hcal_edepthHot5PSim", &MuonHcalDepth5HotEnergyCalo);
     if (maxDepth_ > 5) {
       TREE->Branch("hcal_edepth6PSim", &MuonHcalDepth6EnergyCalo);
       TREE->Branch("hcal_edepthHot6PSim", &MuonHcalDepth6HotEnergyCalo);
       if (maxDepth_ > 6) {
         TREE->Branch("hcal_edepth7PSim", &MuonHcalDepth7EnergyCalo);
         TREE->Branch("hcal_edepthHot7PSim", &MuonHcalDepth7HotEnergyCalo);
       }
     }
   }
 
   TREE->Branch("TrackerLayer", &TrackerLayer);
   TREE->Branch("innerTrack", &innerTrack);
   TREE->Branch("innerTrackpt", &innerTrackpt);
   TREE->Branch("innerTracketa", &innerTracketa);
   TREE->Branch("innerTrackphi", &innerTrackphi);
   TREE->Branch("MatchedStat", &MatchedStat);
   TREE->Branch("GlobalTrckPt", &GlobalTrckPt);
   TREE->Branch("GlobalTrckEta", &GlobalTrckEta);
   TREE->Branch("GlobalTrckPhi", &GlobalTrckPhi);
   TREE->Branch("NumPixelLayers", &NumPixelLayers);
   TREE->Branch("chiTracker", &chiTracker);
   TREE->Branch("DxyTracker", &DxyTracker);
   TREE->Branch("DzTracker", &DzTracker);
   TREE->Branch("OuterTrack", &OuterTrack);
   TREE->Branch("OuterTrackPt", &OuterTrackPt);
   TREE->Branch("OuterTrackEta", &OuterTrackEta);
   TREE->Branch("OuterTrackPhi", &OuterTrackPhi);
   TREE->Branch("OuterTrackHits", &OuterTrackHits);
   TREE->Branch("OuterTrackRHits", &OuterTrackRHits);
   TREE->Branch("OuterTrackChi", &OuterTrackChi);
   TREE->Branch("GlobalTrack", &GlobalTrack);
   TREE->Branch("GlobTrack_Chi", &chiGlobal);
   TREE->Branch("Global_Muon_Hits", &GlobalMuonHits);
   TREE->Branch("MatchedStations", &MatchedStat);
   TREE->Branch("Global_Track_Pt", &GlobalTrckPt);
   TREE->Branch("Global_Track_Eta", &GlobalTrckEta);
   TREE->Branch("Global_Track_Phi", &GlobalTrckPhi);
   TREE->Branch("Tight_LongitudinalImpactparameter", &Tight_LongPara);
   TREE->Branch("Tight_TransImpactparameter", &Tight_TransImpara);
   TREE->Branch("InnerTrackPixelHits", &Tight_PixelHits);
   TREE->Branch("IsolationR04", &IsolationR04);
   TREE->Branch("IsolationR03", &IsolationR03);
 
   TREE->Branch("hcal_cellHot", &MuonHcalHot);
   TREE->Branch("hcal_cellHotPSim", &MuonHcalHotCalo);
 
   TREE->Branch("ecal_3into3", &MuonEcalEnergy);
   TREE->Branch("ecal_3x3", &MuonEcal3x3Energy);
   TREE->Branch("ecal_detID", &MuonEcalDetId);
   TREE->Branch("ehcal_detID", &MuonEHcalDetId);
   TREE->Branch("tracker_3into3", &MuonHOEnergy);
   TREE->Branch("activeLength", &MuonHcalActiveLength);
 
   TREE->Branch("hltresults", &hltresults);
   TREE->Branch("all_triggers", &all_triggers);
   TREE->Branch("rechit_energy", &energy_hb);
   TREE->Branch("rechit_time", &time_hb);
 }

void HcalRaddamMuon::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 714 of file HcalRaddamMuon.cc.

References actHB, actHE, all_triggers, edm::EventSetup::getData(), HcalDDDRecConstants::getThickActive(), hltConfig_, HLTConfigProvider::init(), ntriggers, HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, tok_ddrec_, and HLTConfigProvider::triggerName().

                                                                              {
   const HcalDDDRecConstants* hdc = &iSetup.getData(tok_ddrec_);
   actHB.clear();
   actHE.clear();
   actHB = hdc->getThickActive(0);
   actHE = hdc->getThickActive(1);
 
   bool changed = true;
   all_triggers.clear();
   if (hltConfig_.init(iRun, iSetup, "HLT", changed)) {
     // if init returns TRUE, initialisation has succeeded!
     edm::LogVerbatim("HBHEMuon") << "HLT config with process name 'HLT' successfully extracted";
     std::string string_search[5] = {"HLT_IsoMu_", "HLT_L1SingleMu_", "HLT_L2Mu", "HLT_Mu", "HLT_RelIso1p0Mu"};
     unsigned int ntriggers = hltConfig_.size();
     for (unsigned int t = 0; t < ntriggers; ++t) {
       std::string hltname(hltConfig_.triggerName(t));
       for (unsigned int ik = 0; ik < 5; ++ik) {
         if (hltname.find(string_search[ik]) != std::string::npos) {
           all_triggers.push_back(hltname);
           break;
         }
       }
     }  //loop over ntriggers
     edm::LogVerbatim("HBHEMuon") << "All triggers size in begin run" << all_triggers.size();
   } else {
     edm::LogError("HBHEMuon") << "Error! HLT config extraction with process name 'HLT' failed";
   }
 
 }  //firstmethod

void HcalRaddamMuon::clearVectors ( )

private

clearing vectots

Definition at line 758 of file HcalRaddamMuon.cc.

Referenced by analyze().

                                   {
   EventNumber = -99999;
   RunNumber = -99999;
   LumiNumber = -99999;
   BXNumber = -99999;
   energy_hb.clear();
   time_hb.clear();
   muon_is_good.clear();
   muon_global.clear();
   muon_tracker.clear();
   PtGlob.clear();
   EtaGlob.clear();
   PhiGlob.clear();
   Energy.clear();
   Pmuon.clear();
   TrackerLayer.clear();
   innerTrack.clear();
   NumPixelLayers.clear();
   chiTracker.clear();
   DxyTracker.clear();
   DzTracker.clear();
   innerTrackpt.clear();
   innerTracketa.clear();
   innerTrackphi.clear();
   Tight_PixelHits.clear();
   OuterTrack.clear();
   OuterTrackPt.clear();
   OuterTrackEta.clear();
   OuterTrackPhi.clear();
   OuterTrackHits.clear();
   OuterTrackRHits.clear();
   OuterTrackChi.clear();
   GlobalTrack.clear();
   chiGlobal.clear();
   GlobalMuonHits.clear();
   MatchedStat.clear();
   GlobalTrckPt.clear();
   GlobalTrckEta.clear();
   GlobalTrckPhi.clear();
   Tight_TransImpara.clear();
   Tight_LongPara.clear();
 
   IsolationR04.clear();
   IsolationR03.clear();
   MuonEcalEnergy.clear();
   MuonHcalEnergy.clear();
   MuonHOEnergy.clear();
   MuonEcalDetId.clear();
   MuonHcalDetId.clear();
   MuonEHcalDetId.clear();
   MuonEcal3x3Energy.clear();
   MuonHcal1x1Energy.clear();
   MuonHcalDepth1Energy.clear();
   MuonHcalDepth2Energy.clear();
   MuonHcalDepth3Energy.clear();
   MuonHcalDepth4Energy.clear();
   MuonHcalDepth5Energy.clear();
   MuonHcalDepth6Energy.clear();
   MuonHcalDepth7Energy.clear();
 
   MuonHcalDepth1HotEnergy.clear();
   MuonHcalDepth2HotEnergy.clear();
   MuonHcalDepth3HotEnergy.clear();
   MuonHcalDepth4HotEnergy.clear();
   MuonHcalDepth5HotEnergy.clear();
   MuonHcalDepth6HotEnergy.clear();
   MuonHcalDepth7HotEnergy.clear();
   MuonHcalHot.clear();
   MuonHcalActiveLength.clear();
   hltresults.clear();
 }

void HcalRaddamMuon::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 711 of file HcalRaddamMuon.cc.

Referenced by o2olib.O2ORunMgr::executeJob().

711 {}

void HcalRaddamMuon::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 745 of file HcalRaddamMuon.cc.

745 {}

void HcalRaddamMuon::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 747 of file HcalRaddamMuon.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

                                                                                 {
   edm::ParameterSetDescription desc;
   desc.addUntracked<edm::InputTag>("hlTriggerResults", edm::InputTag("TriggerResults", "", "HLT"));
   desc.addUntracked<edm::InputTag>("muonSource", edm::InputTag("muons"));
   desc.addUntracked<int>("verbosity", 0);
   desc.addUntracked<int>("useRaw", 0);
   desc.add<bool>("isAOD", false);
   desc.addUntracked<int>("maxDepth", 4);
   descriptions.add("hcalRaddamMuon", desc);
 }

int HcalRaddamMuon::matchId	(	const HcalDetId &	id1,
		const HcalDetId &	id2
	)

private

Definition at line 831 of file HcalRaddamMuon.cc.

References HcalDetId::ieta(), HcalDetId::iphi(), match(), and HcalDetId::subdet().

Referenced by analyze().

                                                                       {
   HcalDetId kd1(id1.subdet(), id1.ieta(), id1.iphi(), 1);
   HcalDetId kd2(id2.subdet(), id2.ieta(), id2.iphi(), 1);
   int match = ((kd1 == kd2) ? 1 : 0);
   return match;
 }

Member Data Documentation

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_03

private

Definition at line 130 of file HcalRaddamMuon.cc.

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_04

private

Definition at line 130 of file HcalRaddamMuon.cc.

std::vector<HcalDDDRecConstants::HcalActiveLength> HcalRaddamMuon::actHB

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

std::vector<HcalDDDRecConstants::HcalActiveLength> HcalRaddamMuon::actHE

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

std::vector<bool> HcalRaddamMuon::all_ifTriggerpassed

private

Definition at line 118 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::all_triggers

private

Definition at line 113 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and beginRun().

std::vector<std::string> HcalRaddamMuon::all_triggers1

private

Definition at line 113 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::all_triggers2

private

Definition at line 113 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::all_triggers3

private

Definition at line 113 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::all_triggers4

private

Definition at line 113 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::all_triggers5

private

Definition at line 113 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::BXNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::chiGlobal

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::chiTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::DxyTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::dxyWithBS

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::DzTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::dzWithBS

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<float> HcalRaddamMuon::energy_hb

private

Definition at line 121 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::EtaGlob

private

Definition at line 78 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

unsigned int HcalRaddamMuon::EventNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

edm::Service<TFileService> HcalRaddamMuon::fs

private

Definition at line 106 of file HcalRaddamMuon.cc.

Referenced by beginJob().

std::vector<double> HcalRaddamMuon::GlobalMuonHits

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<bool> HcalRaddamMuon::GlobalTrack

private

Definition at line 86 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::GlobalTrckEta

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::GlobalTrckPhi

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::GlobalTrckPt

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

double HcalRaddamMuon::h3x3

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by analyze().

double HcalRaddamMuon::h3x3Calo

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by analyze().

std::vector<double> HcalRaddamMuon::High_TrackLayers

private

Definition at line 84 of file HcalRaddamMuon.cc.

HLTConfigProvider HcalRaddamMuon::hltConfig_

private

Definition at line 108 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::string HcalRaddamMuon::hltlabel_

private

Definition at line 112 of file HcalRaddamMuon.cc.

std::vector<std::string> HcalRaddamMuon::hltpaths

private

Definition at line 122 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::hltresults

private

Definition at line 120 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

const edm::InputTag HcalRaddamMuon::hlTriggerResults_

private

Definition at line 109 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::ImpactParameter

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::innerTrack

private

Definition at line 86 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), clearVectors(), Lepton.Lepton::lostInner(), and Muon.Muon::muonID().

std::vector<double> HcalRaddamMuon::innerTracketa

private

Definition at line 80 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::innerTrackphi

private

Definition at line 80 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::innerTrackpt

private

Definition at line 80 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

const bool HcalRaddamMuon::isAOD_

private

Definition at line 111 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<bool> HcalRaddamMuon::isHB

private

Definition at line 116 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::isHE

private

Definition at line 116 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::IsolationR03

private

Definition at line 87 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::IsolationR04

private

Definition at line 87 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

unsigned int HcalRaddamMuon::LumiNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MatchedStat

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

int HcalRaddamMuon::maxDepth_

private

Definition at line 105 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and HcalRaddamMuon().

std::vector<bool> HcalRaddamMuon::muon_global

private

Definition at line 119 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<bool> HcalRaddamMuon::muon_is_good

private

Definition at line 119 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<bool> HcalRaddamMuon::muon_tracker

private

Definition at line 119 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonEcal3x3Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<unsigned int> HcalRaddamMuon::MuonEcalDetId

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonEcalEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<unsigned int> HcalRaddamMuon::MuonEHcalDetId

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcal1x1Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalActiveLength

private

Definition at line 103 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<unsigned int> HcalRaddamMuon::MuonHcalDetId

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<unsigned int> HcalRaddamMuon::MuonHcalHot

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<unsigned int> HcalRaddamMuon::MuonHcalHotCalo

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHOEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

const edm::InputTag HcalRaddamMuon::muonsrc_

private

Definition at line 109 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::No_pixelLayers

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NormChi2

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvx

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvy

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvz

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverP

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverPError

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointX

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointY

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointZ

private

Definition at line 126 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::ntriggers

private

Definition at line 131 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::vector<double> HcalRaddamMuon::NTrkMomentum

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NumPixelLayers

private

Definition at line 81 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<bool> HcalRaddamMuon::OuterTrack

private

Definition at line 86 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackChi

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackEta

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackHits

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackPhi

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackPt

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::OuterTrackRHits

private

Definition at line 82 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::PCharge

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PChi2

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0Error

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdxyTrack

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdzTrack

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PhiGlob

private

Definition at line 79 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::PLostHits

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Pmuon

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::PNDoF

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PNormalizedChi2

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PtGlob

private

Definition at line 72 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::Pthetha

private

Definition at line 125 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PValidHits

private

Definition at line 126 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PxGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PyGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PzGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::RunNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::Tight_GlobalMuonTrkFit

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_LongPara

private

Definition at line 84 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::Tight_MatchedStations

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_MuonHits

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_PixelHits

private

Definition at line 84 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::Tight_TransImpara

private

Definition at line 84 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::Tight_TrkerLayers

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<float> HcalRaddamMuon::time_hb

private

Definition at line 121 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

edm::EDGetTokenT<reco::BeamSpot> HcalRaddamMuon::tok_bs_

private

Definition at line 138 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<CaloTopology, CaloTopologyRecord> HcalRaddamMuon::tok_caloTopology_

private

Definition at line 146 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> HcalRaddamMuon::tok_ddrec_

private

Definition at line 144 of file HcalRaddamMuon.cc.

Referenced by beginRun(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EB_

private

Definition at line 139 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> HcalRaddamMuon::tok_ecalChStatus_

private

Definition at line 149 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EE_

private

Definition at line 140 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> HcalRaddamMuon::tok_geom_

private

Definition at line 145 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<HBHERecHitCollection> HcalRaddamMuon::tok_hbhe_

private

Definition at line 141 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<edm::PCaloHitContainer> HcalRaddamMuon::tok_hcal_

private

Definition at line 135 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> HcalRaddamMuon::tok_magField_

private

Definition at line 148 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<reco::MuonCollection> HcalRaddamMuon::tok_muon_

private

Definition at line 142 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<reco::VertexCollection> HcalRaddamMuon::tok_recVtx_

private

Definition at line 137 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd> HcalRaddamMuon::tok_sevlv_

private

Definition at line 150 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> HcalRaddamMuon::tok_topo_

private

Definition at line 147 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<edm::TriggerResults> HcalRaddamMuon::tok_trigRes_

private

Definition at line 136 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::track_cosmic_detid

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDinner

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDouter

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIX

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIY

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIZ

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOX

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOY

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOZ

private

Definition at line 75 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIX

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIY

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIZ

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOX

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOY

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOZ

private

Definition at line 72 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_rad

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xmomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_ymomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_yposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zmomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::TrackerLayer

private

Definition at line 80 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::trackerlayer_hits

private

Definition at line 83 of file HcalRaddamMuon.cc.

TTree* HcalRaddamMuon::TREE

private

Definition at line 117 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<std::string> HcalRaddamMuon::TrigName_

private

Definition at line 122 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::Trk_match_MuStat

private

Definition at line 119 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::type

private

Definition at line 105 of file HcalRaddamMuon.cc.

Referenced by core.autovars.NTupleVariable::makeBranch(), DQM.DQMReader::read_objects(), and core.AutoHandle.AutoHandle::ReallyLoad().

const int HcalRaddamMuon::useRaw_

private

Definition at line 110 of file HcalRaddamMuon.cc.

Referenced by analyze().

std::vector<double> HcalRaddamMuon::v_RH_h3x3_ene

private

Definition at line 125 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_ieta

private

Definition at line 123 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_iphi

private

Definition at line 124 of file HcalRaddamMuon.cc.

const int HcalRaddamMuon::verbosity_

private

Definition at line 110 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and analyze().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation