HcalRaddamMuon Class Reference

Inheritance diagram for HcalRaddamMuon:

Public Member Functions
	HcalRaddamMuon (const edm::ParameterSet &)
	~HcalRaddamMuon ()
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
	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 &	itemsToGetFromEvent () 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
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::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
double	activeLength (const DetId &)
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
virtual void	beginRun (edm::Run const &, edm::EventSetup const &)
void	clearVectors ()
virtual void	endJob ()
virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
virtual void	endRun (edm::Run const &, edm::EventSetup const &)
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
edm::InputTag	HLTriggerResults_
std::vector< double >	ImpactParameter
std::vector< bool >	innerTrack
std::vector< double >	innerTracketa
std::vector< double >	innerTrackphi
std::vector< double >	innerTrackpt
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
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< bool >	NTrkQuality
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::string	theTrackQuality
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
bool	useRaw_
std::vector< double >	v_RH_h3x3_ene
std::vector< int >	v_RH_h3x3_ieta
std::vector< int >	v_RH_h3x3_iphi
int	verbosity_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	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 141 of file HcalRaddamMuon.cc.

References edm::ParameterSet::getUntrackedParameter(), HLTriggerResults_, HLT_FULL_cff::InputTag, isAOD_, maxDepth_, muonsrc_, tok_bs_, tok_EB_, tok_EE_, tok_hbhe_, tok_hcal_, tok_muon_, tok_recVtx_, tok_trigRes_, useRaw_, and verbosity_.

                                                             {
  //now do what ever initialization is needed
  HLTriggerResults_ = iConfig.getUntrackedParameter<edm::InputTag>("HLTriggerResults_");
  muonsrc_          = iConfig.getUntrackedParameter<edm::InputTag>("MuonSource");
  verbosity_        = iConfig.getUntrackedParameter<int>("Verbosity",0);
  isAOD_            = iConfig.getUntrackedParameter<bool>("IsAOD",false);
  maxDepth_         = iConfig.getUntrackedParameter<int>("MaxDepth",4);
  useRaw_           = iConfig.getUntrackedParameter<bool>("UseRaw",false);

  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

(

)

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

References actHB, actHE, HLT_FULL_cff::depth, HcalBarrel, and i.

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  )

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 181 of file HcalRaddamMuon.cc.

