#include <IsoTrackCalib.h>

Inheritance diagram for IsoTrackCalib:

Public Member Functions
double	dR (double eta1, double eta2, double phi1, double phi2)

	IsoTrackCalib (const edm::ParameterSet &)

	~IsoTrackCalib ()

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

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

double	dEta (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

double	dinvPt (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

double	dP (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

double	dPhi (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

double	dPt (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

double	dR (math::XYZTLorentzVector &, math::XYZTLorentzVector &)

virtual void	endJob ()

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

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

Private Attributes
double	a_charIsoR

double	a_coneR

double	a_mipR

double	a_neutIsoR

double	a_neutR1

double	a_neutR2

bool	changed

double	cutCharge

double	cutMip

double	cutNeutral

double	dr_L1

std::vector< double >	drCuts

int	Event

bool	firstEvent

edm::Service< TFileService >	fs

TH1I *	g_Accepts

TH1I *	g_Pre

TH1I *	g_PreHLT

TH1I *	g_PreL1

TH1I *	h_HLTAccept

std::vector< TH1I * >	h_HLTAccepts

TH1I *	h_nHLT

HLTConfigProvider	hltConfig_

std::vector< std::string >	HLTNames

int	maxRunNo

int	minRunNo

int	nRun

int	Run

spr::trackSelectionParameters	selectionParameters

std::vector< double > *	t_charge_iso

std::vector< double > *	t_disthotcell

std::vector< double > *	t_ehcal

std::vector< double > *	t_emip

std::vector< double > *	t_eventweight

std::vector< int > *	t_ieta

std::vector< double > *	t_ietahotcell

std::vector< double > *	t_l1eta

std::vector< double > *	t_l1phi

std::vector< double > *	t_l1pt

std::vector< double > *	t_l3eta

std::vector< double > *	t_l3phi

std::vector< double > *	t_l3pt

std::vector< double > *	t_leadingeta

std::vector< double > *	t_leadingphi

std::vector< double > *	t_leadingpt

std::vector< double > *	t_neu_iso

std::vector< double > *	t_trackEta

std::vector< double > *	t_trackP

std::vector< double > *	t_trackPhi

std::vector< double > *	t_trackPt

std::vector< double > *	t_trackPx

std::vector< double > *	t_trackPy

std::vector< double > *	t_trackPz

std::vector< double > *	t_trkL3mindr

std::string	theTrackQuality

edm::InputTag	theTriggerResultsLabel

edm::EDGetTokenT< reco::BeamSpot >	tok_bs_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EE_

edm::EDGetTokenT < GenEventInfoProduct >	tok_ew_

edm::EDGetTokenT < reco::TrackCollection >	tok_genTrack_

edm::EDGetTokenT < HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< LumiDetails >	tok_lumi

edm::EDGetTokenT < reco::PFJetCollection >	tok_pf_

edm::EDGetTokenT < reco::VertexCollection >	tok_recVtx_

edm::EDGetTokenT < trigger::TriggerEvent >	tok_trigEvt

edm::EDGetTokenT < edm::TriggerResults >	tok_trigRes

TTree *	tree

edm::InputTag	triggerEvent_

std::map< std::pair< unsigned int, std::string >, unsigned int >	TrigList

std::vector< std::string >	trigNames

std::map< std::pair< unsigned int, std::string >, const std::pair< int, int > >	TrigPreList

int	verbosity

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

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 68 of file IsoTrackCalib.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 6 of file IsoTrackCalib.cc.

                                                            : changed(false),
                                  nRun(0) {
    //now do whatever initialization is needed
   verbosity                           = iConfig.getUntrackedParameter<int>("Verbosity",0);
   trigNames                           = iConfig.getUntrackedParameter<std::vector<std::string> >("Triggers");
   theTrackQuality                     = iConfig.getUntrackedParameter<std::string>("TrackQuality","highPurity");
   reco::TrackBase::TrackQuality trackQuality_=reco::TrackBase::qualityByName(theTrackQuality);
   selectionParameters.minPt           = iConfig.getUntrackedParameter<double>("MinTrackPt", 10.0);
   selectionParameters.minQuality      = trackQuality_;
   selectionParameters.maxDxyPV        = iConfig.getUntrackedParameter<double>("MaxDxyPV", 0.2);
   selectionParameters.maxDzPV         = iConfig.getUntrackedParameter<double>("MaxDzPV",  5.0);
   selectionParameters.maxChi2         = iConfig.getUntrackedParameter<double>("MaxChi2",  5.0);
   selectionParameters.maxDpOverP      = iConfig.getUntrackedParameter<double>("MaxDpOverP",  0.1);
   selectionParameters.minOuterHit     = iConfig.getUntrackedParameter<int>("MinOuterHit", 4);
   selectionParameters.minLayerCrossed = iConfig.getUntrackedParameter<int>("MinLayerCrossed", 8);
   selectionParameters.maxInMiss       = iConfig.getUntrackedParameter<int>("MaxInMiss", 0);
   selectionParameters.maxOutMiss      = iConfig.getUntrackedParameter<int>("MaxOutMiss", 0);
   dr_L1                               = iConfig.getUntrackedParameter<double>("IsolationL1",1.0);
   a_coneR                             = iConfig.getUntrackedParameter<double>("ConeRadius",34.98);
   a_charIsoR                          = a_coneR + 28.9;
   a_neutIsoR                          = a_charIsoR*0.726;
   a_mipR                              = iConfig.getUntrackedParameter<double>("ConeRadiusMIP",14.0);
   a_neutR1                            = iConfig.getUntrackedParameter<double>("ConeRadiusNeut1",21.0);
   a_neutR2                            = iConfig.getUntrackedParameter<double>("ConeRadiusNeut2",29.0);
   cutMip                              = iConfig.getUntrackedParameter<double>("MIPCut", 1.0);
   cutCharge                           = iConfig.getUntrackedParameter<double>("ChargeIsolation",  2.0);
   cutNeutral                          = iConfig.getUntrackedParameter<double>("NeutralIsolation",  2.0);
   minRunNo                            = iConfig.getUntrackedParameter<int>("minRun");
   maxRunNo                            = iConfig.getUntrackedParameter<int>("maxRun");
   drCuts                              = iConfig.getUntrackedParameter<std::vector<double> >("DRCuts");
   bool isItAOD                        = iConfig.getUntrackedParameter<bool>("IsItAOD", true);
   triggerEvent_                       = edm::InputTag("hltTriggerSummaryAOD","","HLT");
   theTriggerResultsLabel              = edm::InputTag("TriggerResults","","HLT");
 
   // define tokens for access
   tok_lumi      = consumes<LumiDetails, edm::InLumi>(edm::InputTag("lumiProducer")); 
   tok_trigEvt   = consumes<trigger::TriggerEvent>(triggerEvent_);
   tok_trigRes   = consumes<edm::TriggerResults>(theTriggerResultsLabel);
   tok_genTrack_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
   tok_recVtx_   = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
   tok_bs_       = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
   tok_ew_       = consumes<GenEventInfoProduct>(edm::InputTag("generator")); 
   tok_pf_       = consumes<reco::PFJetCollection>(edm::InputTag("ak5PFJets"));
  
   if (isItAOD) {
     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"));
   }
 
   if (verbosity>=0) {
     edm::LogInfo("IsoTrack") <<"Parameters read from config file \n" 
                  <<"\t minPt "           << selectionParameters.minPt   
                  <<"\t theTrackQuality " << theTrackQuality
                  <<"\t minQuality "      << selectionParameters.minQuality
                  <<"\t maxDxyPV "        << selectionParameters.maxDxyPV          
                  <<"\t maxDzPV "         << selectionParameters.maxDzPV          
                  <<"\t maxChi2 "         << selectionParameters.maxChi2          
                  <<"\t maxDpOverP "      << selectionParameters.maxDpOverP
                  <<"\t minOuterHit "     << selectionParameters.minOuterHit
                  <<"\t minLayerCrossed " << selectionParameters.minLayerCrossed
                  <<"\t maxInMiss "       << selectionParameters.maxInMiss
                  <<"\t maxOutMiss "      << selectionParameters.maxOutMiss
                  <<"\t a_coneR "         << a_coneR          
                  <<"\t a_charIsoR "      << a_charIsoR          
                  <<"\t a_neutIsoR "      << a_neutIsoR          
                  <<"\t a_mipR "          << a_mipR 
                  <<"\t a_neutR "         << a_neutR1 << ":" << a_neutR2
                  <<"\t cuts (MIP "       << cutMip << " : Charge " << cutCharge
                  <<" : Neutral "         << cutNeutral << ")";
     edm::LogInfo("IsoTrack") << trigNames.size() << " triggers to be studied";
     for (unsigned int k=0; k<trigNames.size(); ++k)
       edm::LogInfo("IsoTrack") << "Trigger[" << k << "] : " << trigNames[k];
     edm::LogInfo("IsoTrack") << drCuts.size() << " Delta R zones wrt trigger objects";
     for (unsigned int k=0; k<drCuts.size(); ++k)
       edm::LogInfo("IsoTrack") << "Cut[" << k << "]: " << drCuts[k];
   }
 }

IsoTrackCalib::~IsoTrackCalib ( )

Definition at line 89 of file IsoTrackCalib.cc.

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

Member Function Documentation

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

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 95 of file IsoTrackCalib.cc.

                                                                                {
 
   Run    = iEvent.id().run();
   Event  = iEvent.id().event();
   if (verbosity%10 > 0) 
     edm::LogInfo("IsoTrack") << "Run " << Run << " Event " << Event
                  << " Luminosity " << iEvent.luminosityBlock() 
                  << " Bunch " << iEvent.bunchCrossing() << " start";
   clearTreeVectors();
 
   //Get magnetic field and ECAL channel status
   edm::ESHandle<MagneticField> bFieldH;
   iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
   const MagneticField *bField = bFieldH.product();
   
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
   iSetup.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
 
   // get handles to calogeometry and calotopology
   edm::ESHandle<CaloGeometry> pG;
   iSetup.get<CaloGeometryRecord>().get(pG);
   const CaloGeometry* geo = pG.product();
   
   //Get track collection
   edm::Handle<reco::TrackCollection> trkCollection;
   iEvent.getByToken(tok_genTrack_, trkCollection);
   reco::TrackCollection::const_iterator trkItr;
  
   double flatPtWeight = 0.0;
   //event weight for FLAT sample
   edm::Handle<GenEventInfoProduct> genEventInfo;
   iEvent.getByToken(tok_ew_, genEventInfo);
   flatPtWeight = genEventInfo->weight();  
 
   //jets info
   edm::Handle<reco::PFJetCollection> pfJetsHandle;
   iEvent.getByToken(tok_pf_, pfJetsHandle);   
   reco::PFJetCollection::const_iterator pfItr; 
 
   //Define the best vertex and the beamspot
   edm::Handle<reco::VertexCollection> recVtxs;
   iEvent.getByToken(tok_recVtx_, recVtxs);  
   edm::Handle<reco::BeamSpot> beamSpotH;
   iEvent.getByToken(tok_bs_, beamSpotH);
   math::XYZPoint leadPV(0,0,0);
   if (recVtxs->size()>0 && !((*recVtxs)[0].isFake())) {
     leadPV = math::XYZPoint( (*recVtxs)[0].x(),(*recVtxs)[0].y(), (*recVtxs)[0].z() );
   } else if (beamSpotH.isValid()) {
     leadPV = beamSpotH->position();
   }
   if ((verbosity/100)%10>0) {
     edm::LogInfo("IsoTrack") << "Primary Vertex " << leadPV;
     if (beamSpotH.isValid()) edm::LogInfo("IsoTrack") << "Beam Spot " 
                               << beamSpotH->position();
   }
   
   // RecHits
   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<LumiDetails> Lumid;
   iEvent.getLuminosityBlock().getByToken(tok_lumi, Lumid); 
   float mybxlumi=-1;
   if (Lumid.isValid()) 
   mybxlumi=Lumid->lumiValue(LumiDetails::kOCC1,iEvent.bunchCrossing())*6.37;
   if (verbosity%10 > 0) edm::LogInfo("IsoTrack") << "Luminosity " << mybxlumi;
 
   trigger::TriggerEvent triggerEvent;
   edm::Handle<trigger::TriggerEvent> triggerEventHandle;
   iEvent.getByToken(tok_trigEvt, triggerEventHandle);
   if (!triggerEventHandle.isValid()) {
     edm::LogWarning("IsoTrack") << "Error! Can't get the product "
                 << triggerEvent_.label();
   } else {
     triggerEvent = *(triggerEventHandle.product());
     
     const trigger::TriggerObjectCollection& TOC(triggerEvent.getObjects());
     edm::Handle<edm::TriggerResults> triggerResults;
     iEvent.getByToken(tok_trigRes, triggerResults);
     if (triggerResults.isValid()) {
       std::vector<std::string> modules;
       h_nHLT->Fill(triggerResults->size());
       const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
       
       const std::vector<std::string> & triggerNames_ = triggerNames.triggerNames();
       for (unsigned int iHLT=0; iHLT<triggerResults->size(); iHLT++) {
       bool ok(false);
     unsigned int triggerindx = hltConfig_.triggerIndex(triggerNames_[iHLT]);
     const std::vector<std::string>& moduleLabels(hltConfig_.moduleLabels(triggerindx));
         edm::LogInfo("IsoTrack") << iHLT << "   " <<triggerNames_[iHLT];
     int ipos = -1;
     for (unsigned int i=0; i<HLTNames.size(); ++i) {
       if (triggerNames_[iHLT] == HLTNames[i]) {
         ipos = i;
         break;
       }
     }
     if (ipos < 0) {
       ipos = (int)(HLTNames.size()+1);
       HLTNames.push_back(triggerNames_[iHLT]);
       h_HLTAccept->GetXaxis()->SetBinLabel(ipos+1,triggerNames_[iHLT].c_str());
     }
     if (firstEvent)  h_HLTAccepts[nRun]->GetXaxis()->SetBinLabel(iHLT+1, triggerNames_[iHLT].c_str());
     int hlt    = triggerResults->accept(iHLT);
     if (hlt) {
       h_HLTAccepts[nRun]->Fill(iHLT+1);
       h_HLTAccept->Fill(ipos+1);
     }
     if (iHLT >= 645) edm::LogInfo("IsoTrack") << "Wrong trigger " << Run 
                           << " Event " << Event 
                           << " Hlt " << iHLT;
     for (unsigned int i=0; i<trigNames.size(); ++i) {
       if (triggerNames_[iHLT].find(trigNames[i].c_str())!=std::string::npos) {
         if (verbosity)
           edm::LogInfo("IsoTrack") << "This is the trigger we are looking for " << triggerNames_[iHLT];
         if (hlt > 0) ok = true;
       }
     }
         if (verbosity%10 > 2) 
       edm::LogInfo("IsoTrack") << "Trigger fired? : " << ok;
     if (ok) {
       std::vector<math::XYZTLorentzVector> vec[3];
       const std::pair<int,int> prescales(hltConfig_.prescaleValues(iEvent,iSetup,triggerNames_[iHLT]));
       int preL1  = prescales.first;
       int preHLT = prescales.second;
       int prescale = preL1*preHLT;
       if (verbosity%10 > 0) 
         edm::LogInfo("IsoTrack") << triggerNames_[iHLT] << " accept " 
                      << hlt << " preL1 " << preL1 << " preHLT "
                      << preHLT << " preScale " << prescale;
       std::pair<unsigned int, std::string> iRunTrig =
         std::pair<unsigned int, std::string>(Run,triggerNames_[iHLT]);
       if (TrigList.find(iRunTrig) != TrigList.end() ) {
         TrigList[iRunTrig] += 1;
       } else {
         TrigList.insert(std::pair<std::pair<unsigned int, std::string>, unsigned int>(iRunTrig,1));
         TrigPreList.insert(std::pair<std::pair<unsigned int, std::string>, std::pair<int, int>>(iRunTrig,prescales));
       }
       //loop over all trigger filters in event (i.e. filters passed)
       for (unsigned int ifilter=0; ifilter<triggerEvent.sizeFilters(); ++ifilter) {  
         std::vector<int> Keys;
         std::string label = triggerEvent.filterTag(ifilter).label();
         //loop over keys to objects passing this filter
         for (unsigned int imodule=0; imodule<moduleLabels.size(); imodule++) {
           if (label.find(moduleLabels[imodule]) != std::string::npos) {
         if (verbosity%10 > 0) 
           edm::LogInfo("IsoTrack") << "FilterName " << label;
         for (unsigned int ifiltrKey=0; ifiltrKey<triggerEvent.filterKeys(ifilter).size(); ++ifiltrKey) {
           Keys.push_back(triggerEvent.filterKeys(ifilter)[ifiltrKey]);
           const trigger::TriggerObject& TO(TOC[Keys[ifiltrKey]]);
           math::XYZTLorentzVector v4(TO.px(), TO.py(), TO.pz(), TO.energy());
                   if(label.find("hltSingleJet") != std::string::npos) {
             vec[1].push_back(v4);
                   } else if (label.find("hlt1PFJet") != std::string::npos) {
             vec[2].push_back(v4);
           } else {
             vec[0].push_back(v4);
           }
           if (verbosity%10 > 2)
             edm::LogInfo("IsoTrack") << "key " << ifiltrKey << " : pt " 
                          << TO.pt() << " eta " << TO.eta()
                          << " phi " << TO.phi() << " mass "
                          << TO.mass() << " Id " << TO.id();
         }
           }
         }
       }
       if (verbosity%10 > 0) {
         for (int j=0; j<3; j++) {
           for (unsigned int k=0; k<vec[j].size(); k++) {
         edm::LogInfo("IsoTrack") << "vec[" << j << "][" << k << "] pt " 
                      << vec[j][k].pt() << " eta " 
                      << vec[j][k].eta() << " phi "
                      << vec[j][k].phi();
           }
         }
       }
       double deta, dphi, dr;
       math::XYZTLorentzVector mindRvec1;
       double mindR1(999);
       for (int lvl=1; lvl<3; lvl++) {
         for (unsigned int i=0; i<vec[lvl].size(); i++) {
           deta = dEta(vec[0][0],vec[lvl][i]);
           dphi = dPhi(vec[0][0],vec[lvl][i]);
           dr   = dR(vec[0][0],vec[lvl][i]);
           if (verbosity%10 > 2) 
         edm::LogInfo("IsoTrack") << "lvl " << lvl << " i " << i 
                      << " deta " << deta << " dphi " 
                      << dphi << " dR " << dr;
           if (dr<mindR1) {
         mindR1    = dr;
         mindRvec1 = vec[lvl][i];
           }
         }
       }
           //leading jet loop
           for(pfItr=pfJetsHandle->begin();pfItr!=pfJetsHandle->end(); pfItr++){
         t_leadingpt->push_back(pfItr->pt());  
         t_leadingeta->push_back(pfItr->eta());
         t_leadingphi->push_back(pfItr->phi());
         if (verbosity%10 > 0) 
           edm::LogInfo("IsoTrack") << "Leading jet : pt/eta/phi " 
                        << pfItr->pt() << "/" << pfItr->eta()
                        << "/" << pfItr->phi();
         break;
       }
       //tracks loop
       std::vector<spr::propagatedTrackDirection> trkCaloDirections;
       spr::propagateCALO(trkCollection, geo, bField, theTrackQuality, trkCaloDirections, ((verbosity/100)%10>2));
       std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
       unsigned int nTracks=0,nselTracks=0;
       for (trkDetItr = trkCaloDirections.begin(),nTracks=0; 
            trkDetItr != trkCaloDirections.end(); trkDetItr++,nTracks++) {
         const reco::Track* pTrack = &(*(trkDetItr->trkItr));
             math::XYZTLorentzVector v4(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
             TLorentzVector trackinfo;
             trackinfo.SetPxPyPzE(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
         if (verbosity%10 > 0) 
           edm::LogInfo("IsoTrack") << "This track : " << nTracks 
                        << " (pt/eta/phi/p) :" << pTrack->pt() 
                        << "/" << pTrack->eta() << "/" 
                        << pTrack->phi() << "/" << pTrack->p();
         math::XYZTLorentzVector mindRvec2;
         double mindR2(999);
             if(pTrack->pt()>10){
           for (unsigned int k=0; k<vec[2].size(); ++k) {
         dr   = dR(vec[2][k],v4); //changed 1 to 2
         if (dr<mindR2) {
           mindR2    = dr;
           mindRvec2 = vec[2][k];
         }
           }
           if (verbosity%10 > 2)
         edm::LogInfo("IsoTrack") << "Closest L3 object at mindr :" 
                      << mindR2 << " is " << mindRvec2;
           double mindR = dR(mindRvec1,v4);
         
           unsigned int i1 = drCuts.size();
           for (unsigned int ik=0; ik<drCuts.size(); ++ik) {
         if (mindR < drCuts[ik]) {
           i1 = ik; break;
         }
           }
           unsigned int i2 = drCuts.size();
           for (unsigned int ik=0; ik<drCuts.size(); ++ik) {
         if (mindR2 < drCuts[ik]) {
           i2 = ik; break;
         }
           }
         
           //Selection of good track
           bool selectTk = spr::goodTrack(pTrack,leadPV,selectionParameters,((verbosity/100)%10>2));
           int ieta(0);
           if (trkDetItr->okHCAL) {
         HcalDetId detId = (HcalDetId)(trkDetItr->detIdHCAL);
         ieta = detId.ieta();
           }
           if (verbosity%10 > 0) 
         edm::LogInfo("IsoTrack") << "seltlk/okECAL/okHCAL : "<< selectTk
                      << "/"  << trkDetItr->okECAL << "/" 
                      << trkDetItr->okHCAL  << " iEta " 
                      << ieta << " Classify " << i1 << ":" 
                      << i2;
           if (selectTk && trkDetItr->okECAL && trkDetItr->okHCAL) {
         nselTracks++;
         int nRH_eMipDR=0, nNearTRKs=0;
         double e1 =  spr::eCone_ecal(geo, barrelRecHitsHandle, endcapRecHitsHandle,
                          trkDetItr->pointHCAL, trkDetItr->pointECAL,
                          a_neutR1, trkDetItr->directionECAL, nRH_eMipDR);
         double e2 =  spr::eCone_ecal(geo, barrelRecHitsHandle, endcapRecHitsHandle,
                          trkDetItr->pointHCAL, trkDetItr->pointECAL,
                          a_neutR2, trkDetItr->directionECAL, nRH_eMipDR);
         double eMipDR = spr::eCone_ecal(geo, barrelRecHitsHandle, endcapRecHitsHandle,
                         trkDetItr->pointHCAL, trkDetItr->pointECAL,
                         a_mipR, trkDetItr->directionECAL, nRH_eMipDR);
         int ietaHotCell(-99), iphiHotCell(-99), nRecHitsCone(-999);
         double distFromHotCell(-99.0);
         std::vector<DetId>    coneRecHitDetIds;
         GlobalPoint           gposHotCell(0.,0.,0.);
         double eHcal = spr::eCone_hcal(geo, hbhe, trkDetItr->pointHCAL, trkDetItr->pointECAL,
                            a_coneR, trkDetItr->directionHCAL, nRecHitsCone, 
                            coneRecHitDetIds, distFromHotCell, 
                            ietaHotCell, iphiHotCell, gposHotCell);
           
         double conehmaxNearP = spr::chargeIsolationCone(nTracks, trkCaloDirections, a_charIsoR, nNearTRKs, ((verbosity/100)%10>2));
         double e_inCone = e2 - e1;
 
         if (verbosity%10 > 0) {
           edm::LogInfo("IsoTrack") << "This track : " << nTracks 
                        <<" (pt/eta/phi/p) :" << pTrack->pt()
                        << "/" << pTrack->eta() << "/" 
                        << pTrack->phi() << "/" 
                        << pTrack->p() << "\n"
                        << " (MIP/neu_isol/charge_iso/HCAL_energy/iEta/distfromHcell/iEtaHcell) = " 
                        << eMipDR << "/"<< e_inCone << "/" 
                        << conehmaxNearP << "/" << eHcal 
                        << "/" << ieta << "/" << distFromHotCell
                        << "/" <<ietaHotCell;
         }
         t_trackP->push_back(pTrack->p());
         t_trackPx->push_back(pTrack->px());
         t_trackPy->push_back(pTrack->py()); 
         t_trackPz->push_back(pTrack->pz());
         t_trackPt->push_back(pTrack->pt());;
         t_trackEta->push_back(pTrack->eta());
         t_trackPhi->push_back(pTrack->phi());
         t_emip->push_back(eMipDR);
         t_neu_iso->push_back(e_inCone);;
         t_charge_iso->push_back(conehmaxNearP);
         t_ehcal->push_back(eHcal);
         t_trkL3mindr->push_back(mindR2);
         t_ieta->push_back(ieta);
         t_disthotcell->push_back(distFromHotCell); 
         t_ietahotcell->push_back(ietaHotCell);
           }
         }
       }
       if (verbosity%10 > 0) {
         edm::LogInfo("IsoTrack") << "selected tracks = " << nselTracks 
                      << "\nevent weight is = " << flatPtWeight 
                      << "\n L1 trigger object : pt/eta/phi " 
                      << vec[0][0].pt() << "/" << vec[0][0].eta()
                      << "/" << vec[0][0].phi()
                      << "\n L3 trigger object : pt/eta/phi " 
                      << vec[2][0].pt() << "/" << vec[2][0].eta()
                      << "/"<< vec[2][0].phi();
       }
       t_l1pt->push_back(vec[0][0].pt());
       t_l1eta->push_back(vec[0][0].eta());
       t_l1phi->push_back(vec[0][0].phi());
       t_l3pt->push_back(vec[2][0].pt());
       t_l3eta->push_back(vec[2][0].eta());
       t_l3phi->push_back(vec[2][0].phi());
       t_eventweight->push_back(flatPtWeight);
       //      break;
     }
       }
       // check if trigger names in (new) config                       
       if (changed) {
     changed = false;
     if ((verbosity/10)%10 > 1) {
       edm::LogInfo("IsoTrack") <<"New trigger menu found !!!";
       const unsigned int n(hltConfig_.size());
       for (unsigned itrig=0; itrig<triggerNames_.size(); itrig++) {
         unsigned int triggerindx = hltConfig_.triggerIndex(triggerNames_[itrig]);
         if (triggerindx >= n)
           edm::LogInfo("IsoTrack") << triggerNames_[itrig] << " " 
                        << triggerindx << " does not exist";
         else
           edm::LogInfo("IsoTrack") << triggerNames_[itrig] << " " 
                        << triggerindx << " exists";
       }
     }
       }
     }
   }
   tree->Fill();
 }

void IsoTrackCalib::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 461 of file IsoTrackCalib.cc.

References fs, h_HLTAccept, h_nHLT, TFileService::make(), t_charge_iso, t_disthotcell, t_ehcal, t_emip, t_eventweight, t_ieta, t_ietahotcell, t_l1eta, t_l1phi, t_l1pt, t_l3eta, t_l3phi, t_l3pt, t_leadingeta, t_leadingphi, t_leadingpt, t_neu_iso, t_trackEta, t_trackP, t_trackPhi, t_trackPt, t_trackPx, t_trackPy, t_trackPz, t_trkL3mindr, and tree.

                              {
   h_nHLT        = fs->make<TH1I>("h_nHLT" , "size of trigger Names", 1000, 0, 1000);
   h_HLTAccept   = fs->make<TH1I>("h_HLTAccept", "HLT Accepts for all runs", 1000, 0, 1000);
   tree = fs->make<TTree>("tree", "tree");
    
   tree->Branch("Run",&Run,"Run/I");
   tree->Branch("Event",&Event,"Event/I");
   t_trackP = new std::vector<double>();
   t_trackPx = new std::vector<double>();
   t_trackPy = new std::vector<double>();
   t_trackPz = new std::vector<double>();
   t_trackEta = new std::vector<double>();
   t_trackPhi = new std::vector<double>();
   t_trackPt = new std::vector<double>();
   t_neu_iso = new std::vector<double>();
   t_charge_iso = new std::vector<double>();
   t_emip = new std::vector<double>();
   t_ehcal = new std::vector<double>(); 
   t_trkL3mindr = new std::vector<double>();
   t_ieta = new std::vector<int>();
   t_disthotcell = new std::vector<double>();
   t_ietahotcell = new std::vector<double>(); 
   t_eventweight = new std::vector<double>();
   t_l1pt = new std::vector<double>();
   t_l1eta = new std::vector<double>();
   t_l1phi = new std::vector<double>();
   t_l3pt = new std::vector<double>();
   t_l3eta = new std::vector<double>();
   t_l3phi = new std::vector<double>();
   t_leadingpt = new std::vector<double>();
   t_leadingeta = new std::vector<double>();
   t_leadingphi = new std::vector<double>();
 
   tree->Branch("t_trackP","std::vector<double>",&t_trackP);
   tree->Branch("t_trackPx","std::vector<double>",&t_trackPx);
   tree->Branch("t_trackPy","std::vector<double>",&t_trackPy);
   tree->Branch("t_trackPz","std::vector<double>",&t_trackPz);
   tree->Branch("t_trackEta","std::vector<double>",&t_trackEta);
   tree->Branch("t_trackPhi","vector<double>",&t_trackPhi);
   tree->Branch("t_trackPt","std::vector<double>",&t_trackPt);
   tree->Branch("t_neu_iso","std::vector<double>",&t_neu_iso);
   tree->Branch("t_charge_iso","std::vector<double>",&t_charge_iso);
   tree->Branch("t_emip","std::vector<double>",&t_emip);
   tree->Branch("t_ehcal","std::vector<double>",&t_ehcal);
   tree->Branch("t_trkL3mindr","std::vector<double>",&t_trkL3mindr);
   tree->Branch("t_ieta","std::vector<int>",&t_ieta);  
   tree->Branch("t_disthotcell","std::vector<double>",&t_disthotcell);
   tree->Branch("t_ietahotcell","std::vector<double>",&t_ietahotcell);
   tree->Branch("t_eventweight","std::vector<double>",&t_eventweight);
   tree->Branch("t_l1pt","std::vector<double>",&t_l1pt);
   tree->Branch("t_l1eta","std::vector<double>",&t_l1eta);
   tree->Branch("t_l1phi","std::vector<double>",&t_l1phi);
   tree->Branch("t_l3pt","std::vector<double>",&t_l3pt);
   tree->Branch("t_l3eta","std::vector<double>",&t_l3eta);
   tree->Branch("t_l3phi","std::vector<double>",&t_l3phi);
   tree->Branch("t_leadingpt","std::vector<double>",&t_leadingpt); 
   tree->Branch("t_leadingeta","std::vector<double>",&t_leadingeta);
   tree->Branch("t_leadingphi","std::vector<double>",&t_leadingphi);  
 }

void IsoTrackCalib::beginLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 562 of file IsoTrackCalib.cc.

562 {}

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 544 of file IsoTrackCalib.cc.

References changed, firstEvent, fs, h_HLTAccepts, hltConfig_, HLTConfigProvider::init(), TFileService::make(), nRun, and edm::RunBase::run().

                                                                             {
   edm::LogInfo("IsoTrack") << "Run[" << nRun <<"] " << iRun.run() 
                << " hltconfig.init " << hltConfig_.init(iRun,iSetup,"HLT",changed);
   char  hname[100], htit[100];
   sprintf(hname, "h_HLTAccepts_%i", iRun.run());
   sprintf(htit, "HLT Accepts for Run No %i", iRun.run());
   TH1I *hnew = fs->make<TH1I>(hname, htit, 1000, 0, 1000);
   h_HLTAccepts.push_back(hnew);
   firstEvent = true;
 }

void IsoTrackCalib::clearTreeVectors ( )

private

Definition at line 598 of file IsoTrackCalib.cc.

References t_charge_iso, t_disthotcell, t_ehcal, t_emip, t_eventweight, t_ieta, t_ietahotcell, t_l1eta, t_l1phi, t_l1pt, t_l3eta, t_l3phi, t_l3pt, t_leadingeta, t_leadingphi, t_leadingpt, t_neu_iso, t_trackEta, t_trackP, t_trackPhi, t_trackPt, t_trackPx, t_trackPy, t_trackPz, and t_trkL3mindr.

Referenced by analyze().

                                     {
    t_trackP->clear();
    t_trackPx->clear();  
    t_trackPy->clear();
    t_trackPz->clear();
    t_trackPt->clear();
    t_trackEta->clear(); 
    t_trackPhi->clear();
    t_emip->clear();
    t_neu_iso->clear();;
    t_charge_iso->clear();
    t_ehcal->clear();
    t_trkL3mindr->clear();
    t_ieta->clear(); 
    t_disthotcell->clear();
    t_ietahotcell->clear();
    t_eventweight->clear();  
    t_l1pt->clear();
    t_l1eta->clear();
    t_l1phi->clear();
    t_l3pt->clear();
    t_l3eta->clear();
    t_l3phi->clear(); 
    t_leadingpt->clear();
    t_leadingeta->clear();
    t_leadingphi->clear();  
 }

double IsoTrackCalib::dEta	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 574 of file IsoTrackCalib.cc.

Referenced by analyze().

                                                                                    {
   return (vec1.eta()-vec2.eta());
 }

double IsoTrackCalib::dinvPt	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 594 of file IsoTrackCalib.cc.

                                                                                      {
   return ((1/vec1.pt())-(1/vec2.pt()));
 }

double IsoTrackCalib::dP	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 590 of file IsoTrackCalib.cc.

References funct::abs().

                                                                                  {
   return (std::abs(vec1.r()-vec2.r()));
 }

double IsoTrackCalib::dPhi	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 578 of file IsoTrackCalib.cc.

References reco::deltaPhi().

Referenced by analyze().

                                                                                    {
   return reco::deltaPhi(vec1.phi(),vec2.phi());
 }

double IsoTrackCalib::dPt	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 586 of file IsoTrackCalib.cc.

                                                                                   {
   return (vec1.pt()-vec2.pt());
 }

double IsoTrackCalib::dR	(	double	eta1,
		double	eta2,
		double	phi1,
		double	phi2
	)

Referenced by analyze().

double IsoTrackCalib::dR	(	math::XYZTLorentzVector &	vec1,
		math::XYZTLorentzVector &	vec2
	)

private

Definition at line 582 of file IsoTrackCalib.cc.

References reco::deltaR().

                                                                                  {
   return reco::deltaR(vec1.eta(),vec1.phi(),vec2.eta(),vec2.phi());
 }

void IsoTrackCalib::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 522 of file IsoTrackCalib.cc.

References first, fs, g_Accepts, g_Pre, g_PreHLT, g_PreL1, TFileService::make(), maxRunNo, minRunNo, n, edm::second(), TrigList, and TrigPreList.

                            {
   unsigned int preL1, preHLT;
   std::map<std::pair<unsigned int, std::string>, unsigned int>::iterator itr;
   std::map<std::pair<unsigned int, std::string>, const std::pair<int, int>>::iterator itrPre;
   edm::LogInfo("IsoTrack") << "RunNo vs HLT accepts";
   unsigned int n = maxRunNo - minRunNo +1;
   g_Pre = fs->make<TH1I>("h_PrevsRN", "PreScale Vs Run Number", n, minRunNo, maxRunNo);
   g_PreL1 = fs->make<TH1I>("h_PreL1vsRN", "L1 PreScale Vs Run Number", n, minRunNo, maxRunNo);
   g_PreHLT = fs->make<TH1I>("h_PreHLTvsRN", "HLT PreScale Vs Run Number", n, minRunNo, maxRunNo);
   g_Accepts = fs->make<TH1I>("h_HLTAcceptsvsRN", "HLT Accepts Vs Run Number", n, minRunNo, maxRunNo); 
 
   for (itr=TrigList.begin(), itrPre=TrigPreList.begin(); itr!=TrigList.end(); itr++, itrPre++) {
     preL1 = (itrPre->second).first;
     preHLT = (itrPre->second).second;
     g_Accepts->Fill((itr->first).first, itr->second);
     g_PreL1->Fill((itr->first).first, preL1);
     g_PreHLT->Fill((itr->first).first, preHLT);
     g_Pre->Fill((itr->first).first, preL1*preHLT);
   }
 }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 564 of file IsoTrackCalib.cc.

564 {}

void IsoTrackCalib::endRun	(	edm::Run const &	iRun,
		edm::EventSetup const &
	)

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 556 of file IsoTrackCalib.cc.

References nRun, and edm::RunBase::run().

                                                                    {
   nRun++;
   edm::LogInfo("IsoTrack") << "endRun[" << nRun << "] " << iRun.run();
 }

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

static

Definition at line 566 of file IsoTrackCalib.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);
 }

Member Data Documentation

double IsoTrackCalib::a_charIsoR

private

Definition at line 103 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

double IsoTrackCalib::a_coneR

private

Definition at line 103 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

double IsoTrackCalib::a_mipR

private

Definition at line 103 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

double IsoTrackCalib::a_neutIsoR

private

Definition at line 103 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

double IsoTrackCalib::a_neutR1

private

Definition at line 104 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

double IsoTrackCalib::a_neutR2

private

Definition at line 104 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

bool IsoTrackCalib::changed

private

Definition at line 96 of file IsoTrackCalib.h.

Referenced by analyze(), and beginRun().

double IsoTrackCalib::cutCharge

private

Definition at line 104 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

double IsoTrackCalib::cutMip

private

Definition at line 104 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

double IsoTrackCalib::cutNeutral

private

Definition at line 104 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

double IsoTrackCalib::dr_L1

private

Definition at line 103 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

std::vector<double> IsoTrackCalib::drCuts

private

Definition at line 106 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

int IsoTrackCalib::Event

private

Definition at line 130 of file IsoTrackCalib.h.

bool IsoTrackCalib::firstEvent

private

Definition at line 122 of file IsoTrackCalib.h.

Referenced by analyze(), beginRun(), looper.Looper::loop(), and Printer.Printer::process().

edm::Service<TFileService> IsoTrackCalib::fs

private

Definition at line 97 of file IsoTrackCalib.h.

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

TH1I * IsoTrackCalib::g_Accepts

private

Definition at line 127 of file IsoTrackCalib.h.

Referenced by endJob().

TH1I* IsoTrackCalib::g_Pre

private

Definition at line 127 of file IsoTrackCalib.h.

Referenced by endJob().

TH1I * IsoTrackCalib::g_PreHLT

private

Definition at line 127 of file IsoTrackCalib.h.

Referenced by endJob().

TH1I * IsoTrackCalib::g_PreL1

private

Definition at line 127 of file IsoTrackCalib.h.

Referenced by endJob().

TH1I * IsoTrackCalib::h_HLTAccept

private

Definition at line 125 of file IsoTrackCalib.h.

Referenced by analyze(), and beginJob().

std::vector<TH1I*> IsoTrackCalib::h_HLTAccepts

private

Definition at line 126 of file IsoTrackCalib.h.

Referenced by analyze(), and beginRun().

TH1I* IsoTrackCalib::h_nHLT

private

Definition at line 125 of file IsoTrackCalib.h.

Referenced by analyze(), and beginJob().

HLTConfigProvider IsoTrackCalib::hltConfig_

private

Definition at line 98 of file IsoTrackCalib.h.

Referenced by analyze(), and beginRun().

std::vector<std::string> IsoTrackCalib::HLTNames

private

Definition at line 99 of file IsoTrackCalib.h.

Referenced by analyze().

int IsoTrackCalib::maxRunNo

private

Definition at line 105 of file IsoTrackCalib.h.

Referenced by endJob(), and IsoTrackCalib().

int IsoTrackCalib::minRunNo

private

Definition at line 105 of file IsoTrackCalib.h.

Referenced by endJob(), and IsoTrackCalib().

int IsoTrackCalib::nRun

private

Definition at line 105 of file IsoTrackCalib.h.

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

int IsoTrackCalib::Run

private

Definition at line 130 of file IsoTrackCalib.h.

Referenced by analyze(), and BeamSpotObj.BeamSpot::Reset().

spr::trackSelectionParameters IsoTrackCalib::selectionParameters

private

Definition at line 101 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

std::vector<double>* IsoTrackCalib::t_charge_iso

private

Definition at line 140 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_disthotcell

private

Definition at line 144 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_ehcal

private

Definition at line 141 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_emip

private

Definition at line 138 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_eventweight

private

Definition at line 146 of file IsoTrackCalib.h.

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

std::vector<int>* IsoTrackCalib::t_ieta

private

Definition at line 143 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_ietahotcell

private

Definition at line 145 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l1eta

private

Definition at line 148 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l1phi

private

Definition at line 149 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l1pt

private

Definition at line 147 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l3eta

private

Definition at line 151 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l3phi

private

Definition at line 152 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_l3pt

private

Definition at line 150 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_leadingeta

private

Definition at line 154 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_leadingphi

private

Definition at line 155 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_leadingpt

private

Definition at line 153 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_neu_iso

private

Definition at line 139 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackEta

private

Definition at line 136 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackP

private

Definition at line 131 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackPhi

private

Definition at line 137 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackPt

private

Definition at line 135 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackPx

private

Definition at line 132 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackPy

private

Definition at line 133 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trackPz

private

Definition at line 134 of file IsoTrackCalib.h.

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

std::vector<double>* IsoTrackCalib::t_trkL3mindr

private

Definition at line 142 of file IsoTrackCalib.h.

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

std::string IsoTrackCalib::theTrackQuality

private

Definition at line 102 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::InputTag IsoTrackCalib::theTriggerResultsLabel

private

Definition at line 108 of file IsoTrackCalib.h.

Referenced by IsoTrackCalib().

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

private

Definition at line 115 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<EcalRecHitCollection> IsoTrackCalib::tok_EB_

private

Definition at line 116 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<EcalRecHitCollection> IsoTrackCalib::tok_EE_

private

Definition at line 117 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<GenEventInfoProduct> IsoTrackCalib::tok_ew_

private

Definition at line 119 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<reco::TrackCollection> IsoTrackCalib::tok_genTrack_

private

Definition at line 113 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<HBHERecHitCollection> IsoTrackCalib::tok_hbhe_

private

Definition at line 118 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<LumiDetails> IsoTrackCalib::tok_lumi

private

Definition at line 109 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<reco::PFJetCollection> IsoTrackCalib::tok_pf_

private

Definition at line 120 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

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

private

Definition at line 114 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<trigger::TriggerEvent> IsoTrackCalib::tok_trigEvt

private

Definition at line 110 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

edm::EDGetTokenT<edm::TriggerResults> IsoTrackCalib::tok_trigRes

private

Definition at line 111 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

TTree* IsoTrackCalib::tree

private

Definition at line 129 of file IsoTrackCalib.h.

Referenced by eventstfile.Events::__iter__(), svgfig.SVG::__str__(), analyze(), beginJob(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), MetTreeProducer.MetTreeProducer::process(), python.cmstools.EventTree::SetAlias(), and eventstfile.Events::to().

edm::InputTag IsoTrackCalib::triggerEvent_

private

Definition at line 108 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

std::map<std::pair<unsigned int, std::string>, unsigned int> IsoTrackCalib::TrigList

private

Definition at line 123 of file IsoTrackCalib.h.

Referenced by analyze(), and endJob().

std::vector<std::string> IsoTrackCalib::trigNames

private

Definition at line 99 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

std::map<std::pair<unsigned int, std::string>, const std::pair<int, int> > IsoTrackCalib::TrigPreList

private

Definition at line 124 of file IsoTrackCalib.h.

Referenced by analyze(), and endJob().

int IsoTrackCalib::verbosity

private

Definition at line 100 of file IsoTrackCalib.h.

Referenced by analyze(), and IsoTrackCalib().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation