HcalRaddamMuon Class Reference

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 &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	activeLength (const DetId &)
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	beginJob () override
void	beginRun (edm::Run const &, edm::EventSetup const &) override
void	clearVectors ()
void	endJob () override
void	endRun (edm::Run const &, edm::EventSetup const &) override
int	matchId (const HcalDetId &, const HcalDetId &)

Private Attributes
double	_RecoMuon1TrackIsoSumPtMaxCutValue_03
double	_RecoMuon1TrackIsoSumPtMaxCutValue_04
std::vector< HcalDDDRecConstants::HcalActiveLength >	actHB
std::vector< HcalDDDRecConstants::HcalActiveLength >	actHE
std::vector< bool >	all_ifTriggerpassed
std::vector< std::string >	all_triggers
std::vector< std::string >	all_triggers1
std::vector< std::string >	all_triggers2
std::vector< std::string >	all_triggers3
std::vector< std::string >	all_triggers4
std::vector< std::string >	all_triggers5
unsigned int	BXNumber
std::vector< double >	chiGlobal
std::vector< double >	chiTracker
std::vector< double >	DxyTracker
std::vector< double >	dxyWithBS
std::vector< double >	DzTracker
std::vector< double >	dzWithBS
std::vector< double >	Energy
std::vector< float >	energy_hb
std::vector< double >	EtaGlob
unsigned int	EventNumber
edm::Service< TFileService >	fs
std::vector< double >	GlobalMuonHits
std::vector< bool >	GlobalTrack
std::vector< double >	GlobalTrckEta
std::vector< double >	GlobalTrckPhi
std::vector< double >	GlobalTrckPt
double	h3x3
double	h3x3Calo
std::vector< double >	High_TrackLayers
HLTConfigProvider	hltConfig_
std::string	hltlabel_
std::vector< std::string >	hltpaths
std::vector< int >	hltresults
const edm::InputTag	hlTriggerResults_
std::vector< double >	ImpactParameter
std::vector< bool >	innerTrack
std::vector< double >	innerTracketa
std::vector< double >	innerTrackphi
std::vector< double >	innerTrackpt
const bool	isAOD_
std::vector< bool >	isHB
std::vector< bool >	isHE
std::vector< double >	IsolationR03
std::vector< double >	IsolationR04
unsigned int	LumiNumber
std::vector< double >	MatchedStat
int	maxDepth_
std::vector< bool >	muon_global
std::vector< bool >	muon_is_good
std::vector< bool >	muon_tracker
std::vector< double >	MuonEcal3x3Energy
std::vector< unsigned int >	MuonEcalDetId
std::vector< double >	MuonEcalEnergy
std::vector< unsigned int >	MuonEHcalDetId
std::vector< double >	MuonHcal1x1Energy
std::vector< double >	MuonHcalActiveLength
std::vector< double >	MuonHcalDepth1Energy
std::vector< double >	MuonHcalDepth1EnergyCalo
std::vector< double >	MuonHcalDepth1HotEnergy
std::vector< double >	MuonHcalDepth1HotEnergyCalo
std::vector< double >	MuonHcalDepth2Energy
std::vector< double >	MuonHcalDepth2EnergyCalo
std::vector< double >	MuonHcalDepth2HotEnergy
std::vector< double >	MuonHcalDepth2HotEnergyCalo
std::vector< double >	MuonHcalDepth3Energy
std::vector< double >	MuonHcalDepth3EnergyCalo
std::vector< double >	MuonHcalDepth3HotEnergy
std::vector< double >	MuonHcalDepth3HotEnergyCalo
std::vector< double >	MuonHcalDepth4Energy
std::vector< double >	MuonHcalDepth4EnergyCalo
std::vector< double >	MuonHcalDepth4HotEnergy
std::vector< double >	MuonHcalDepth4HotEnergyCalo
std::vector< double >	MuonHcalDepth5Energy
std::vector< double >	MuonHcalDepth5EnergyCalo
std::vector< double >	MuonHcalDepth5HotEnergy
std::vector< double >	MuonHcalDepth5HotEnergyCalo
std::vector< double >	MuonHcalDepth6Energy
std::vector< double >	MuonHcalDepth6EnergyCalo
std::vector< double >	MuonHcalDepth6HotEnergy
std::vector< double >	MuonHcalDepth6HotEnergyCalo
std::vector< double >	MuonHcalDepth7Energy
std::vector< double >	MuonHcalDepth7EnergyCalo
std::vector< double >	MuonHcalDepth7HotEnergy
std::vector< double >	MuonHcalDepth7HotEnergyCalo
std::vector< unsigned int >	MuonHcalDetId
std::vector< double >	MuonHcalEnergy
std::vector< unsigned int >	MuonHcalHot
std::vector< unsigned int >	MuonHcalHotCalo
std::vector< double >	MuonHOEnergy
const edm::InputTag	muonsrc_
std::vector< double >	No_pixelLayers
std::vector< double >	NormChi2
std::vector< double >	NPvx
std::vector< double >	NPvy
std::vector< double >	NPvz
std::vector< double >	NQOverP
std::vector< double >	NQOverPError
std::vector< double >	NRefPointX
std::vector< double >	NRefPointY
std::vector< double >	NRefPointZ
int	ntriggers
std::vector< double >	NTrkMomentum
std::vector< double >	NumPixelLayers
std::vector< bool >	OuterTrack
std::vector< double >	OuterTrackChi
std::vector< double >	OuterTrackEta
std::vector< double >	OuterTrackHits
std::vector< double >	OuterTrackPhi
std::vector< double >	OuterTrackPt
std::vector< double >	OuterTrackRHits
std::vector< double >	PCharge
std::vector< double >	PChi2
std::vector< double >	PD0
std::vector< double >	PD0Error
std::vector< double >	PdxyTrack
std::vector< double >	PdzTrack
std::vector< double >	PhiGlob
std::vector< double >	PLostHits
std::vector< double >	Pmuon
std::vector< double >	PNDoF
std::vector< double >	PNormalizedChi2
std::vector< double >	PtGlob
std::vector< double >	Pthetha
std::vector< double >	PValidHits
std::vector< double >	PxGlob
std::vector< double >	PyGlob
std::vector< double >	PzGlob
unsigned int	RunNumber
std::vector< double >	Tight_GlobalMuonTrkFit
std::vector< double >	Tight_LongPara
std::vector< double >	Tight_MatchedStations
std::vector< double >	Tight_MuonHits
std::vector< double >	Tight_PixelHits
std::vector< double >	Tight_TransImpara
std::vector< double >	Tight_TrkerLayers
std::vector< float >	time_hb
edm::EDGetTokenT< reco::BeamSpot >	tok_bs_
edm::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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 54 of file HcalRaddamMuon.cc.

