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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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::vector< ModuleDescription const * > &modules, 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

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::EDGetTokenT< EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT< EcalRecHitCollection >	tok_EE_

edm::EDGetTokenT< HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_hcal_

edm::EDGetTokenT< reco::MuonCollection >	tok_muon_

edm::EDGetTokenT< reco::VertexCollection >	tok_recVtx_

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)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

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

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 55 of file HcalRaddamMuon.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 136 of file HcalRaddamMuon.cc.

References edm::ParameterSet::getUntrackedParameter(), hlTriggerResults_, isAOD_, TFileService::kSharedResource, maxDepth_, muonsrc_, tok_bs_, tok_EB_, tok_EE_, tok_hbhe_, tok_hcal_, tok_muon_, tok_recVtx_, 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_);
 }

HcalRaddamMuon::~HcalRaddamMuon ( )

override

Definition at line 166 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 729 of file HcalRaddamMuon.cc.

References actHB, actHE, DEFINE_FWK_MODULE, egammaForCoreTracking_cff::depth, HcalBarrel, mps_fire::i, and triggerObjects_cff::id.

Referenced by analyze().

                                                     {
   HcalDetId id(id_);
   int ieta = id.ietaAbs();
   int depth= id.depth();
   double lx(0);
   if (id.subdet() == HcalBarrel) {
     //    std::cout<<"actHB.size()"<<actHB.size()<<std::endl;
     for (unsigned int i=0; i<actHB.size(); ++i) {
       if (ieta == actHB[i].ieta && depth == actHB[i].depth) {
     lx = actHB[i].thick;
     break;
       }
     }
   } else {
     //    std::cout<<"actHE.size()"<<actHE.size()<<std::endl; 
     for (unsigned int i=0; i<actHE.size(); ++i) {
       if (ieta == actHE[i].ieta && depth == actHE[i].depth) {
     lx = actHE[i].thick;
 //  std::cout<<"actHE[i].thick"<<actHE[i].thick<<std::endl;
     break;
       }
     }
   }
   return lx;
 }

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

overrideprivate

Definition at line 178 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) std::cout << "size of all triggers " 
                    << all_triggers.size() << std::endl;
   int Ntriggers = all_triggers.size();
   
   if ((verbosity_%10)>1) std::cout << "size of HLT MENU: "
                    << _Triggers->size() << std::endl;
   
   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) std::cout << "outside loop " << index[i]
                        << "\ntriggerSize " << triggerSize
                        << std::endl;
       if (index[i] < triggerSize) {
         hltresults.push_back(_Triggers->accept(index[i])) ;
     if ((verbosity_%10)>2) std::cout << "trigger_info " << triggerSize
                      << " triggerSize " << index[i]
                      << " trigger_index " << hltresults.at(i)
                      << " hltresult " << std::endl;
       } else {
     edm::LogInfo("TriggerBlock") << "Requested HLT path \"" <<  "\" does not exist";
       }
     }
   }
   
   // get handles to calogeometry and calotopology
   edm::ESHandle<CaloGeometry> pG;
   iSetup.get<CaloGeometryRecord>().get(pG);
   const CaloGeometry* geo = pG.product();
   
   edm::ESHandle<MagneticField> bFieldH;
   iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
   const MagneticField* bField = bFieldH.product();
   
   edm::ESHandle<EcalChannelStatus> ecalChStatus;
   iSetup.get<EcalChannelStatusRcd>().get(ecalChStatus);
   const EcalChannelStatus* theEcalChStatus = ecalChStatus.product();
   
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
   iSetup.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
   
   edm::ESHandle<CaloTopology> theCaloTopology;
   iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
   const CaloTopology *caloTopology = theCaloTopology.product();
   
   edm::ESHandle<HcalTopology> htopo;
   iSetup.get<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* theHBHETopology = htopo.product();
 
   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.product(),1,1,-100.0,-100.0,-500.0,500.0,false);
       
       eEcal = e3x3.first;
       //std::cout<<"eEcal"<<eEcal<<std::endl;
     }
     
     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);
       //std::cout<<"eHcal"<<eHcal<<std::endl;
       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;
         //std::cout<<eHcalDepth[ehdepth[i].second-1]<<std::endl;
       }
 
       eHcal = spr::eHCALmatrix(theHBHETopology, closestCell, calosimhits,0,0, false, true, -100.0, -100.0, -100.0, -100.0, -500.,500.,useRaw_);
       
       //std::cout<<"eHcal"<<eHcal<<std::endl;
       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;
         //std::cout<<eHcalDepth[ehdepth[i].second-1]<<std::endl;
       }
       
       HcalDetId hcid0(closestCell.rawId());
       activeL = activeLength(trackID.detIdHCAL);
       
       std::cout<<activeL<<std::endl;
       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);
 
       // std::cout<<"hcal 3X3  < "<<h3x3<<">" << " ClosestCell <" << (HcalDetId)(closestCell) << "> hotCell id < " << hotCell << "> isHot" << isHot << std::endl;
       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;
           //  std::cout<<eHcalDepthHot[ehdepth[i].second-1]<<std::endl;
         }
       }
 
       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;
           //  std::cout<<eHcalDepthHot[ehdepth[i].second-1]<<std::endl;                                                                         
         }
       }
     }
       } 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 491 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 598 of file HcalRaddamMuon.cc.