References activeLength(), all_triggers, begin, ecalTB2006H4_GenSimDigiReco_cfg::bField, edm::EventBase::bunchCrossing(), BXNumber, chiGlobal, chiTracker, clearVectors(), gather_cfg::cout, spr::propagatedTrackID::detIdECAL, spr::propagatedTrackID::detIdEHCAL, spr::propagatedTrackID::detIdHCAL, DxyTracker, DzTracker, spr::eECALmatrix(), spr::eHCALmatrix(), Energy, spr::energyHCALCell(), EtaGlob, edm::EventID::event(), EventNumber, edm::EventSetup::get(), edm::Event::getByToken(), GlobalMuonHits, GlobalTrack, GlobalTrckEta, GlobalTrckPhi, GlobalTrckPt, h3x3, h3x3Calo, hltresults, i, edm::EventBase::id(), cmsHarvester::index, innerTrack, innerTracketa, innerTrackphi, innerTrackpt, IsolationR03, IsolationR04, edm::HandleBase::isValid(), edm::EventID::luminosityBlock(), LumiNumber, MatchedStat, matchId(), bookConverter::max, maxDepth_, muon_global, muon_is_good, muon_tracker, MuonEcal3x3Energy, MuonEcalDetId, MuonEcalEnergy, MuonEHcalDetId, MuonHcal1x1Energy, MuonHcalActiveLength, MuonHcalDepth1Energy, MuonHcalDepth1EnergyCalo, MuonHcalDepth1HotEnergy, MuonHcalDepth1HotEnergyCalo, MuonHcalDepth2Energy, MuonHcalDepth2EnergyCalo, MuonHcalDepth2HotEnergy, MuonHcalDepth2HotEnergyCalo, MuonHcalDepth3Energy, MuonHcalDepth3EnergyCalo, MuonHcalDepth3HotEnergy, MuonHcalDepth3HotEnergyCalo, MuonHcalDepth4Energy, MuonHcalDepth4EnergyCalo, MuonHcalDepth4HotEnergy, MuonHcalDepth4HotEnergyCalo, MuonHcalDepth5Energy, MuonHcalDepth5EnergyCalo, MuonHcalDepth5HotEnergy, MuonHcalDepth5HotEnergyCalo, MuonHcalDepth6Energy, MuonHcalDepth6EnergyCalo, MuonHcalDepth6HotEnergy, MuonHcalDepth6HotEnergyCalo, MuonHcalDepth7Energy, MuonHcalDepth7EnergyCalo, MuonHcalDepth7HotEnergy, MuonHcalDepth7HotEnergyCalo, MuonHcalDetId, MuonHcalEnergy, MuonHcalHot, MuonHcalHotCalo, MuonHOEnergy, NumPixelLayers, spr::propagatedTrackID::okECAL, spr::propagatedTrackID::okHCAL, OuterTrack, OuterTrackChi, OuterTrackEta, OuterTrackHits, OuterTrackPhi, OuterTrackPt, OuterTrackRHits, PhiGlob, Pmuon, reco::Vertex::position(), position, edm::ESHandle< class >::product(), spr::propagateCALO(), EnergyCorrector::pt, PtGlob, DetId::rawId(), edm::EventID::run(), Tight_LongPara, Tight_PixelHits, Tight_TransImpara, tok_bs_, tok_EB_, tok_EE_, tok_hbhe_, tok_hcal_, tok_muon_, tok_recVtx_, tok_trigRes_, TREE, edm::TriggerNames::triggerIndex(), edm::Event::triggerNames(), useRaw_, and verbosity_.

                                                                                {
  
  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_);
      
      //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_,(((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);
      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_, (((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()) {
        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, useRaw_, false);//(((verbosity_/1000)%10)>0    ));
        spr::energyHCALCell(hotCell, hbhe, ehdepth, maxDepth_, -100.0, -100.0, -100.0, -100.0, -500.0, 500.0, false);
        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()) {
        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_, 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  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 483 of file HcalRaddamMuon.cc.

References all_triggers, BXNumber, chiGlobal, chiTracker, DxyTracker, DzTracker, Energy, energy_hb, EtaGlob, EventNumber, fs, GlobalMuonHits, GlobalTrack, GlobalTrckEta, GlobalTrckPhi, GlobalTrckPt, hltresults, innerTrack, innerTracketa, innerTrackphi, innerTrackpt, IsolationR03, IsolationR04, LumiNumber, TFileService::make(), MatchedStat, maxDepth_, muon_global, muon_is_good, muon_tracker, MuonEcal3x3Energy, MuonEcalDetId, MuonEcalEnergy, MuonEHcalDetId, MuonHcal1x1Energy, MuonHcalActiveLength, MuonHcalDepth1Energy, MuonHcalDepth1EnergyCalo, MuonHcalDepth1HotEnergy, MuonHcalDepth1HotEnergyCalo, MuonHcalDepth2Energy, MuonHcalDepth2EnergyCalo, MuonHcalDepth2HotEnergy, MuonHcalDepth2HotEnergyCalo, MuonHcalDepth3Energy, MuonHcalDepth3EnergyCalo, MuonHcalDepth3HotEnergy, MuonHcalDepth3HotEnergyCalo, MuonHcalDepth4Energy, MuonHcalDepth4EnergyCalo, MuonHcalDepth4HotEnergy, MuonHcalDepth4HotEnergyCalo, MuonHcalDepth5EnergyCalo, MuonHcalDepth5HotEnergyCalo, MuonHcalDepth6EnergyCalo, MuonHcalDepth6HotEnergyCalo, MuonHcalDepth7EnergyCalo, MuonHcalDepth7HotEnergyCalo, MuonHcalDetId, MuonHcalEnergy, MuonHcalHot, MuonHcalHotCalo, MuonHOEnergy, NumPixelLayers, OuterTrack, OuterTrackChi, OuterTrackEta, OuterTrackHits, OuterTrackPhi, OuterTrackPt, OuterTrackRHits, PhiGlob, Pmuon, PtGlob, Tight_LongPara, Tight_PixelHits, Tight_TransImpara, time_hb, and TREE.

                              {
  
  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::beginLuminosityBlock ( edm::LuminosityBlock const &  , edm::EventSetup const &    )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 630 of file HcalRaddamMuon.cc.

{ }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 590 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, 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 644 of file HcalRaddamMuon.cc.

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

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  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 587 of file HcalRaddamMuon.cc.

Referenced by o2o.O2ORunMgr::executeJob().

{}

void HcalRaddamMuon::endLuminosityBlock ( edm::LuminosityBlock const &  , edm::EventSetup const &    )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 633 of file HcalRaddamMuon.cc.

{ }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 627 of file HcalRaddamMuon.cc.

{ }

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

static

Definition at line 636 of file HcalRaddamMuon.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

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

private

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

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_04

private

Definition at line 124 of file HcalRaddamMuon.cc.

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

private

Definition at line 99 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

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

private

Definition at line 99 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

std::vector<bool> HcalRaddamMuon::all_ifTriggerpassed

private

Definition at line 112 of file HcalRaddamMuon.cc.

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

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

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

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

private

Definition at line 107 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::BXNumber

private

Definition at line 123 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::chiGlobal

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::chiTracker

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::DxyTracker

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::dxyWithBS

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::DzTracker

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::dzWithBS

private

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

Referenced by beginJob(), and clearVectors().

std::vector<double> HcalRaddamMuon::EtaGlob

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

unsigned int HcalRaddamMuon::EventNumber

private

Definition at line 123 of file HcalRaddamMuon.cc.

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

edm::Service<TFileService> HcalRaddamMuon::fs

private

Definition at line 101 of file HcalRaddamMuon.cc.

Referenced by beginJob().

std::vector<double> HcalRaddamMuon::GlobalMuonHits

private

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

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

std::vector<double> HcalRaddamMuon::GlobalTrckPhi

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::GlobalTrckPt

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

double HcalRaddamMuon::h3x3

private

Definition at line 122 of file HcalRaddamMuon.cc.

Referenced by analyze().

double HcalRaddamMuon::h3x3Calo

private

Definition at line 122 of file HcalRaddamMuon.cc.

Referenced by analyze().

std::vector<double> HcalRaddamMuon::High_TrackLayers

private

Definition at line 85 of file HcalRaddamMuon.cc.

HLTConfigProvider HcalRaddamMuon::hltConfig_

private

Definition at line 103 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::string HcalRaddamMuon::hltlabel_

private

Definition at line 106 of file HcalRaddamMuon.cc.

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

private

Definition at line 116 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::hltresults

private

Definition at line 114 of file HcalRaddamMuon.cc.

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

edm::InputTag HcalRaddamMuon::HLTriggerResults_

private

Definition at line 126 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::ImpactParameter

private

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

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

std::vector<double> HcalRaddamMuon::innerTrackphi

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::innerTrackpt

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

bool HcalRaddamMuon::isAOD_

private

Definition at line 105 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<bool> HcalRaddamMuon::isHB

private

Definition at line 110 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::isHE

private

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

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

std::vector<double> HcalRaddamMuon::MatchedStat

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

int HcalRaddamMuon::maxDepth_

private

Definition at line 100 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_global

private

Definition at line 113 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_is_good

private

Definition at line 113 of file HcalRaddamMuon.cc.

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

std::vector<bool> HcalRaddamMuon::muon_tracker

private

Definition at line 113 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 98 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 94 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergyCalo

private

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

Referenced by analyze(), and beginJob().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergy

private

Definition at line 91 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergyCalo

private

Definition at line 95 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().

edm::InputTag HcalRaddamMuon::muonsrc_

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::No_pixelLayers

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NormChi2

private

Definition at line 84 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvx

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvy

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NPvz

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverP

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NQOverPError

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointX

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointY

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NRefPointZ

private

Definition at line 120 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::ntriggers

private

Definition at line 125 of file HcalRaddamMuon.cc.

Referenced by beginRun().

std::vector<double> HcalRaddamMuon::NTrkMomentum

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::NTrkQuality

private

Definition at line 121 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::NumPixelLayers

private

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

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

std::vector<double> HcalRaddamMuon::OuterTrackEta

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackHits

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackPhi

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackPt

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::OuterTrackRHits

private

Definition at line 83 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::PCharge

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PChi2

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PD0Error

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdxyTrack

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PdzTrack

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PhiGlob

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::PLostHits

private

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

std::vector<double> HcalRaddamMuon::PNormalizedChi2

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PtGlob

private

Definition at line 76 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Pthetha

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PValidHits

private

Definition at line 120 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PxGlob

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PyGlob

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::PzGlob

private

Definition at line 119 of file HcalRaddamMuon.cc.

unsigned int HcalRaddamMuon::RunNumber

private

Definition at line 123 of file HcalRaddamMuon.cc.

Referenced by PopulateDB.PopulateDB::run().

std::string HcalRaddamMuon::theTrackQuality

private

Definition at line 127 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_GlobalMuonTrkFit

private

Definition at line 85 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_LongPara

private

Definition at line 85 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_MatchedStations

private

Definition at line 85 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_MuonHits

private

Definition at line 85 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::Tight_PixelHits

private

Definition at line 85 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_TransImpara

private

Definition at line 85 of file HcalRaddamMuon.cc.

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

std::vector<double> HcalRaddamMuon::Tight_TrkerLayers

private

Definition at line 85 of file HcalRaddamMuon.cc.

std::vector<float> HcalRaddamMuon::time_hb

private

Definition at line 115 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

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

private

Definition at line 134 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EB_

private

Definition at line 135 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EE_

private

Definition at line 136 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

edm::EDGetTokenT<HBHERecHitCollection> HcalRaddamMuon::tok_hbhe_

private

Definition at line 137 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 131 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 138 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 133 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

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

private

Definition at line 132 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::track_cosmic_detid

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDinner

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_detIDouter

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIX

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIY

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIZ

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOX

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOY

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOZ

private

Definition at line 78 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIX

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIY

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionIZ

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOX

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOY

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_positionOZ

private

Definition at line 76 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_rad

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xmomentum

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_xposition

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_ymomentum

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_yposition

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zmomentum

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::track_cosmic_zposition

private

Definition at line 129 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::TrackerLayer

private

Definition at line 81 of file HcalRaddamMuon.cc.

std::vector<double> HcalRaddamMuon::trackerlayer_hits

private

Definition at line 84 of file HcalRaddamMuon.cc.

TTree* HcalRaddamMuon::TREE

private

Definition at line 111 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

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

private

Definition at line 116 of file HcalRaddamMuon.cc.

std::vector<bool> HcalRaddamMuon::Trk_match_MuStat

private

Definition at line 113 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::type

private

Definition at line 100 of file HcalRaddamMuon.cc.

Referenced by cuy.ValElement::__init__(), 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(), and core.AutoHandle.AutoHandle::ReallyLoad().

bool HcalRaddamMuon::useRaw_

private

Definition at line 105 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

std::vector<double> HcalRaddamMuon::v_RH_h3x3_ene

private

Definition at line 119 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_ieta

private

Definition at line 117 of file HcalRaddamMuon.cc.

std::vector<int> HcalRaddamMuon::v_RH_h3x3_iphi

private

Definition at line 118 of file HcalRaddamMuon.cc.

int HcalRaddamMuon::verbosity_

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().