Constructor & Destructor Documentation

HcalRaddamMuon()

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

explicit

Definition at line 145 of file HcalRaddamMuon.cc.

    : 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_);
}

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_.

~HcalRaddamMuon()

HcalRaddamMuon::~HcalRaddamMuon ( )

override

Definition at line 176 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

activeLength()

double HcalRaddamMuon::activeLength ( const DetId &  id_ )

private

Definition at line 829 of file HcalRaddamMuon.cc.

                                                    {
  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;
}

References actHB, actHE, LEDCalibrationChannels::depth, HcalBarrel, mps_fire::i, triggerObjects_cff::id, and LEDCalibrationChannels::ieta.

Referenced by analyze().

analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 186 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();
}

References edm::HLTGlobalStatus::accept(), activeLength(), all_triggers, begin, Calorimetry_cff::bField, BXNumber, chiGlobal, chiTracker, clearVectors(), gather_cfg::cout, HcalTopology::dddConstants(), spr::propagatedTrackID::detIdECAL, spr::propagatedTrackID::detIdEHCAL, spr::propagatedTrackID::detIdHCAL, DxyTracker, DzTracker, spr::eECALmatrix(), spr::eHCALmatrix(), Energy, spr::energyHCALCell(), EtaGlob, EventNumber, edm::EventSetup::get(), get, HcalDDDRecConstants::getMinDepth(), GlobalMuonHits, GlobalTrack, GlobalTrckEta, GlobalTrckPhi, GlobalTrckPt, h3x3, h3x3Calo, photonIsolationHIProducer_cfi::hbhe, hltresults, mps_fire::i, iEvent, innerTrack, innerTracketa, innerTrackphi, innerTrackpt, createfilelist::int, LEDCalibrationChannels::iphi, IsolationR03, IsolationR04, edm::HandleBase::isValid(), LumiNumber, MatchedStat, matchId(), SiStripPI::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::BeamSpot::position(), position, edm::ESHandle< T >::product(), spr::propagateCALO(), DiDispStaMuonMonitor_cfi::pt, PtGlob, DetId::rawId(), RunNumber, edm::HLTGlobalStatus::size(), 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(), useRaw_, verbosity_, bphysicsOniaDQM_cfi::vertex, badGlobalMuonTaggersAOD_cff::vtx, and ecaldqm::zside().