References actHB, actHE, all_triggers, edm::EventSetup::get(), HcalDDDRecConstants::getThickActive(), hltConfig_, lumiCalc2::hltname, HLTConfigProvider::init(), ntriggers, HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::t, and HLTConfigProvider::triggerName().

                                                                              {
 
   edm::ESHandle<HcalDDDRecConstants> pHRNDC;
   iSetup.get<HcalRecNumberingRecord>().get(pHRNDC);
   const HcalDDDRecConstants & hdc = (*pHRNDC);
   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::LogInfo("TriggerBlock") << "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
     //  std::cout<<"all triggers size in begin run"<<all_triggers.size()<<std::endl;
   } else {
     edm::LogError("TriggerBlock") << "Error! HLT config extraction with process name " 
                   << "HLT"<< " failed";
   }
   
 }//firstmethod

void HcalRaddamMuon::clearVectors ( )

private

clearing vectots

Definition at line 648 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 595 of file HcalRaddamMuon.cc.

Referenced by o2olib.O2ORunMgr::executeJob().

595 {}

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

overrideprivate

Definition at line 635 of file HcalRaddamMuon.cc.

635 { }

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

static

Definition at line 637 of file HcalRaddamMuon.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and edm::ParameterSetDescription::addUntracked().

                                                                                 {
   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 721 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 122 of file HcalRaddamMuon.cc.

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_04

private

Definition at line 122 of file HcalRaddamMuon.cc.

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

private

Definition at line 97 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

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

private

Definition at line 97 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

std::vector<bool> HcalRaddamMuon::all_ifTriggerpassed

private

Definition at line 111 of file HcalRaddamMuon.cc.

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

private

Definition at line 106 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::BXNumber

private

Definition at line 121 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::chiGlobal

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::chiTracker

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::DxyTracker

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::dxyWithBS

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::DzTracker

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::dzWithBS

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Energy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

std::vector<float> HcalRaddamMuon::energy_hb

private

Definition at line 114 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::EtaGlob

private

Definition at line 77 of file HcalRaddamMuon.cc.

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

unsigned int HcalRaddamMuon::EventNumber

private

Definition at line 121 of file HcalRaddamMuon.cc.

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

edm::Service<TFileService> HcalRaddamMuon::fs

private

Definition at line 99 of file HcalRaddamMuon.cc.

Referenced by beginJob().

std::vector<double> HcalRaddamMuon::GlobalMuonHits

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::GlobalTrack

private

Definition at line 84 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::GlobalTrckEta

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::GlobalTrckPhi

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::GlobalTrckPt

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

double HcalRaddamMuon::h3x3

private

Definition at line 120 of file HcalRaddamMuon.cc.

Referenced by analyze().

double HcalRaddamMuon::h3x3Calo

private

Definition at line 120 of file HcalRaddamMuon.cc.

Referenced by analyze().

std::vector<double> HcalRaddamMuon::High_TrackLayers

private

Definition at line 83 of file HcalRaddamMuon.cc.

HLTConfigProvider HcalRaddamMuon::hltConfig_

private

Definition at line 101 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::string HcalRaddamMuon::hltlabel_

private

Definition at line 105 of file HcalRaddamMuon.cc.

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

private

Definition at line 115 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::hltresults

private

Definition at line 113 of file HcalRaddamMuon.cc.

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

const edm::InputTag HcalRaddamMuon::hlTriggerResults_

private

Definition at line 102 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::ImpactParameter

private

Definition at line 82 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::innerTrack

private

Definition at line 84 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 79 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::innerTrackphi

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::innerTrackpt

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

const bool HcalRaddamMuon::isAOD_

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<bool> HcalRaddamMuon::isHB

private

Definition at line 109 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::isHE

private

Definition at line 109 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::IsolationR03

private

Definition at line 85 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::IsolationR04

private

Definition at line 85 of file HcalRaddamMuon.cc.

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

unsigned int HcalRaddamMuon::LumiNumber

private

Definition at line 121 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MatchedStat

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

int HcalRaddamMuon::maxDepth_

private

Definition at line 98 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_global

private

Definition at line 112 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_is_good

private

Definition at line 112 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_tracker

private

Definition at line 112 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonEcal3x3Energy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonEcalEnergy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcal1x1Energy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalActiveLength

private

Definition at line 96 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth1Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth1EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth2EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth3EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth4EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7EnergyCalo

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergy

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergyCalo

private

Definition at line 93 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

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

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalEnergy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 87 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHOEnergy

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

const edm::InputTag HcalRaddamMuon::muonsrc_

private

Definition at line 102 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::No_pixelLayers

private

Definition at line 82 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NormChi2

private

Definition at line 82 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvx

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvy

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvz

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverP

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverPError

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointX

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointY

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointZ

private

Definition at line 119 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::ntriggers

private

Definition at line 123 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::vector<double> HcalRaddamMuon::NTrkMomentum

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NumPixelLayers

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::OuterTrack

private

Definition at line 84 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackChi

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackEta

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackHits

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackPhi

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackPt

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackRHits

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::PCharge

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PChi2

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0Error

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdxyTrack

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdzTrack

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PhiGlob

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::PLostHits

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Pmuon

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::PNDoF

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PNormalizedChi2

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PtGlob

private

Definition at line 74 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Pthetha

private

Definition at line 118 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PValidHits

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PxGlob

private

Definition at line 118 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PyGlob

private

Definition at line 118 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PzGlob

private

Definition at line 118 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::RunNumber

private

Definition at line 121 of file HcalRaddamMuon.cc.

Referenced by analyze(), beginJob(), clearVectors(), Page1Parser.Page1Parser::ParsePage1(), and PopulateDB.PopulateDB::run().

std::vector<double> HcalRaddamMuon::Tight_GlobalMuonTrkFit

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_LongPara

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_MatchedStations

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_MuonHits

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_PixelHits

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_TransImpara

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_TrkerLayers

private

Definition at line 83 of file HcalRaddamMuon.cc.

std::vector<float> HcalRaddamMuon::time_hb

private

Definition at line 114 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

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

private

Definition at line 129 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EB_

private

Definition at line 130 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EE_

private

Definition at line 131 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<HBHERecHitCollection> HcalRaddamMuon::tok_hbhe_

private

Definition at line 132 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 126 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 133 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 127 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::track_cosmic_detid

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDinner

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDouter

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIX

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIY

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIZ

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOX

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOY

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOZ

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIX

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIY

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIZ

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOX

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOY

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOZ

private

Definition at line 74 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_rad

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xmomentum

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xposition

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_ymomentum

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_yposition

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zmomentum

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zposition

private

Definition at line 124 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::TrackerLayer

private

Definition at line 79 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::trackerlayer_hits

private

Definition at line 82 of file HcalRaddamMuon.cc.

TTree* HcalRaddamMuon::TREE

private

Definition at line 110 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

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

private

Definition at line 115 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::Trk_match_MuStat

private

Definition at line 112 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::type

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::inputCommands(), core.autovars.NTupleVariable::makeBranch(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::outputCommands(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::outputEventContent(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::properties(), DQM.DQMReader::read_objects(), and core.AutoHandle.AutoHandle::ReallyLoad().

const int HcalRaddamMuon::useRaw_

private

Definition at line 103 of file HcalRaddamMuon.cc.

Referenced by analyze().

std::vector<double> HcalRaddamMuon::v_RH_h3x3_ene

private

Definition at line 118 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_ieta

private

Definition at line 116 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_iphi

private

Definition at line 117 of file HcalRaddamMuon.cc.

const int HcalRaddamMuon::verbosity_

private

Definition at line 103 of file HcalRaddamMuon.cc.

Referenced by 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