beginJob()

void HcalRaddamMuon::beginJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 595 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);
}

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, RunNumber, Tight_LongPara, Tight_PixelHits, Tight_TransImpara, time_hb, and TREE.

beginRun()

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

overrideprivate

Definition at line 699 of file HcalRaddamMuon.cc.

                                                                             {
  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

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

clearVectors()

void HcalRaddamMuon::clearVectors ( )

private

clearing vectots

Definition at line 749 of file HcalRaddamMuon.cc.

                                  {
  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();
}

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, RunNumber, Tight_LongPara, Tight_PixelHits, Tight_TransImpara, and time_hb.

Referenced by analyze().

endJob()

void HcalRaddamMuon::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 696 of file HcalRaddamMuon.cc.

{}

Referenced by o2olib.O2ORunMgr::executeJob().

endRun()

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

overrideprivate

Definition at line 736 of file HcalRaddamMuon.cc.

{}

fillDescriptions()

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

static

Definition at line 738 of file HcalRaddamMuon.cc.

                                                                                {
  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);
}

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

matchId()

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

private

Definition at line 822 of file HcalRaddamMuon.cc.

                                                                      {
  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;
}

References globals_cff::id1, globals_cff::id2, and match().

Referenced by analyze().

Member Data Documentation

_RecoMuon1TrackIsoSumPtMaxCutValue_03

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_03

private

Definition at line 130 of file HcalRaddamMuon.cc.

_RecoMuon1TrackIsoSumPtMaxCutValue_04

double HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_04

private

Definition at line 130 of file HcalRaddamMuon.cc.

actHB

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

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

actHE

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

private

Definition at line 104 of file HcalRaddamMuon.cc.

Referenced by activeLength(), and beginRun().

all_ifTriggerpassed

std::vector<bool> HcalRaddamMuon::all_ifTriggerpassed

private

Definition at line 118 of file HcalRaddamMuon.cc.

all_triggers

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

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

all_triggers1

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

all_triggers2

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

all_triggers3

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

all_triggers4

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

all_triggers5

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

private

Definition at line 113 of file HcalRaddamMuon.cc.

BXNumber

unsigned int HcalRaddamMuon::BXNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

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

chiGlobal

std::vector<double> HcalRaddamMuon::chiGlobal

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

chiTracker

std::vector<double> HcalRaddamMuon::chiTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

DxyTracker

std::vector<double> HcalRaddamMuon::DxyTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

dxyWithBS

std::vector<double> HcalRaddamMuon::dxyWithBS

private

Definition at line 126 of file HcalRaddamMuon.cc.

DzTracker

std::vector<double> HcalRaddamMuon::DzTracker

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

dzWithBS

std::vector<double> HcalRaddamMuon::dzWithBS

private

Definition at line 126 of file HcalRaddamMuon.cc.

Energy

std::vector<double> HcalRaddamMuon::Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

energy_hb

std::vector<float> HcalRaddamMuon::energy_hb

private

Definition at line 121 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

EtaGlob

std::vector<double> HcalRaddamMuon::EtaGlob

private

Definition at line 78 of file HcalRaddamMuon.cc.

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

EventNumber

unsigned int HcalRaddamMuon::EventNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

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

fs

edm::Service<TFileService> HcalRaddamMuon::fs

private

Definition at line 106 of file HcalRaddamMuon.cc.

Referenced by beginJob().

GlobalMuonHits

std::vector<double> HcalRaddamMuon::GlobalMuonHits

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

GlobalTrack

std::vector<bool> HcalRaddamMuon::GlobalTrack

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

GlobalTrckEta

std::vector<double> HcalRaddamMuon::GlobalTrckEta

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

GlobalTrckPhi

std::vector<double> HcalRaddamMuon::GlobalTrckPhi

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

GlobalTrckPt

std::vector<double> HcalRaddamMuon::GlobalTrckPt

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

h3x3

double HcalRaddamMuon::h3x3

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by analyze().

h3x3Calo

double HcalRaddamMuon::h3x3Calo

private

Definition at line 128 of file HcalRaddamMuon.cc.

Referenced by analyze().

High_TrackLayers

std::vector<double> HcalRaddamMuon::High_TrackLayers

private

Definition at line 84 of file HcalRaddamMuon.cc.

hltConfig_

HLTConfigProvider HcalRaddamMuon::hltConfig_

private

Definition at line 108 of file HcalRaddamMuon.cc.

Referenced by beginRun().

hltlabel_

std::string HcalRaddamMuon::hltlabel_

private

Definition at line 112 of file HcalRaddamMuon.cc.

hltpaths

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

private

Definition at line 122 of file HcalRaddamMuon.cc.

hltresults

std::vector<int> HcalRaddamMuon::hltresults

private

Definition at line 120 of file HcalRaddamMuon.cc.

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

hlTriggerResults_

const edm::InputTag HcalRaddamMuon::hlTriggerResults_

private

Definition at line 109 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

ImpactParameter

std::vector<double> HcalRaddamMuon::ImpactParameter

private

Definition at line 83 of file HcalRaddamMuon.cc.

innerTrack

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

innerTracketa

std::vector<double> HcalRaddamMuon::innerTracketa

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

innerTrackphi

std::vector<double> HcalRaddamMuon::innerTrackphi

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

innerTrackpt

std::vector<double> HcalRaddamMuon::innerTrackpt

private

Definition at line 80 of file HcalRaddamMuon.cc.

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

isAOD_

const bool HcalRaddamMuon::isAOD_

private

Definition at line 111 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

isHB

std::vector<bool> HcalRaddamMuon::isHB

private

Definition at line 116 of file HcalRaddamMuon.cc.

isHE

std::vector<bool> HcalRaddamMuon::isHE

private

Definition at line 116 of file HcalRaddamMuon.cc.

IsolationR03

std::vector<double> HcalRaddamMuon::IsolationR03

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

IsolationR04

std::vector<double> HcalRaddamMuon::IsolationR04

private

Definition at line 87 of file HcalRaddamMuon.cc.

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

LumiNumber

unsigned int HcalRaddamMuon::LumiNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

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

MatchedStat

std::vector<double> HcalRaddamMuon::MatchedStat

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

maxDepth_

int HcalRaddamMuon::maxDepth_

private

Definition at line 105 of file HcalRaddamMuon.cc.

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

muon_global

std::vector<bool> HcalRaddamMuon::muon_global

private

Definition at line 119 of file HcalRaddamMuon.cc.

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

muon_is_good

std::vector<bool> HcalRaddamMuon::muon_is_good

private

Definition at line 119 of file HcalRaddamMuon.cc.

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

muon_tracker

std::vector<bool> HcalRaddamMuon::muon_tracker

private

Definition at line 119 of file HcalRaddamMuon.cc.

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

MuonEcal3x3Energy

std::vector<double> HcalRaddamMuon::MuonEcal3x3Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

MuonEcalDetId

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

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

MuonEcalEnergy

std::vector<double> HcalRaddamMuon::MuonEcalEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

MuonEHcalDetId

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

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

MuonHcal1x1Energy

std::vector<double> HcalRaddamMuon::MuonHcal1x1Energy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

MuonHcalActiveLength

std::vector<double> HcalRaddamMuon::MuonHcalActiveLength

private

Definition at line 103 of file HcalRaddamMuon.cc.

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

MuonHcalDepth1Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth1Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

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

MuonHcalDepth1EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth1EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth1HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

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

MuonHcalDepth1HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth1HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth2Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth2Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

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

MuonHcalDepth2EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth2EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth2HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

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

MuonHcalDepth2HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth2HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth3Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth3Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

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

MuonHcalDepth3EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth3EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth3HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

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

MuonHcalDepth3HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth3HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth4Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth4Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

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

MuonHcalDepth4EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth4EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth4HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

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

MuonHcalDepth4HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth4HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth5Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth5Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth5EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth5EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth5HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth5HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth5HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth6Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth6Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth6EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth6EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth6HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth6HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth6HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth7Energy

std::vector<double> HcalRaddamMuon::MuonHcalDepth7Energy

private

Definition at line 90 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth7EnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth7EnergyCalo

private

Definition at line 96 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDepth7HotEnergy

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergy

private

Definition at line 92 of file HcalRaddamMuon.cc.

Referenced by analyze(), and clearVectors().

MuonHcalDepth7HotEnergyCalo

std::vector<double> HcalRaddamMuon::MuonHcalDepth7HotEnergyCalo

private

Definition at line 98 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHcalDetId

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

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

MuonHcalEnergy

std::vector<double> HcalRaddamMuon::MuonHcalEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

MuonHcalHot

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

private

Definition at line 89 of file HcalRaddamMuon.cc.

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

MuonHcalHotCalo

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

private

Definition at line 89 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

MuonHOEnergy

std::vector<double> HcalRaddamMuon::MuonHOEnergy

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

muonsrc_

const edm::InputTag HcalRaddamMuon::muonsrc_

private

Definition at line 109 of file HcalRaddamMuon.cc.

Referenced by HcalRaddamMuon().

No_pixelLayers

std::vector<double> HcalRaddamMuon::No_pixelLayers

private

Definition at line 83 of file HcalRaddamMuon.cc.

NormChi2

std::vector<double> HcalRaddamMuon::NormChi2

private

Definition at line 83 of file HcalRaddamMuon.cc.

NPvx

std::vector<double> HcalRaddamMuon::NPvx

private

Definition at line 126 of file HcalRaddamMuon.cc.

NPvy

std::vector<double> HcalRaddamMuon::NPvy

private

Definition at line 126 of file HcalRaddamMuon.cc.

NPvz

std::vector<double> HcalRaddamMuon::NPvz

private

Definition at line 126 of file HcalRaddamMuon.cc.

NQOverP

std::vector<double> HcalRaddamMuon::NQOverP

private

Definition at line 126 of file HcalRaddamMuon.cc.

NQOverPError

std::vector<double> HcalRaddamMuon::NQOverPError

private

Definition at line 126 of file HcalRaddamMuon.cc.

NRefPointX

std::vector<double> HcalRaddamMuon::NRefPointX

private

Definition at line 126 of file HcalRaddamMuon.cc.

NRefPointY

std::vector<double> HcalRaddamMuon::NRefPointY

private

Definition at line 126 of file HcalRaddamMuon.cc.

NRefPointZ

std::vector<double> HcalRaddamMuon::NRefPointZ

private

Definition at line 126 of file HcalRaddamMuon.cc.

ntriggers

int HcalRaddamMuon::ntriggers

private

Definition at line 131 of file HcalRaddamMuon.cc.

Referenced by beginRun().

NTrkMomentum

std::vector<double> HcalRaddamMuon::NTrkMomentum

private

Definition at line 126 of file HcalRaddamMuon.cc.

NumPixelLayers

std::vector<double> HcalRaddamMuon::NumPixelLayers

private

Definition at line 81 of file HcalRaddamMuon.cc.

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

OuterTrack

std::vector<bool> HcalRaddamMuon::OuterTrack

private

Definition at line 86 of file HcalRaddamMuon.cc.

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

OuterTrackChi

std::vector<double> HcalRaddamMuon::OuterTrackChi

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

OuterTrackEta

std::vector<double> HcalRaddamMuon::OuterTrackEta

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

OuterTrackHits

std::vector<double> HcalRaddamMuon::OuterTrackHits

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

OuterTrackPhi

std::vector<double> HcalRaddamMuon::OuterTrackPhi

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

OuterTrackPt

std::vector<double> HcalRaddamMuon::OuterTrackPt

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

OuterTrackRHits

std::vector<double> HcalRaddamMuon::OuterTrackRHits

private

Definition at line 82 of file HcalRaddamMuon.cc.

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

PCharge

std::vector<double> HcalRaddamMuon::PCharge

private

Definition at line 126 of file HcalRaddamMuon.cc.

PChi2

std::vector<double> HcalRaddamMuon::PChi2

private

Definition at line 126 of file HcalRaddamMuon.cc.

PD0

std::vector<double> HcalRaddamMuon::PD0

private

Definition at line 126 of file HcalRaddamMuon.cc.

PD0Error

std::vector<double> HcalRaddamMuon::PD0Error

private

Definition at line 126 of file HcalRaddamMuon.cc.

PdxyTrack

std::vector<double> HcalRaddamMuon::PdxyTrack

private

Definition at line 126 of file HcalRaddamMuon.cc.

PdzTrack

std::vector<double> HcalRaddamMuon::PdzTrack

private

Definition at line 126 of file HcalRaddamMuon.cc.

PhiGlob

std::vector<double> HcalRaddamMuon::PhiGlob

private

Definition at line 79 of file HcalRaddamMuon.cc.

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

PLostHits

std::vector<double> HcalRaddamMuon::PLostHits

private

Definition at line 126 of file HcalRaddamMuon.cc.

Pmuon

std::vector<double> HcalRaddamMuon::Pmuon

private

Definition at line 88 of file HcalRaddamMuon.cc.

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

PNDoF

std::vector<double> HcalRaddamMuon::PNDoF

private

Definition at line 126 of file HcalRaddamMuon.cc.

PNormalizedChi2

std::vector<double> HcalRaddamMuon::PNormalizedChi2

private

Definition at line 126 of file HcalRaddamMuon.cc.

PtGlob

std::vector<double> HcalRaddamMuon::PtGlob

private

Definition at line 72 of file HcalRaddamMuon.cc.

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

Pthetha

std::vector<double> HcalRaddamMuon::Pthetha

private

Definition at line 125 of file HcalRaddamMuon.cc.

PValidHits

std::vector<double> HcalRaddamMuon::PValidHits

private

Definition at line 126 of file HcalRaddamMuon.cc.

PxGlob

std::vector<double> HcalRaddamMuon::PxGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

PyGlob

std::vector<double> HcalRaddamMuon::PyGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

PzGlob

std::vector<double> HcalRaddamMuon::PzGlob

private

Definition at line 125 of file HcalRaddamMuon.cc.

RunNumber

unsigned int HcalRaddamMuon::RunNumber

private

Definition at line 129 of file HcalRaddamMuon.cc.

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

Tight_GlobalMuonTrkFit

std::vector<double> HcalRaddamMuon::Tight_GlobalMuonTrkFit

private

Definition at line 84 of file HcalRaddamMuon.cc.

Tight_LongPara

std::vector<double> HcalRaddamMuon::Tight_LongPara

private

Definition at line 84 of file HcalRaddamMuon.cc.

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

Tight_MatchedStations

std::vector<double> HcalRaddamMuon::Tight_MatchedStations

private

Definition at line 84 of file HcalRaddamMuon.cc.

Tight_MuonHits

std::vector<double> HcalRaddamMuon::Tight_MuonHits

private

Definition at line 84 of file HcalRaddamMuon.cc.

Tight_PixelHits

std::vector<double> HcalRaddamMuon::Tight_PixelHits

private

Definition at line 84 of file HcalRaddamMuon.cc.

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

Tight_TransImpara

std::vector<double> HcalRaddamMuon::Tight_TransImpara

private

Definition at line 84 of file HcalRaddamMuon.cc.

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

Tight_TrkerLayers

std::vector<double> HcalRaddamMuon::Tight_TrkerLayers

private

Definition at line 84 of file HcalRaddamMuon.cc.

time_hb

std::vector<float> HcalRaddamMuon::time_hb

private

Definition at line 121 of file HcalRaddamMuon.cc.

Referenced by beginJob(), and clearVectors().

tok_bs_

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

private

Definition at line 138 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_EB_

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EB_

private

Definition at line 139 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_EE_

edm::EDGetTokenT<EcalRecHitCollection> HcalRaddamMuon::tok_EE_

private

Definition at line 140 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_hbhe_

edm::EDGetTokenT<HBHERecHitCollection> HcalRaddamMuon::tok_hbhe_

private

Definition at line 141 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_hcal_

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

private

Definition at line 135 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_muon_

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

private

Definition at line 142 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_recVtx_

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

private

Definition at line 137 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

tok_trigRes_

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

private

Definition at line 136 of file HcalRaddamMuon.cc.

Referenced by analyze(), and HcalRaddamMuon().

track_cosmic_detid

std::vector<double> HcalRaddamMuon::track_cosmic_detid

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_detIDinner

std::vector<double> HcalRaddamMuon::track_cosmic_detIDinner

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_detIDouter

std::vector<double> HcalRaddamMuon::track_cosmic_detIDouter

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumIX

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIX

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumIY

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIY

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumIZ

std::vector<double> HcalRaddamMuon::track_cosmic_momentumIZ

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumOX

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOX

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumOY

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOY

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_momentumOZ

std::vector<double> HcalRaddamMuon::track_cosmic_momentumOZ

private

Definition at line 75 of file HcalRaddamMuon.cc.

track_cosmic_positionIX

std::vector<double> HcalRaddamMuon::track_cosmic_positionIX

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_positionIY

std::vector<double> HcalRaddamMuon::track_cosmic_positionIY

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_positionIZ

std::vector<double> HcalRaddamMuon::track_cosmic_positionIZ

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_positionOX

std::vector<double> HcalRaddamMuon::track_cosmic_positionOX

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_positionOY

std::vector<double> HcalRaddamMuon::track_cosmic_positionOY

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_positionOZ

std::vector<double> HcalRaddamMuon::track_cosmic_positionOZ

private

Definition at line 72 of file HcalRaddamMuon.cc.

track_cosmic_rad

std::vector<double> HcalRaddamMuon::track_cosmic_rad

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_xmomentum

std::vector<double> HcalRaddamMuon::track_cosmic_xmomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_xposition

std::vector<double> HcalRaddamMuon::track_cosmic_xposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_ymomentum

std::vector<double> HcalRaddamMuon::track_cosmic_ymomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_yposition

std::vector<double> HcalRaddamMuon::track_cosmic_yposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_zmomentum

std::vector<double> HcalRaddamMuon::track_cosmic_zmomentum

private

Definition at line 132 of file HcalRaddamMuon.cc.

track_cosmic_zposition

std::vector<double> HcalRaddamMuon::track_cosmic_zposition

private

Definition at line 132 of file HcalRaddamMuon.cc.

TrackerLayer

std::vector<double> HcalRaddamMuon::TrackerLayer

private

Definition at line 80 of file HcalRaddamMuon.cc.

trackerlayer_hits

std::vector<double> HcalRaddamMuon::trackerlayer_hits

private

Definition at line 83 of file HcalRaddamMuon.cc.

TREE

TTree* HcalRaddamMuon::TREE

private

Definition at line 117 of file HcalRaddamMuon.cc.

Referenced by analyze(), and beginJob().

TrigName_

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

private

Definition at line 122 of file HcalRaddamMuon.cc.

Trk_match_MuStat

std::vector<bool> HcalRaddamMuon::Trk_match_MuStat

private

Definition at line 119 of file HcalRaddamMuon.cc.

type

int HcalRaddamMuon::type

private

Definition at line 105 of file HcalRaddamMuon.cc.

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

useRaw_

const int HcalRaddamMuon::useRaw_

private

Definition at line 110 of file HcalRaddamMuon.cc.

Referenced by analyze().

v_RH_h3x3_ene

std::vector<double> HcalRaddamMuon::v_RH_h3x3_ene

private

Definition at line 125 of file HcalRaddamMuon.cc.

v_RH_h3x3_ieta

std::vector<int> HcalRaddamMuon::v_RH_h3x3_ieta

private

Definition at line 123 of file HcalRaddamMuon.cc.

v_RH_h3x3_iphi

std::vector<int> HcalRaddamMuon::v_RH_h3x3_iphi

private

Definition at line 124 of file HcalRaddamMuon.cc.

verbosity_

const int HcalRaddamMuon::verbosity_

private

Definition at line 110 of file HcalRaddamMuon.cc.

Referenced by analyze().