00001
00002
00003
00004
00005
00006 #include "RecoJets/JetAnalyzers/interface/myJetAna.h"
00007 #include "RecoJets/JetAlgorithms/interface/JetAlgoHelper.h"
00008 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
00009 #include "DataFormats/JetReco/interface/CaloJet.h"
00010 #include "DataFormats/JetReco/interface/GenJet.h"
00011 #include "DataFormats/METReco/interface/CaloMETCollection.h"
00012 #include "DataFormats/METReco/interface/CaloMET.h"
00013
00014 #include "DataFormats/Common/interface/Handle.h"
00015 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalCaloFlagLabels.h"
00016
00017 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
00018 #include "DataFormats/HcalRecHit/interface/HcalSourcePositionData.h"
00019 #include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
00020
00021 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
00022 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
00023 #include "DataFormats/EcalDetId/interface/EBDetId.h"
00024 #include "DataFormats/EcalDetId/interface/EEDetId.h"
00025
00026 #include "FWCore/Framework/interface/ESHandle.h"
00027 #include "Geometry/Records/interface/CaloGeometryRecord.h"
00028 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
00029 #include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
00030 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
00031 #include "Geometry/CaloEventSetup/interface/CaloTopologyRecord.h"
00032
00033 #include "DataFormats/TrackReco/interface/Track.h"
00034 #include "DataFormats/TrackReco/interface/TrackFwd.h"
00035 #include "DataFormats/TrackReco/interface/Track.h"
00036 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
00037
00038 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
00039
00040 #include "DataFormats/MuonReco/interface/Muon.h"
00041 #include "DataFormats/MuonReco/interface/MuonFwd.h"
00042
00043 #include "DataFormats/VertexReco/interface/Vertex.h"
00044 #include "DataFormats/VertexReco/interface/VertexFwd.h"
00045
00046
00047
00048
00049
00050 #include "DataFormats/Math/interface/deltaR.h"
00051 #include "DataFormats/Math/interface/deltaPhi.h"
00052
00053 #include "DataFormats/Candidate/interface/Candidate.h"
00054
00055 #include "FWCore/Framework/interface/Event.h"
00056
00057 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00058
00059 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
00060
00061 #include "DataFormats/HLTReco/interface/TriggerObject.h"
00062
00063 #include "DataFormats/Common/interface/TriggerResults.h"
00064 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
00065 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
00066
00067
00068
00069
00070 #include "CommonTools/RecoAlgos/interface/HBHENoiseFilter.h"
00071 #include "DataFormats/METReco/interface/HcalNoiseSummary.h"
00072
00073 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalCaloFlagLabels.h"
00074
00075
00076 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00077 #include "JetMETCorrections/Objects/interface/JetCorrector.h"
00078 #include <TROOT.h>
00079 #include <TSystem.h>
00080 #include <TFile.h>
00081 #include <TCanvas.h>
00082 #include <cmath>
00083
00084 using namespace edm;
00085 using namespace reco;
00086 using namespace std;
00087
00088
00089 #define INVALID 9999.
00090 #define DEBUG false
00091 #define MAXJETS 100
00092
00093 typedef struct RBX_struct {
00094 double et;
00095 double hadEnergy;
00096 double emEnergy;
00097 float hcalTime;
00098 float ecalTime;
00099 int nTowers;
00100 } RBX ;
00101
00102 typedef struct HPD_struct {
00103 double et;
00104 double hadEnergy;
00105 double emEnergy;
00106 double time;
00107 float hcalTime;
00108 float ecalTime;
00109 int nTowers;
00110 } HPD ;
00111
00112
00113
00114 float totBNC, nBNC[4000];
00115
00116 RBX RBXColl[36];
00117 HPD HPDColl[144];
00118
00119
00120
00121
00122
00123
00124
00125 myJetAna::myJetAna( const ParameterSet & cfg ) :
00126 CaloJetAlgorithm( cfg.getParameter<string>( "CaloJetAlgorithm" ) ),
00127 GenJetAlgorithm( cfg.getParameter<string>( "GenJetAlgorithm" ) )
00128 {
00129 theTriggerResultsLabel = cfg.getParameter<edm::InputTag>("TriggerResultsLabel");
00130 }
00131
00132
00133
00134
00135
00136 void myJetAna::beginJob( ) {
00137
00138
00139
00140 edm::Service<TFileService> fs;
00141
00142
00143 h_pt = fs->make<TH1F>( "pt", "Jet p_{T}", 100, 0, 50 );
00144 h_ptRBX = fs->make<TH1F>( "ptRBX", "RBX: Jet p_{T}", 100, 0, 50 );
00145 h_ptHPD = fs->make<TH1F>( "ptHPD", "HPD: Jet p_{T}", 100, 0, 50 );
00146 h_ptTower = fs->make<TH1F>( "ptTower", "Jet p_{T}", 100, 0, 50 );
00147 h_et = fs->make<TH1F>( "et", "Jet E_{T}", 100, 0, 50 );
00148 h_eta = fs->make<TH1F>( "eta", "Jet #eta", 100, -5, 5 );
00149 h_phi = fs->make<TH1F>( "phi", "Jet #phi", 50, -M_PI, M_PI );
00150
00151
00152 hitEtaEt = fs->make<TH1F>( "hitEtaEt", "RecHit #eta", 90, -45, 45 );
00153 hitEta = fs->make<TH1F>( "hitEta", "RecHit #eta", 90, -45, 45 );
00154 hitPhi = fs->make<TH1F>( "hitPhi", "RecHit #phi", 73, 0, 73 );
00155
00156 caloEtaEt = fs->make<TH1F>( "caloEtaEt", "CaloTower #eta", 100, -4, 4 );
00157 caloEta = fs->make<TH1F>( "caloEta", "CaloTower #eta", 100, -4, 4 );
00158 caloPhi = fs->make<TH1F>( "caloPhi", "CaloTower #phi", 50, -M_PI, M_PI );
00159
00160 dijetMass = fs->make<TH1F>("dijetMass","DiJet Mass",100,0,100);
00161
00162 totEneLeadJetEta1 = fs->make<TH1F>("totEneLeadJetEta1","Total Energy Lead Jet Eta1 1",100,0,100);
00163 totEneLeadJetEta2 = fs->make<TH1F>("totEneLeadJetEta2","Total Energy Lead Jet Eta2 1",150,0,150);
00164 totEneLeadJetEta3 = fs->make<TH1F>("totEneLeadJetEta3","Total Energy Lead Jet Eta3 1",150,0,150);
00165
00166 hadEneLeadJetEta1 = fs->make<TH1F>("hadEneLeadJetEta1","Hadronic Energy Lead Jet Eta1 1",50,0,50);
00167 hadEneLeadJetEta2 = fs->make<TH1F>("hadEneLeadJetEta2","Hadronic Energy Lead Jet Eta2 1",100,0,100);
00168 hadEneLeadJetEta3 = fs->make<TH1F>("hadEneLeadJetEta3","Hadronic Energy Lead Jet Eta3 1",100,0,100);
00169 emEneLeadJetEta1 = fs->make<TH1F>("emEneLeadJetEta1","EM Energy Lead Jet Eta1 1",50,0,50);
00170 emEneLeadJetEta2 = fs->make<TH1F>("emEneLeadJetEta2","EM Energy Lead Jet Eta2 1",100,0,100);
00171 emEneLeadJetEta3 = fs->make<TH1F>("emEneLeadJetEta3","EM Energy Lead Jet Eta3 1",100,0,100);
00172
00173
00174 hadFracEta1 = fs->make<TH1F>("hadFracEta11","Hadronic Fraction Eta1 Jet 1",100,0,1);
00175 hadFracEta2 = fs->make<TH1F>("hadFracEta21","Hadronic Fraction Eta2 Jet 1",100,0,1);
00176 hadFracEta3 = fs->make<TH1F>("hadFracEta31","Hadronic Fraction Eta3 Jet 1",100,0,1);
00177
00178 HFSumEt = fs->make<TH1F>("HFSumEt","HFSumEt",100,0,100);
00179 HFMET = fs->make<TH1F>("HFMET", "HFMET",120,0,120);
00180
00181 SumEt = fs->make<TH1F>("SumEt","SumEt",100,0,100);
00182 MET = fs->make<TH1F>("MET", "MET",120,0,120);
00183 OERMET = fs->make<TH1F>("OERMET", "OERMET",120,0,120);
00184 METSig = fs->make<TH1F>("METSig", "METSig",100,0,50);
00185 MEx = fs->make<TH1F>("MEx", "MEx",100,-20,20);
00186 MEy = fs->make<TH1F>("MEy", "MEy",100,-20,20);
00187 METPhi = fs->make<TH1F>("METPhi", "METPhi",315,0,3.15);
00188 MET_RBX = fs->make<TH1F>("MET_RBX", "MET",100,0,1000);
00189 MET_HPD = fs->make<TH1F>("MET_HPD", "MET",100,0,1000);
00190 MET_Tower = fs->make<TH1F>("MET_Tower", "MET",100,0,1000);
00191
00192 SiClusters = fs->make<TH1F>("SiClusters", "SiClusters",150,0,1500);
00193
00194 h_Vx = fs->make<TH1F>("Vx", "Vx",100,-0.5,0.5);
00195 h_Vy = fs->make<TH1F>("Vy", "Vy",100,-0.5,0.5);
00196 h_Vz = fs->make<TH1F>("Vz", "Vz",100,-20,20);
00197 h_VNTrks = fs->make<TH1F>("VNTrks", "VNTrks",10,1,100);
00198
00199 h_Trk_pt = fs->make<TH1F>("Trk_pt", "Trk_pt",100,0,20);
00200 h_Trk_NTrk = fs->make<TH1F>("Trk_NTrk", "Trk_NTrk",150,0,150);
00201
00202 hf_sumTowerAllEx = fs->make<TH1F>("sumTowerAllEx","Tower Ex",100,-1000,1000);
00203 hf_sumTowerAllEy = fs->make<TH1F>("sumTowerAllEy","Tower Ey",100,-1000,1000);
00204
00205 hf_TowerJetEt = fs->make<TH1F>("TowerJetEt","Tower/Jet Et 1",50,0,1);
00206
00207 ETime = fs->make<TH1F>("ETime","Ecal Time",200,-200,200);
00208 HTime = fs->make<TH1F>("HTime","Hcal Time",200,-200,200);
00209
00210 towerHadEnHB = fs->make<TH1F>("towerHadEnHB" ,"HB: Calo Tower HAD Energy",210,-1,20);
00211 towerHadEnHE = fs->make<TH1F>("towerHadEnHE" ,"HE: Calo Tower HAD Energy",510,-1,50);
00212 towerHadEnHF = fs->make<TH1F>("towerHadEnHF" ,"HF: Calo Tower HAD Energy",510,-1,50);
00213
00214 towerEmEnHB = fs->make<TH1F>("towerEmEnHB" ,"HB: Calo Tower EM Energy",210,-1,20);
00215 towerEmEnHE = fs->make<TH1F>("towerEmEnHE" ,"HE: Calo Tower EM Energy",510,-1,50);
00216 towerEmEnHF = fs->make<TH1F>("towerEmEnHF" ,"HF: Calo Tower EM Energy",510,-1,50);
00217
00218 towerHadEn = fs->make<TH1F>("towerHadEn" ,"Hadronic Energy in Calo Tower",2000,-100,100);
00219 towerEmEn = fs->make<TH1F>("towerEmEn" ,"EM Energy in Calo Tower",2000,-100,100);
00220 towerOuterEn = fs->make<TH1F>("towerOuterEn" ,"HO Energy in Calo Tower",2000,-100,100);
00221
00222 towerEmFrac = fs->make<TH1F>("towerEmFrac","EM Fraction of Energy in Calo Tower",100,-1.,1.);
00223
00224 RBX_et = fs->make<TH1F>("RBX_et","ET in RBX",1000,-20,100);
00225 RBX_hadEnergy = fs->make<TH1F>("RBX_hadEnergy","Hcal Energy in RBX",1000,-20,100);
00226 RBX_hcalTime = fs->make<TH1F>("RBX_hcalTime","Hcal Time in RBX",200,-200,200);
00227 RBX_nTowers = fs->make<TH1F>("RBX_nTowers","Number of Towers in RBX",75,0,75);
00228 RBX_N = fs->make<TH1F>("RBX_N","Number of RBX",10,0,10);
00229
00230 HPD_et = fs->make<TH1F>("HPD_et","ET in HPD",1000,-20,100);
00231 HPD_hadEnergy = fs->make<TH1F>("HPD_hadEnergy","Hcal Energy in HPD",1000,-20,100);
00232 HPD_hcalTime = fs->make<TH1F>("HPD_hcalTime","Hcal Time in HPD",200,-200,200);
00233 HPD_nTowers = fs->make<TH1F>("HPD_nTowers","Number of Towers in HPD",20,0,20);
00234 HPD_N = fs->make<TH1F>("HPD_N","Number of HPD",10,0,10);
00235
00236 nTowers1 = fs->make<TH1F>("nTowers1","Number of Towers pt 0.5",100,0,200);
00237 nTowers2 = fs->make<TH1F>("nTowers2","Number of Towers pt 1.0",100,0,200);
00238 nTowers3 = fs->make<TH1F>("nTowers3","Number of Towers pt 1.5",100,0,200);
00239 nTowers4 = fs->make<TH1F>("nTowers4","Number of Towers pt 2.0",100,0,200);
00240
00241 nTowersLeadJetPt1 = fs->make<TH1F>("nTowersLeadJetPt1","Number of Towers in Lead Jet pt 0.5",100,0,100);
00242 nTowersLeadJetPt2 = fs->make<TH1F>("nTowersLeadJetPt2","Number of Towers in Lead Jet pt 1.0",100,0,100);
00243 nTowersLeadJetPt3 = fs->make<TH1F>("nTowersLeadJetPt3","Number of Towers in Lead Jet pt 1.5",100,0,100);
00244 nTowersLeadJetPt4 = fs->make<TH1F>("nTowersLeadJetPt4","Number of Towers in Lead Jet pt 2.0",100,0,100);
00245
00246 h_nCalJets = fs->make<TH1F>( "nCalJets", "Number of CalJets", 20, 0, 20 );
00247
00248 HBEneOOT = fs->make<TH1F>( "HBEneOOT", "HBEneOOT", 200, -5, 10 );
00249 HEEneOOT = fs->make<TH1F>( "HEEneOOT", "HEEneOOT", 200, -5, 10 );
00250 HFEneOOT = fs->make<TH1F>( "HFEneOOT", "HFEneOOT", 200, -5, 10 );
00251 HOEneOOT = fs->make<TH1F>( "HOEneOOT", "HOEneOOT", 200, -5, 10 );
00252
00253 HBEneOOTTh = fs->make<TH1F>( "HBEneOOTTh", "HBEneOOTTh", 200, -5, 10 );
00254 HEEneOOTTh = fs->make<TH1F>( "HEEneOOTTh", "HEEneOOTTh", 200, -5, 10 );
00255 HFEneOOTTh = fs->make<TH1F>( "HFEneOOTTh", "HFEneOOTTh", 200, -5, 10 );
00256 HOEneOOTTh = fs->make<TH1F>( "HOEneOOTTh", "HOEneOOTTh", 200, -5, 10 );
00257
00258 HBEneOOTTh1 = fs->make<TH1F>( "HBEneOOTTh1", "HBEneOOT", 200, -5, 10 );
00259 HEEneOOTTh1 = fs->make<TH1F>( "HEEneOOTTh1", "HEEneOOT", 200, -5, 10 );
00260 HFEneOOTTh1 = fs->make<TH1F>( "HFEneOOTTh1", "HFEneOOT", 200, -5, 10 );
00261 HOEneOOTTh1 = fs->make<TH1F>( "HOEneOOTTh1", "HOEneOOT", 200, -5, 10 );
00262
00263 HBEneTThr = fs->make<TH1F>( "HBEneTThr", "HBEneTThr", 105, -5, 100 );
00264 HEEneTThr = fs->make<TH1F>( "HEEneTThr", "HEEneTThr", 105, -5, 100 );
00265 HFEneTThr = fs->make<TH1F>( "HFEneTThr", "HFEneTThr", 105, -5, 100 );
00266
00267
00268 HBEne = fs->make<TH1F>( "HBEne", "HBEne", 205, -5, 200 );
00269 HBEneTh = fs->make<TH1F>( "HBEneTh", "HBEneTh", 205, -5, 200 );
00270 HBEneTh1 = fs->make<TH1F>( "HBEneTh1", "HBEneTh1", 205, -5, 200 );
00271 HBEneX = fs->make<TH1F>( "HBEneX", "HBEneX", 200, -5, 10 );
00272 HBEneY = fs->make<TH1F>( "HBEneY", "HBEnedY", 200, -5, 10 );
00273 HBTime = fs->make<TH1F>( "HBTime", "HBTime", 200, -100, 100 );
00274 HBTimeTh = fs->make<TH1F>( "HBTimeTh", "HBTimeTh", 200, -100, 100 );
00275 HBTimeTh1 = fs->make<TH1F>( "HBTimeTh1", "HBTimeTh1", 200, -100, 100 );
00276 HBTimeTh2 = fs->make<TH1F>( "HBTimeTh2", "HBTimeTh2", 200, -100, 100 );
00277 HBTimeTh3 = fs->make<TH1F>( "HBTimeTh3", "HBTimeTh3", 200, -100, 100 );
00278 HBTimeThR = fs->make<TH1F>( "HBTimeThR", "HBTimeThR", 200, -100, 100 );
00279 HBTimeTh1R = fs->make<TH1F>( "HBTimeTh1R", "HBTimeTh1R", 200, -100, 100 );
00280 HBTimeTh2R = fs->make<TH1F>( "HBTimeTh2R", "HBTimeTh2R", 200, -100, 100 );
00281 HBTimeTh3R = fs->make<TH1F>( "HBTimeTh3R", "HBTimeTh3R", 200, -100, 100 );
00282
00283 HBTimeFlagged = fs->make<TH1F>( "HBTimeFlagged", "HBTimeFlagged", 200, -100, 100 );
00284 HBTimeThFlagged = fs->make<TH1F>( "HBTimeThFlagged", "HBTimeThFlagged", 200, -100, 100 );
00285 HBTimeTh1Flagged = fs->make<TH1F>( "HBTimeTh1Flagged", "HBTimeTh1Flagged", 200, -100, 100 );
00286 HBTimeTh2Flagged = fs->make<TH1F>( "HBTimeTh2Flagged", "HBTimeTh2Flagged", 200, -100, 100 );
00287
00288 HBTimeFlagged2 = fs->make<TH1F>( "HBTimeFlagged2", "HBTimeFlagged2", 200, -100, 100 );
00289 HBTimeThFlagged2 = fs->make<TH1F>( "HBTimeThFlagged2", "HBTimeThFlagged2", 200, -100, 100 );
00290 HBTimeTh1Flagged2 = fs->make<TH1F>( "HBTimeTh1Flagged2", "HBTimeTh1Flagged2", 200, -100, 100 );
00291 HBTimeTh2Flagged2 = fs->make<TH1F>( "HBTimeTh2Flagged2", "HBTimeTh2Flagged2", 200, -100, 100 );
00292
00293 HBTimeX = fs->make<TH1F>( "HBTimeX", "HBTimeX", 200, -100, 100 );
00294 HBTimeY = fs->make<TH1F>( "HBTimeY", "HBTimeY", 200, -100, 100 );
00295 HEEne = fs->make<TH1F>( "HEEne", "HEEne", 205, -5, 200 );
00296 HEEneTh = fs->make<TH1F>( "HEEneTh", "HEEneTh", 205, -5, 200 );
00297 HEEneTh1 = fs->make<TH1F>( "HEEneTh1", "HEEneTh1", 205, -5, 200 );
00298 HEEneX = fs->make<TH1F>( "HEEneX", "HEEneX", 200, -5, 10 );
00299 HEEneY = fs->make<TH1F>( "HEEneY", "HEEneY", 200, -5, 10 );
00300 HEposEne = fs->make<TH1F>( "HEposEne", "HEposEne", 200, -5, 10 );
00301 HEnegEne = fs->make<TH1F>( "HEnegEne", "HEnegEne", 200, -5, 10 );
00302 HETime = fs->make<TH1F>( "HETime", "HETime", 200, -100, 100 );
00303 HETimeTh = fs->make<TH1F>( "HETimeTh", "HETimeTh", 200, -100, 100 );
00304 HETimeTh1 = fs->make<TH1F>( "HETimeTh1", "HETimeTh1", 200, -100, 100 );
00305 HETimeTh2 = fs->make<TH1F>( "HETimeTh2", "HETimeTh2", 200, -100, 100 );
00306 HETimeTh3 = fs->make<TH1F>( "HETimeTh3", "HETimeTh3", 200, -100, 100 );
00307 HETimeThR = fs->make<TH1F>( "HETimeThR", "HETimeThR", 200, -100, 100 );
00308 HETimeTh1R = fs->make<TH1F>( "HETimeTh1R", "HETimeTh1R", 200, -100, 100 );
00309 HETimeTh2R = fs->make<TH1F>( "HETimeTh2R", "HETimeTh2R", 200, -100, 100 );
00310 HETimeTh3R = fs->make<TH1F>( "HETimeTh3R", "HETimeTh3R", 200, -100, 100 );
00311
00312 HETimeFlagged = fs->make<TH1F>( "HETimeFlagged", "HETimeFlagged", 200, -100, 100 );
00313 HETimeThFlagged = fs->make<TH1F>( "HETimeThFlagged", "HETimeThFlagged", 200, -100, 100 );
00314 HETimeTh1Flagged = fs->make<TH1F>( "HETimeTh1Flagged", "HETimeTh1Flagged", 200, -100, 100 );
00315 HETimeTh2Flagged = fs->make<TH1F>( "HETimeTh2Flagged", "HETimeTh2Flagged", 200, -100, 100 );
00316
00317 HETimeFlagged2 = fs->make<TH1F>( "HETimeFlagged2", "HETimeFlagged2", 200, -100, 100 );
00318 HETimeThFlagged2 = fs->make<TH1F>( "HETimeThFlagged2", "HETimeThFlagged2", 200, -100, 100 );
00319 HETimeTh1Flagged2 = fs->make<TH1F>( "HETimeTh1Flagged2", "HETimeTh1Flagged2", 200, -100, 100 );
00320 HETimeTh2Flagged2 = fs->make<TH1F>( "HETimeTh2Flagged2", "HETimeTh2Flagged2", 200, -100, 100 );
00321
00322 HETimeX = fs->make<TH1F>( "HETimeX", "HETimeX", 200, -100, 100 );
00323 HETimeY = fs->make<TH1F>( "HETimeY", "HETimeY", 200, -100, 100 );
00324 HEposTime = fs->make<TH1F>( "HEposTime", "HEposTime", 200, -100, 100 );
00325 HEnegTime = fs->make<TH1F>( "HEnegTime", "HEnegTime", 200, -100, 100 );
00326 HOEne = fs->make<TH1F>( "HOEne", "HOEne", 200, -5, 10 );
00327 HOEneTh = fs->make<TH1F>( "HOEneTh", "HOEneTh", 200, -5, 10 );
00328 HOEneTh1 = fs->make<TH1F>( "HOEneTh1", "HOEneTh1", 200, -5, 10 );
00329 HOTime = fs->make<TH1F>( "HOTime", "HOTime", 200, -100, 100 );
00330 HOTimeTh = fs->make<TH1F>( "HOTimeTh", "HOTimeTh", 200, -100, 100 );
00331
00332
00333 HOSEne = fs->make<TH1F>( "HOSEne", "HOSEne", 12000, -20, 100 );
00334 HOSTime = fs->make<TH1F>( "HOSTime", "HOSTime", 200, -100, 100 );
00335 HOHEne = fs->make<TH1F>( "HOHEne", "HOHEne", 12000, -20, 100 );
00336 HOHTime = fs->make<TH1F>( "HOHTime", "HOHTime", 200, -100, 100 );
00337
00338 HOHr0Ene = fs->make<TH1F>( "HOHr0Ene" , "HOHr0Ene", 12000, -20 , 100 );
00339 HOHr0Time = fs->make<TH1F>( "HOHr0Time" , "HOHr0Time", 200, -200, 200 );
00340 HOHrm1Ene = fs->make<TH1F>( "HOHrm1Ene" , "HOHrm1Ene", 12000, -20 , 100 );
00341 HOHrm1Time = fs->make<TH1F>( "HOHrm1Time", "HOHrm1Time", 200, -200, 200 );
00342 HOHrm2Ene = fs->make<TH1F>( "HOHrm2Ene" , "HOHrm2Ene", 12000, -20 , 100 );
00343 HOHrm2Time = fs->make<TH1F>( "HOHrm2Time", "HOHrm2Time", 200, -200, 200 );
00344 HOHrp1Ene = fs->make<TH1F>( "HOHrp1Ene" , "HOHrp1Ene", 12000, -20 , 100 );
00345 HOHrp1Time = fs->make<TH1F>( "HOHrp1Time", "HOHrp1Time", 200, -200, 200 );
00346 HOHrp2Ene = fs->make<TH1F>( "HOHrp2Ene" , "HOHrp2Ene", 12000, -20 , 100 );
00347 HOHrp2Time = fs->make<TH1F>( "HOHrp2Time", "HOHrp2Time", 200, -200, 200 );
00348
00349 HBTvsE = fs->make<TH2F>( "HBTvsE", "HBTvsE",305, -5, 300, 100, -100, 100);
00350 HETvsE = fs->make<TH2F>( "HETvsE", "HETvsE",305, -5, 300, 100, -100, 100);
00351
00352 HFTvsE = fs->make<TH2F>( "HFTvsE", "HFTvsE",305, -5, 300, 100, -100, 100);
00353 HFTvsEFlagged = fs->make<TH2F>( "HFTvsEFlagged", "HFTvsEFlagged",305, -5, 300, 100, -100, 100);
00354 HFTvsEFlagged2 = fs->make<TH2F>( "HFTvsEFlagged2", "HFTvsEFlagged2",305, -5, 300, 100, -100, 100);
00355
00356 HFTvsEThr = fs->make<TH2F>( "HFTvsEThr", "HFTvsEThr",305, -5, 300, 100, -100, 100);
00357 HFTvsEFlaggedThr = fs->make<TH2F>( "HFTvsEFlaggedThr", "HFTvsEFlaggedThr",305, -5, 300, 100, -100, 100);
00358 HFTvsEFlagged2Thr = fs->make<TH2F>( "HFTvsEFlagged2Thr", "HFTvsEFlagged2Thr",305, -5, 300, 100, -100, 100);
00359
00360 HOTvsE = fs->make<TH2F>( "HOTvsE", "HOTvsE",305, -5, 300, 100, -100, 100);
00361
00362 HFvsZ = fs->make<TH2F>( "HFvsZ", "HFvsZ",100,-50,50,100,-50,50);
00363
00364
00365
00366 HOocc = fs->make<TH2F>( "HOocc", "HOocc",85,-42.5,42.5,70,0.5,70.5);
00367 HBocc = fs->make<TH2F>( "HBocc", "HBocc",85,-42.5,42.5,70,0.5,70.5);
00368 HEocc = fs->make<TH2F>( "HEocc", "HEocc",85,-42.5,42.5,70,0.5,70.5);
00369 HFocc = fs->make<TH2F>( "HFocc", "HFocc",85,-42.5,42.5,70,0.5,70.5);
00370 HFoccTime = fs->make<TH2F>( "HFoccTime", "HFoccTime",85,-42.5,42.5,70,0.5,70.5);
00371 HFoccFlagged = fs->make<TH2F>( "HFoccFlagged", "HFoccFlagged",85,-42.5,42.5,70,0.5,70.5);
00372 HFoccFlagged2 = fs->make<TH2F>( "HFoccFlagged2", "HFoccFlagged2",85,-42.5,42.5,70,0.5,70.5);
00373
00374 HFEtaPhiNFlagged = fs->make<TH2F>( "HFEtaPhiNFlagged", "HFEtaPhiNFlagged",85,-42.5,42.5,70,0.5,70.5);
00375
00376
00377 HFEtaFlagged = fs->make<TH1F>( "HFEtaFlagged", "HFEtaFlagged",85,-42.5,42.5);
00378 HFEtaFlaggedL = fs->make<TH1F>( "HFEtaFlaggedL", "HFEtaFlaggedL",85,-42.5,42.5);
00379 HFEtaFlaggedLN = fs->make<TH1F>( "HFEtaFlaggedLN", "HFEtaFlaggedLN",85,-42.5,42.5);
00380 HFEtaFlaggedS = fs->make<TH1F>( "HFEtaFlaggedS", "HFEtaFlaggedS",85,-42.5,42.5);
00381 HFEtaFlaggedSN = fs->make<TH1F>( "HFEtaFlaggedSN", "HFEtaFlaggedSN",85,-42.5,42.5);
00382
00383 HFEtaNFlagged = fs->make<TProfile>( "HFEtaNFlagged", "HFEtaNFlagged",85,-42.5,42.5,0, 10000);
00384
00385 HOoccOOT = fs->make<TH2F>( "HOoccOOT", "HOoccOOT",85,-42.5,42.5,70,0.5,70.5);
00386 HBoccOOT = fs->make<TH2F>( "HBoccOOT", "HBoccOOT",85,-42.5,42.5,70,0.5,70.5);
00387 HEoccOOT = fs->make<TH2F>( "HEoccOOT", "HEoccOOT",85,-42.5,42.5,70,0.5,70.5);
00388 HFoccOOT = fs->make<TH2F>( "HFoccOOT", "HFoccOOT",85,-42.5,42.5,70,0.5,70.5);
00389
00390 HFEnePMT0 = fs->make<TH1F>( "HFEnePMT0", "HFEnePMT0", 210, -10, 200 );
00391 HFEnePMT1 = fs->make<TH1F>( "HFEnePMT1", "HFEnePMT1", 210, -10, 200 );
00392 HFEnePMT2 = fs->make<TH1F>( "HFEnePMT2", "HFEnePMT2", 210, -10, 200 );
00393 HFTimePMT0 = fs->make<TH1F>( "HFTimePMT0", "HFTimePMT0", 200, -100, 100 );
00394 HFTimePMT1 = fs->make<TH1F>( "HFTimePMT1", "HFTimePMT1", 200, -100, 100 );
00395 HFTimePMT2 = fs->make<TH1F>( "HFTimePMT2", "HFTimePMT2", 200, -100, 100 );
00396
00397 HFEne = fs->make<TH1F>( "HFEne", "HFEne", 210, -10, 200 );
00398 HFEneFlagged = fs->make<TH1F>( "HFEneFlagged", "HFEneFlagged", 210, -10, 200 );
00399 HFEneFlagged2 = fs->make<TH1F>( "HFEneFlagged2", "HFEneFlagged2", 210, -10, 200 );
00400 HFEneTh = fs->make<TH1F>( "HFEneTh", "HFEneTh", 210, -10, 200 );
00401 HFEneTh1 = fs->make<TH1F>( "HFEneTh1", "HFEneTh1", 210, -10, 200 );
00402 HFEneP = fs->make<TH1F>( "HFEneP", "HFEneP", 200, -5, 10 );
00403 HFEneM = fs->make<TH1F>( "HFEneM", "HFEneM", 200, -5, 10 );
00404 HFTime = fs->make<TH1F>( "HFTime", "HFTime", 200, -100, 100 );
00405 PMTHits = fs->make<TH1F>( "PMTHits", "PMTHits", 10, 0, 10 );
00406 HFTimeFlagged = fs->make<TH1F>( "HFTimeFlagged", "HFTimeFlagged", 200, -100, 100 );
00407
00408 HFTimeFlagged2 = fs->make<TH1F>( "HFTimeFlagged2", "HFTimeFlagged2", 200, -100, 100 );
00409 HFTimeThFlagged2 = fs->make<TH1F>( "HFTimeThFlagged2", "HFTimeThFlagged2", 200, -100, 100 );
00410 HFTimeTh1Flagged2 = fs->make<TH1F>( "HFTimeTh1Flagged2", "HFTimeTh1Flagged2", 200, -100, 100 );
00411 HFTimeTh2Flagged2 = fs->make<TH1F>( "HFTimeTh2Flagged2", "HFTimeTh2Flagged2", 200, -100, 100 );
00412 HFTimeTh3Flagged2 = fs->make<TH1F>( "HFTimeTh3Flagged2", "HFTimeTh3Flagged2", 200, -100, 100 );
00413
00414 HFTimeFlagged3 = fs->make<TH1F>( "HFTimeFlagged3", "HFTimeFlagged3", 200, -100, 100 );
00415 HFTimeThFlagged3 = fs->make<TH1F>( "HFTimeThFlagged3", "HFTimeThFlagged3", 200, -100, 100 );
00416 HFTimeTh1Flagged3 = fs->make<TH1F>( "HFTimeTh1Flagged3", "HFTimeTh1Flagged3", 200, -100, 100 );
00417 HFTimeTh2Flagged3 = fs->make<TH1F>( "HFTimeTh2Flagged3", "HFTimeTh2Flagged3", 200, -100, 100 );
00418 HFTimeTh3Flagged3 = fs->make<TH1F>( "HFTimeTh3Flagged3", "HFTimeTh3Flagged3", 200, -100, 100 );
00419
00420 HFTimeThFlagged = fs->make<TH1F>( "HFTimeThFlagged", "HFTimeThFlagged", 200, -100, 100 );
00421 HFTimeTh2Flagged = fs->make<TH1F>( "HFTimeTh2Flagged", "HFTimeTh2Flagged", 200, -100, 100 );
00422 HFTimeTh3Flagged = fs->make<TH1F>( "HFTimeTh3Flagged", "HFTimeTh3Flagged", 200, -100, 100 );
00423
00424 HFTimeThFlaggedR = fs->make<TH1F>( "HFTimeThFlaggedR", "HFTimeThFlaggedR", 200, -100, 100 );
00425 HFTimeThFlaggedR1 = fs->make<TH1F>( "HFTimeThFlaggedR1", "HFTimeThFlaggedR1", 200, -100, 100 );
00426 HFTimeThFlaggedR2 = fs->make<TH1F>( "HFTimeThFlaggedR2", "HFTimeThFlaggedR2", 200, -100, 100 );
00427 HFTimeThFlaggedR3 = fs->make<TH1F>( "HFTimeThFlaggedR3", "HFTimeThFlaggedR3", 200, -100, 100 );
00428 HFTimeThFlaggedR4 = fs->make<TH1F>( "HFTimeThFlaggedR4", "HFTimeThFlaggedR4", 200, -100, 100 );
00429 HFTimeThFlaggedRM = fs->make<TH1F>( "HFTimeThFlaggedRM", "HFTimeThFlaggedRM", 200, -100, 100 );
00430 TrkMultFlagged0 = fs->make<TH1F>( "TrkMultFlagged0", "TrkMultFlagged0", 100, 0, 100 );
00431 TrkMultFlagged1 = fs->make<TH1F>( "TrkMultFlagged1", "TrkMultFlagged1", 100, 0, 100 );
00432 TrkMultFlagged2 = fs->make<TH1F>( "TrkMultFlagged2", "TrkMultFlagged2", 100, 0, 100 );
00433 TrkMultFlagged3 = fs->make<TH1F>( "TrkMultFlagged3", "TrkMultFlagged3", 100, 0, 100 );
00434 TrkMultFlagged4 = fs->make<TH1F>( "TrkMultFlagged4", "TrkMultFlagged4", 100, 0, 100 );
00435 TrkMultFlaggedM = fs->make<TH1F>( "TrkMultFlaggedM", "TrkMultFlaggedM", 100, 0, 100 );
00436 HFTimeTh = fs->make<TH1F>( "HFTimeTh", "HFTimeTh", 200, -100, 100 );
00437 HFTimeTh1 = fs->make<TH1F>( "HFTimeTh1", "HFTimeTh1", 200, -100, 100 );
00438 HFTimeTh2 = fs->make<TH1F>( "HFTimeTh2", "HFTimeTh2", 200, -100, 100 );
00439 HFTimeTh3 = fs->make<TH1F>( "HFTimeTh3", "HFTimeTh3", 200, -100, 100 );
00440 HFTimeThR = fs->make<TH1F>( "HFTimeThR", "HFTimeThR", 200, -100, 100 );
00441 HFTimeTh1R = fs->make<TH1F>( "HFTimeTh1R", "HFTimeTh1R", 200, -100, 100 );
00442 HFTimeTh2R = fs->make<TH1F>( "HFTimeTh2R", "HFTimeTh2R", 200, -100, 100 );
00443 HFTimeTh3R = fs->make<TH1F>( "HFTimeTh3R", "HFTimeTh3R", 200, -100, 100 );
00444 HFTimeP = fs->make<TH1F>( "HFTimeP", "HFTimeP", 100, -100, 50 );
00445 HFTimeM = fs->make<TH1F>( "HFTimeM", "HFTimeM", 100, -100, 50 );
00446 HFTimePMa = fs->make<TH1F>( "HFTimePMa", "HFTimePMa", 100, -100, 100 );
00447 HFTimePM = fs->make<TH1F>( "HFTimePM", "HFTimePM", 100, -100, 100 );
00448
00449
00450 HFLEneAll = fs->make<TH1F>( "HFLEneAll", "HFLEneAll", 210, -10, 200 );
00451 HFLEneAllF = fs->make<TH1F>( "HFLEneAllF", "HFLEneAllF", 210, -10, 200 );
00452 HFSEneAll = fs->make<TH1F>( "HFSEneAll", "HFSEneAll", 210, -10, 200 );
00453 HFSEneAllF = fs->make<TH1F>( "HFSEneAllF", "HFSEneAllF", 210, -10, 200 );
00454 HFLEne = fs->make<TH1F>( "HFLEne", "HFLEne", 200, -5, 10 );
00455 HFLTime = fs->make<TH1F>( "HFLTime", "HFLTime", 200, -100, 100 );
00456 HFSEne = fs->make<TH1F>( "HFSEne", "HFSEne", 200, -5, 10 );
00457 HFSTime = fs->make<TH1F>( "HFSTime", "HFSTime", 200, -100, 100 );
00458 HFLSRatio = fs->make<TH1F>( "HFLSRatio", "HFLSRatio", 220, -1.1, 1.1 );
00459
00460 HFOERatio = fs->make<TH1F>( "HFOERatio", "HFOERatio", 2200, -1.1, 1.1 );
00461
00462 HFLvsS = fs->make<TH2F>( "HFLvsS", "HFLvsS",220,-20,200,220,-20,200);
00463 HFLEneNoS = fs->make<TH1F>( "HFLEneNoS", "HFLEneNoS", 205, -5, 200 );
00464 HFSEneNoL = fs->make<TH1F>( "HFSEneNoL", "HFSEneNoL", 205, -5, 200 );
00465 HFLEneNoSFlagged = fs->make<TH1F>( "HFLEneNoSFlagged", "HFLEneNoSFlagged", 205, -5, 200 );
00466 HFSEneNoLFlagged = fs->make<TH1F>( "HFSEneNoLFlagged", "HFSEneNoLFlagged", 205, -5, 200 );
00467 HFLEneNoSFlaggedN = fs->make<TH1F>( "HFLEneNoSFlaggedN", "HFLEneNoSFlaggedN", 205, -5, 200 );
00468 HFSEneNoLFlaggedN = fs->make<TH1F>( "HFSEneNoLFlaggedN", "HFSEneNoLFlaggedN", 205, -5, 200 );
00469
00470
00471 EBEne = fs->make<TH1F>( "EBEne", "EBEne", 200, -5, 10 );
00472 EBEneTh = fs->make<TH1F>( "EBEneTh", "EBEneTh", 200, -5, 10 );
00473 EBEneX = fs->make<TH1F>( "EBEneX", "EBEneX", 200, -5, 10 );
00474 EBEneY = fs->make<TH1F>( "EBEneY", "EBEneY", 200, -5, 10 );
00475 EBTime = fs->make<TH1F>( "EBTime", "EBTime", 200, -100, 100 );
00476 EBTimeTh = fs->make<TH1F>( "EBTimeTh", "EBTimeTh", 200, -100, 100 );
00477 EBTimeX = fs->make<TH1F>( "EBTimeX", "EBTimeX", 200, -100, 100 );
00478 EBTimeY = fs->make<TH1F>( "EBTimeY", "EBTimeY", 200, -100, 100 );
00479 EEEne = fs->make<TH1F>( "EEEne", "EEEne", 200, -5, 10 );
00480 EEEneTh = fs->make<TH1F>( "EEEneTh", "EEEneTh", 200, -5, 10 );
00481 EEEneX = fs->make<TH1F>( "EEEneX", "EEEneX", 200, -5, 10 );
00482 EEEneY = fs->make<TH1F>( "EEEneY", "EEEneY", 200, -5, 10 );
00483 EEnegEne = fs->make<TH1F>( "EEnegEne", "EEnegEne", 200, -5, 10 );
00484 EEposEne = fs->make<TH1F>( "EEposEne", "EEposEne", 200, -5, 10 );
00485 EETime = fs->make<TH1F>( "EETime", "EETime", 200, -100, 100 );
00486 EETimeTh = fs->make<TH1F>( "EETimeTh", "EETimeTh", 200, -100, 100 );
00487 EETimeX = fs->make<TH1F>( "EETimeX", "EETimeX", 200, -100, 100 );
00488 EETimeY = fs->make<TH1F>( "EETimeY", "EETimeY", 200, -100, 100 );
00489 EEnegTime = fs->make<TH1F>( "EEnegTime", "EEnegTime", 200, -100, 100 );
00490 EEposTime = fs->make<TH1F>( "EEposTime", "EEposTime", 200, -100, 100 );
00491
00492 h_nTowersCal = fs->make<TH1F>( "nTowersCal", "N Towers in Jet", 100, 0, 50 );
00493 h_EMFracCal = fs->make<TH1F>( "EMFracCal", "EM Fraction in Jet", 100, -1.1, 1.1 );
00494 h_ptCal = fs->make<TH1F>( "ptCal", "p_{T} of CalJet", 100, 0, 50 );
00495 h_etaCal = fs->make<TH1F>( "etaCal", "#eta of CalJet", 100, -4, 4 );
00496 h_phiCal = fs->make<TH1F>( "phiCal", "#phi of CalJet", 50, -M_PI, M_PI );
00497
00498 h_nGenJets = fs->make<TH1F>( "nGenJets", "Number of GenJets", 20, 0, 20 );
00499
00500 h_ptGen = fs->make<TH1F>( "ptGen", "p_{T} of GenJet", 100, 0, 50 );
00501 h_etaGen = fs->make<TH1F>( "etaGen", "#eta of GenJet", 100, -4, 4 );
00502 h_phiGen = fs->make<TH1F>( "phiGen", "#phi of GenJet", 50, -M_PI, M_PI );
00503
00504 h_ptGenL = fs->make<TH1F>( "ptGenL", "p_{T} of GenJetL", 100, 0, 50 );
00505 h_etaGenL = fs->make<TH1F>( "etaGenL", "#eta of GenJetL", 100, -4, 4 );
00506 h_phiGenL = fs->make<TH1F>( "phiGenL", "#phi of GenJetL", 50, -M_PI, M_PI );
00507
00508 h_jetEt = fs->make<TH1F>( "jetEt", "Total Jet Et", 100, 0, 3000 );
00509
00510 h_jet1Pt = fs->make<TH1F>( "jet1Pt", "Jet1 Pt", 100, 0, 1000 );
00511 h_jet2Pt = fs->make<TH1F>( "jet2Pt", "Jet2 Pt", 100, 0, 1000 );
00512 h_jet1Eta = fs->make<TH1F>( "jet1Eta", "Jet1 Eta", 50, -5, 5 );
00513 h_jet2Eta = fs->make<TH1F>( "jet2Eta", "Jet2 Eta", 50, -5, 5 );
00514 h_jet1PtHLT = fs->make<TH1F>( "jet1PtHLT", "Jet1 Pt HLT", 100, 0, 1000 );
00515
00516 h_TotalUnclusteredEt = fs->make<TH1F>( "TotalUnclusteredEt", "Total Unclustered Et", 100, 0, 500 );
00517 h_UnclusteredEt = fs->make<TH1F>( "UnclusteredEt", "Unclustered Et", 100, 0, 50 );
00518 h_UnclusteredEts = fs->make<TH1F>( "UnclusteredEts", "Unclustered Et", 100, 0, 2 );
00519
00520 h_ClusteredE = fs->make<TH1F>( "ClusteredE", "Clustered E", 200, 0, 20 );
00521 h_TotalClusteredE = fs->make<TH1F>( "TotalClusteredE", "Total Clustered E", 200, 0, 100 );
00522 h_UnclusteredE = fs->make<TH1F>( "UnclusteredE", "Unclustered E", 200, 0, 20 );
00523 h_TotalUnclusteredE = fs->make<TH1F>( "TotalUnclusteredE", "Total Unclustered E", 200, 0, 100 );
00524
00525 jetHOEne = fs->make<TH1F>("jetHOEne" ,"HO Energy in Jet",100, 0,100);
00526 jetEMFraction = fs->make<TH1F>( "jetEMFraction", "Jet EM Fraction", 100, -1.1, 1.1 );
00527 NTowers = fs->make<TH1F>( "NTowers", "Number of Towers", 100, 0, 100 );
00528
00529
00530 h_EmEnergy = fs->make<TH2F>( "EmEnergy", "Em Energy", 90, -45, 45, 73, 0, 73 );
00531 h_HadEnergy = fs->make<TH2F>( "HadEnergy", "Had Energy", 90, -45, 45, 73, 0, 73 );
00532
00533 st_Pt = fs->make<TH1F>( "st_Pt", "Pt", 200, 0, 200 );
00534 st_Constituents = fs->make<TH1F>( "st_Constituents", "Constituents", 200, 0, 200 );
00535 st_Energy = fs->make<TH1F>( "st_Energy", "Tower Energy", 200, 0, 200 );
00536 st_EmEnergy = fs->make<TH1F>( "st_EmEnergy", "Tower EmEnergy", 200, 0, 200 );
00537 st_HadEnergy = fs->make<TH1F>( "st_HadEnergy", "Tower HadEnergy", 200, 0, 200 );
00538 st_OuterEnergy = fs->make<TH1F>( "st_OuterEnergy", "Tower OuterEnergy", 200, 0, 200 );
00539 st_Eta = fs->make<TH1F>( "st_Eta", "Eta", 100, -4, 4 );
00540 st_Phi = fs->make<TH1F>( "st_Phi", "Phi", 50, -M_PI, M_PI );
00541 st_iEta = fs->make<TH1F>( "st_iEta", "iEta", 60, -30, 30 );
00542 st_iPhi = fs->make<TH1F>( "st_iPhi", "iPhi", 80, 0, 80 );
00543 st_Frac = fs->make<TH1F>( "st_Frac", "Frac", 100, 0, 1 );
00544
00545
00546 EBvHB = fs->make<TH2F>( "EBvHB", "EB vs HB",1000,0,4500000.,1000,0,1000000.);
00547 EEvHE = fs->make<TH2F>( "EEvHE", "EE vs HE",1000,0,4500000.,1000,0,200000.);
00548
00549 ECALvHCAL = fs->make<TH2F>( "ECALvHCAL", "ECAL vs HCAL",100,0,20000000.,100,-500000,500000.);
00550 ECALvHCALEta1 = fs->make<TH2F>( "ECALvHCALEta1", "ECAL vs HCALEta1",100,0,20000000.,100,-500000,500000.);
00551 ECALvHCALEta2 = fs->make<TH2F>( "ECALvHCALEta2", "ECAL vs HCALEta2",100,0,20000000.,100,-500000,500000.);
00552 ECALvHCALEta3 = fs->make<TH2F>( "ECALvHCALEta3", "ECAL vs HCALEta3",100,0,20000000.,100,-500000,500000.);
00553
00554 EMF_Eta = fs->make<TProfile>("EMF_Eta","EMF Eta", 100, -50, 50, 0, 10);
00555 EMF_Phi = fs->make<TProfile>("EMF_Phi","EMF Phi", 100, 0, 100, 0, 10);
00556 EMF_EtaX = fs->make<TProfile>("EMF_EtaX","EMF EtaX", 100, -50, 50, 0, 10);
00557 EMF_PhiX = fs->make<TProfile>("EMF_PhiX","EMF PhiX", 100, 0, 100, 0, 10);
00558
00559 HFTimeVsiEtaP = fs->make<TProfile>("HFTimeVsiEtaP","HFTimeVsiEtaP", 13, 28.5, 41.5, -100, 100);
00560 HFTimeVsiEtaM = fs->make<TProfile>("HFTimeVsiEtaM","HFTimeVsiEtaM", 13, -41.5, -28.5, -100, 100);
00561
00562 HFTimeVsiEtaP5 = fs->make<TProfile>("HFTimeVsiEtaP5","HFTimeVsiEtaP5", 13, 28.5, 41.5, -100, 100);
00563 HFTimeVsiEtaM5 = fs->make<TProfile>("HFTimeVsiEtaM5","HFTimeVsiEtaM5", 13, -41.5, -28.5, -100, 100);
00564
00565 HFTimeVsiEtaP20 = fs->make<TProfile>("HFTimeVsiEtaP20","HFTimeVsiEtaP20", 13, 28.5, 41.5, -100, 100);
00566 HFTimeVsiEtaM20 = fs->make<TProfile>("HFTimeVsiEtaM20","HFTimeVsiEtaM20", 13, -41.5, -28.5, -100, 100);
00567
00568 NPass = fs->make<TH1F>( "NPass", "NPass", 3, -1, 1 );
00569 NTotal = fs->make<TH1F>( "NTotal", "NTotal", 3, -1, 1 );
00570 NTime = fs->make<TH1F>( "NTime", "NTime", 10, 0, 10 );
00571
00572
00573 HFRecHitEne = fs->make<TH1F>( "HFRecHitEne", "HFRecHitEne", 300, 0, 3000 );
00574 HFRecHitEneClean = fs->make<TH1F>( "HFRecHitEneClean", "HFRecHitEneClean", 300, 0, 3000 );
00575 HFRecHitTime = fs->make<TH1F>( "HFRecHitTime", "HFRecHitTime", 120, -60, 60 );
00576
00577
00578 HFLongShortPhi = fs->make<TH1F>( "HFLongShortPhi", "HFLongShortPhi", 73, 0, 73 );
00579 HFLongShortEta = fs->make<TH1F>( "HFLongShortEta", "HFLongShortEta", 90, -45, 45 );
00580 HFLongShortEne = fs->make<TH1F>( "HFLongShortEne", "HFLongShortEne", 300, 0, 3000 );
00581 HFLongShortTime = fs->make<TH1F>( "HFLongShortTime", "HFLongShortTime", 120, -60, 60 );
00582 HFLongShortNHits = fs->make<TH1F>( "HFLongShortNHits", "HFLongShortNHits", 30, 0, 30 );
00583
00584 HFDigiTimePhi = fs->make<TH1F>( "HFDigiTimePhi", "HFDigiTimePhi", 73, 0, 73 );
00585 HFDigiTimeEta = fs->make<TH1F>( "HFDigiTimeEta", "HFDigiTimeEta", 90, -45, 45 );
00586 HFDigiTimeEne = fs->make<TH1F>( "HFDigiTimeEne", "HFDigiTimeEne", 300, 0, 3000 );
00587 HFDigiTimeTime = fs->make<TH1F>( "HFDigiTimeTime", "HFDigiTimeTime", 120, -60, 60 );
00588 HFDigiTimeNHits = fs->make<TH1F>( "HFDigiTimeNHits", "HFDigiTimeNHits", 30, 0, 30 );
00589
00590
00591 totBNC = 0;
00592 for (int i=0; i<4000; i++) nBNC[i] = 0;
00593
00594 }
00595
00596
00597
00598 void myJetAna::analyze( const edm::Event& evt, const edm::EventSetup& es ) {
00599
00600 using namespace edm;
00601
00602 bool Pass, Pass_HFTime, Pass_DiJet, Pass_BunchCrossing, Pass_Trigger, Pass_Vertex;
00603
00604 int EtaOk10, EtaOk13, EtaOk40;
00605
00606 double LeadMass;
00607
00608 double HFRecHit[100][100][2];
00609 int HFRecHitFlag[100][100][2];
00610 int HFRecHitFlagN[100][100][2];
00611
00612 double towerEtCut, towerECut, towerE;
00613
00614 towerEtCut = 1.0;
00615 towerECut = 1.0;
00616
00617 unsigned int StableRun = 123732;
00618
00619 double HBHEThreshold = 2.0;
00620 double HFThreshold = 2.0;
00621 double HOThreshold = 2.0;
00622 double EBEEThreshold = 2.0;
00623
00624 double HBHEThreshold1 = 4.0;
00625 double HFThreshold1 = 4.0;
00626 double HOThreshold1 = 4.0;
00627
00628
00629 double HBHEThreshold2 = 10.0;
00630 double HFThreshold2 = 10.0;
00631
00632
00633
00634 double HBHEThreshold3 = 40.0;
00635 double HFThreshold3 = 40.0;
00636
00637
00638
00639 float pt1;
00640
00641 float minJetPt = 20.;
00642 float minJetPt10 = 10.;
00643 int jetInd, allJetInd;
00644 LeadMass = -1;
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657 math::XYZTLorentzVector p4tmp[2], p4cortmp[2];
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674 Pass = false;
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690 Handle<TriggerResults> triggerResults;
00691 evt.getByLabel(theTriggerResultsLabel, triggerResults);
00692
00693
00694 if (triggerResults.isValid()) {
00695 if (DEBUG) std::cout << "trigger valid " << std::endl;
00696
00697
00698 unsigned int n = triggerResults->size();
00699 for (unsigned int i=0; i!=n; i++) {
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728 }
00729
00730 } else {
00731
00732 edm::Handle<TriggerResults> *tr = new edm::Handle<TriggerResults>;
00733 triggerResults = (*tr);
00734
00735
00736
00737
00738
00739 if (DEBUG) std::cout << "trigger not valid " << std::endl;
00740 edm::LogInfo("myJetAna") << "TriggerResults::HLT not found, "
00741 "automatically select events";
00742
00743 Pass_Trigger = true;
00744
00745
00746 }
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772 if (evt.id().run() == 122294)
00773 if ( (evt.luminosityBlock() >= 37) && (evt.luminosityBlock() <= 43) )
00774 Pass = true;
00775 if (evt.id().run() == 122314)
00776 if ( (evt.luminosityBlock() >= 24) && (evt.luminosityBlock() <= 37) )
00777 Pass = true;
00778 if (evt.id().run() == 123575)
00779 Pass = true;
00780 if (evt.id().run() == 123596)
00781 Pass = true;
00782
00783
00784 if (evt.id().run() == 124009) {
00785 if ( (evt.bunchCrossing() == 51) ||
00786 (evt.bunchCrossing() == 151) ||
00787 (evt.bunchCrossing() == 2824) ) {
00788 Pass = true;
00789 }
00790 }
00791
00792 if (evt.id().run() == 124020) {
00793 if ( (evt.bunchCrossing() == 51) ||
00794 (evt.bunchCrossing() == 151) ||
00795 (evt.bunchCrossing() == 2824) ) {
00796 Pass = true;
00797 }
00798 }
00799
00800 if (evt.id().run() == 124024) {
00801 if ( (evt.bunchCrossing() == 51) ||
00802 (evt.bunchCrossing() == 151) ||
00803 (evt.bunchCrossing() == 2824) ) {
00804 Pass = true;
00805 }
00806 }
00807
00808 if ( (evt.bunchCrossing() == 51) ||
00809 (evt.bunchCrossing() == 151) ||
00810 (evt.bunchCrossing() == 2596) ||
00811 (evt.bunchCrossing() == 2724) ||
00812 (evt.bunchCrossing() == 2824) ||
00813 (evt.bunchCrossing() == 3487) ) {
00814 Pass_BunchCrossing = true;
00815 } else {
00816 Pass_BunchCrossing = false;
00817 }
00818
00819
00820
00821
00822
00823
00824 double HFM_ETime, HFP_ETime;
00825 double HFM_E, HFP_E;
00826 double HF_PMM;
00827
00828 HFM_ETime = 0.;
00829 HFM_E = 0.;
00830 HFP_ETime = 0.;
00831 HFP_E = 0.;
00832
00833 for (int i=0; i<100; i++) {
00834 for (int j=0; j<100; j++) {
00835 HFRecHit[i][j][0] = -10.;
00836 HFRecHit[i][j][1] = -10.;
00837 HFRecHitFlag[i][j][0] = 0;
00838 HFRecHitFlag[i][j][1] = 0;
00839 HFRecHitFlagN[i][j][0] = 0;
00840 HFRecHitFlagN[i][j][1] = 0;
00841 }
00842 }
00843
00844
00845 int nTime = 0;
00846 int NHFLongShortHits;
00847 int NHFDigiTimeHits;
00848 NHFLongShortHits = 0;
00849 NHFDigiTimeHits = 0;
00850
00851
00852
00853 try {
00854 std::vector<edm::Handle<HFRecHitCollection> > colls;
00855 evt.getManyByType(colls);
00856
00857 std::vector<edm::Handle<HFRecHitCollection> >::iterator i;
00858 for (i=colls.begin(); i!=colls.end(); i++) {
00859
00860 for (HFRecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
00861 if (j->id().subdet() == HcalForward) {
00862
00863 HFRecHitEne->Fill(j->energy());
00864 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 0) &&
00865 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 0) ) {
00866 HFRecHitEneClean->Fill(j->energy());
00867 }
00868
00869 HFRecHitTime->Fill(j->time());
00870
00871 int myFlag;
00872 myFlag= j->flagField(HcalCaloFlagLabels::HFLongShort);
00873 if (myFlag==1) {
00874 NHFLongShortHits++;
00875 HFLongShortPhi->Fill(j->id().iphi());
00876 HFLongShortEta->Fill(j->id().ieta());
00877 HFLongShortEne->Fill(j->energy());
00878 HFLongShortTime->Fill(j->time());
00879 }
00880
00881 myFlag= j->flagField(HcalCaloFlagLabels::HFDigiTime);
00882 if (myFlag==1) {
00883 NHFDigiTimeHits++;
00884 HFDigiTimePhi->Fill(j->id().iphi());
00885 HFDigiTimeEta->Fill(j->id().ieta());
00886 HFDigiTimeEne->Fill(j->energy());
00887 HFDigiTimeTime->Fill(j->time());
00888 }
00889
00890
00891 float en = j->energy();
00892 float time = j->time();
00893 if ((en > 20.) && (time>20.)) {
00894 HFoccTime->Fill(j->id().ieta(),j->id().iphi());
00895 nTime++;
00896 }
00897 HcalDetId id(j->detid().rawId());
00898 int ieta = id.ieta();
00899 int iphi = id.iphi();
00900 int depth = id.depth();
00901
00902
00903
00904
00905 HFRecHit[ieta+41][iphi][depth-1] = en;
00906 HFRecHitFlag[ieta+41][iphi][depth-1] = j->flagField(0);
00907
00908
00909
00910
00911
00912
00913
00914 if (j->id().ieta()<0) {
00915 if (j->energy() > HFThreshold) {
00916 HFM_ETime += j->energy()*j->time();
00917 HFM_E += j->energy();
00918 }
00919 } else {
00920 if (j->energy() > HFThreshold) {
00921 HFP_ETime += j->energy()*j->time();
00922 HFP_E += j->energy();
00923 }
00924 }
00925
00926 }
00927 }
00928 break;
00929 }
00930 } catch (...) {
00931 cout << "No HF RecHits." << endl;
00932 }
00933
00934 cout << "N HF Hits" << NHFLongShortHits << " " << NHFDigiTimeHits << endl;
00935 HFLongShortNHits->Fill(NHFLongShortHits);
00936 HFDigiTimeNHits->Fill(NHFDigiTimeHits);
00937
00938 NTime->Fill(nTime);
00939
00940 double OER = 0, OddEne, EvenEne;
00941 int nOdd, nEven;
00942
00943 for (int iphi=0; iphi<100; iphi++) {
00944 OddEne = EvenEne = 0.;
00945 nOdd = 0;
00946 nEven = 0;
00947 for (int ieta=0; ieta<100; ieta++) {
00948 if (HFRecHit[ieta][iphi][0] > 1.0) {
00949 if (ieta%2 == 0) {
00950 EvenEne += HFRecHit[ieta][iphi][0];
00951 nEven++;
00952 } else {
00953 OddEne += HFRecHit[ieta][iphi][0];
00954 nOdd++;
00955 }
00956 }
00957 if (HFRecHit[ieta][iphi][1] > 1.0) {
00958 if (ieta%2 == 0) {
00959 EvenEne += HFRecHit[ieta][iphi][1];
00960 nEven++;
00961 } else {
00962 OddEne += HFRecHit[ieta][iphi][1];
00963 nOdd++;
00964 }
00965 }
00966 }
00967 if (((OddEne + EvenEne) > 10.) && (nOdd > 1) && (nEven > 1)) {
00968 OER = (OddEne - EvenEne) / (OddEne + EvenEne);
00969 HFOERatio->Fill(OER);
00970 }
00971 }
00972
00973 if ((HFP_E > 0.) && (HFM_E > 0.)) {
00974 HF_PMM = (HFP_ETime / HFP_E) - (HFM_ETime / HFM_E);
00975 HFTimePMa->Fill(HF_PMM);
00976 } else {
00977 HF_PMM = INVALID;
00978 }
00979
00980
00981 if (fabs(HF_PMM) < 10.) {
00982 Pass_HFTime = true;
00983 } else {
00984 Pass_HFTime = false;
00985 }
00986
00987
00988
00989
00990
00991 double highestPt;
00992 double nextPt;
00993 double dphi;
00994 int nDiJet, nJet;
00995
00996 nJet = 0;
00997 nDiJet = 0;
00998 highestPt = 0.0;
00999 nextPt = 0.0;
01000
01001 allJetInd = 0;
01002 Handle<CaloJetCollection> caloJets;
01003 evt.getByLabel( CaloJetAlgorithm, caloJets );
01004 for( CaloJetCollection::const_iterator cal = caloJets->begin(); cal != caloJets->end(); ++ cal ) {
01005
01006
01007 if (nJet == 0) p4tmp[0] = cal->p4();
01008 if (nJet == 1) p4tmp[1] = cal->p4();
01009
01010 if ( (cal->pt() > 3.) &&
01011 (fabs(cal->eta()) < 3.0) ) {
01012 nDiJet++;
01013 }
01014 nJet++;
01015
01016 }
01017
01018
01019 if (nDiJet > 1) {
01020 dphi = deltaPhi(p4tmp[0].phi(), p4tmp[1].phi());
01021 Pass_DiJet = true;
01022 } else {
01023 dphi = INVALID;
01024 Pass_DiJet = false;
01025 }
01026
01027
01028
01029
01030
01031 double VTX;
01032 int nVTX;
01033
01034 edm::Handle<reco::VertexCollection> vertexCollection;
01035 evt.getByLabel("offlinePrimaryVertices", vertexCollection);
01036 const reco::VertexCollection vC = *(vertexCollection.product());
01037
01038
01039
01040 nVTX = vC.size();
01041 for (reco::VertexCollection::const_iterator vertex=vC.begin(); vertex!=vC.end(); vertex++){
01042 VTX = vertex->z();
01043 }
01044
01045 if ( (fabs(VTX) < 20.) && (nVTX > 0) ){
01046 Pass_Vertex = true;
01047 } else {
01048 Pass_Vertex = false;
01049 }
01050
01051
01052
01053
01054
01055 nBNC[evt.bunchCrossing()]++;
01056 totBNC++;
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073 edm::Handle< edmNew::DetSetVector<SiPixelCluster> > hClusterColl;
01074 evt.getByLabel("siPixelClusters", hClusterColl);
01075 const edmNew::DetSetVector<SiPixelCluster> clustColl = *(hClusterColl.product());
01076
01077 edm::Handle<reco::TrackCollection> trackCollection;
01078 evt.getByLabel("generalTracks", trackCollection);
01079 const reco::TrackCollection tC = *(trackCollection.product());
01080
01081
01082
01083
01084
01085
01086
01087 if (evt.id().run() == 1) {
01088 if ( (Pass_DiJet) &&
01089 (Pass_Vertex) ) {
01090 Pass = true;
01091 } else {
01092 Pass = false;
01093 }
01094 Pass = true;
01095
01096 } else {
01097 if ( (Pass_BunchCrossing) &&
01098 (Pass_HFTime) &&
01099 (Pass_Vertex) ) {
01100 Pass = true;
01101 } else {
01102 Pass = false;
01103 }
01104 }
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119 NTotal->Fill(0);
01120
01121 Pass = false;
01122 if ((tC.size() > 100) && (clustColl.size() > 1000)) Pass = true;
01123 Pass = true;
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137 edm::Handle<HcalNoiseSummary> summary_h;
01138 evt.getByType(summary_h);
01139 if(!summary_h.isValid()) {
01140 throw edm::Exception(edm::errors::ProductNotFound) << " could not find HcalNoiseSummary.\n";
01141
01142 }
01143
01144 const HcalNoiseSummary summary = *summary_h;
01145
01146 bool Pass_NoiseSummary;
01147 Pass_NoiseSummary = true;
01148 if(summary.minE2Over10TS()<0.7) {
01149 Pass_NoiseSummary = false;
01150 }
01151 if(summary.maxE2Over10TS()>0.96) {
01152 Pass_NoiseSummary = false;
01153 }
01154 if(summary.maxHPDHits()>=17) {
01155 Pass_NoiseSummary = false;
01156 }
01157 if(summary.maxRBXHits()>=999) {
01158 Pass_NoiseSummary = false;
01159 }
01160 if(summary.maxHPDNoOtherHits()>=10) {
01161 Pass_NoiseSummary = false;
01162 }
01163 if(summary.maxZeros()>=10) {
01164 Pass_NoiseSummary = false;
01165 }
01166 if(summary.min25GeVHitTime()<-9999.0) {
01167 Pass_NoiseSummary = false;
01168 }
01169 if(summary.max25GeVHitTime()>9999.0) {
01170 Pass_NoiseSummary = false;
01171 }
01172 if(summary.minRBXEMF()<0.01) {
01173 }
01174
01175 if (Pass_NoiseSummary) {
01176 Pass = false;
01177 } else {
01178 Pass = true;
01179 }
01180
01181
01182 Pass = true;
01183 if (Pass) {
01184
01185 NPass->Fill(0);
01186
01187
01188
01189
01190 int evtType = 0;
01191
01192 Handle<CaloTowerCollection> caloTowers;
01193 evt.getByLabel( "towerMaker", caloTowers );
01194
01195 for (int i=0;i<36;i++) {
01196 RBXColl[i].et = 0;
01197 RBXColl[i].hadEnergy = 0;
01198 RBXColl[i].emEnergy = 0;
01199 RBXColl[i].hcalTime = 0;
01200 RBXColl[i].ecalTime = 0;
01201 RBXColl[i].nTowers = 0;
01202 }
01203 for (int i=0;i<144;i++) {
01204 HPDColl[i].et = 0;
01205 HPDColl[i].hadEnergy = 0;
01206 HPDColl[i].emEnergy = 0;
01207 HPDColl[i].hcalTime = 0;
01208 HPDColl[i].ecalTime = 0;
01209 HPDColl[i].nTowers = 0;
01210 }
01211
01212 double ETotal, emFrac;
01213 double HCALTotalCaloTowerE, ECALTotalCaloTowerE;
01214 double HCALTotalCaloTowerE_Eta1, ECALTotalCaloTowerE_Eta1;
01215 double HCALTotalCaloTowerE_Eta2, ECALTotalCaloTowerE_Eta2;
01216 double HCALTotalCaloTowerE_Eta3, ECALTotalCaloTowerE_Eta3;
01217
01218 ETotal = 0.;
01219 emFrac = 0.;
01220
01221 HCALTotalCaloTowerE = 0;
01222 ECALTotalCaloTowerE = 0;
01223 HCALTotalCaloTowerE_Eta1 = 0.;
01224 ECALTotalCaloTowerE_Eta1 = 0.;
01225 HCALTotalCaloTowerE_Eta2 = 0.;
01226 ECALTotalCaloTowerE_Eta2 = 0.;
01227 HCALTotalCaloTowerE_Eta3 = 0.;
01228 ECALTotalCaloTowerE_Eta3 = 0.;
01229
01230 for (CaloTowerCollection::const_iterator tower = caloTowers->begin();
01231 tower != caloTowers->end(); tower++) {
01232 ETotal += tower->hadEnergy();
01233 ETotal += tower->emEnergy();
01234 }
01235
01236 for (CaloTowerCollection::const_iterator tower = caloTowers->begin();
01237 tower != caloTowers->end(); tower++) {
01238
01239
01240 if (abs(tower->ieta()) < 100) EMF_Eta->Fill(tower->ieta(), emFrac);
01241
01242 if (abs(tower->ieta()) < 15) {
01243 towerHadEnHB->Fill(tower->hadEnergy());
01244 towerEmEnHB->Fill(tower->emEnergy());
01245 }
01246 if ( (abs(tower->ieta()) > 17) && ((abs(tower->ieta()) < 30)) ){
01247 towerHadEnHE->Fill(tower->hadEnergy());
01248 towerEmEnHE->Fill(tower->emEnergy());
01249 }
01250 if (abs(tower->ieta()) > 29) {
01251 towerHadEnHF->Fill(tower->hadEnergy());
01252 towerEmEnHF->Fill(tower->emEnergy());
01253 }
01254
01255 towerHadEn->Fill(tower->hadEnergy());
01256 towerEmEn->Fill(tower->emEnergy());
01257 towerOuterEn->Fill(tower->outerEnergy());
01258
01259
01260
01261
01262
01263 if ((tower->emEnergy()+tower->hadEnergy()) != 0) {
01264 emFrac = tower->emEnergy()/(tower->emEnergy()+tower->hadEnergy());
01265 towerEmFrac->Fill(emFrac);
01266 } else {
01267 emFrac = 0.;
01268 }
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279 if (abs(tower->iphi()) < 100) EMF_Phi->Fill(tower->iphi(), emFrac);
01280 if (abs(tower->ieta()) < 100) EMF_Eta->Fill(tower->ieta(), emFrac);
01281 if ( (evt.id().run() == 120020) && (evt.id().event() == 453) ) {
01282 std::cout << "Bunch Crossing = " << evt.bunchCrossing()
01283 << " Orbit Number = " << evt.orbitNumber()
01284 << std::endl;
01285
01286 if (abs(tower->iphi()) < 100) EMF_PhiX->Fill(tower->iphi(), emFrac);
01287 if (abs(tower->ieta()) < 100) EMF_EtaX->Fill(tower->ieta(), emFrac);
01288 }
01289
01290 HCALTotalCaloTowerE += tower->hadEnergy();
01291 ECALTotalCaloTowerE += tower->emEnergy();
01292
01293 towerE = tower->hadEnergy() + tower->emEnergy();
01294 if (tower->et() > towerEtCut) caloEtaEt->Fill(tower->eta());
01295 if (towerE > towerECut) caloEta->Fill(tower->eta());
01296 caloPhi->Fill(tower->phi());
01297
01298 if (fabs(tower->eta()) < 1.3) {
01299 HCALTotalCaloTowerE_Eta1 += tower->hadEnergy();
01300 ECALTotalCaloTowerE_Eta1 += tower->emEnergy();
01301 }
01302 if ((fabs(tower->eta()) >= 1.3) && (fabs(tower->eta()) < 2.5)) {
01303 HCALTotalCaloTowerE_Eta2 += tower->hadEnergy();
01304 ECALTotalCaloTowerE_Eta2 += tower->emEnergy();
01305 }
01306 if (fabs(tower->eta()) > 2.5) {
01307 HCALTotalCaloTowerE_Eta3 += tower->hadEnergy();
01308 ECALTotalCaloTowerE_Eta3 += tower->emEnergy();
01309 }
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319 if ((tower->hadEnergy() + tower->emEnergy()) > 2.0) {
01320
01321 int iRBX = tower->iphi();
01322 iRBX = iRBX-2;
01323 if (iRBX == 0) iRBX = 17;
01324 if (iRBX == -1) iRBX = 18;
01325 iRBX = (iRBX-1)/4;
01326
01327 if (tower->ieta() < 0) iRBX += 18;
01328 if (iRBX < 36) {
01329 RBXColl[iRBX].et += tower->et();
01330 RBXColl[iRBX].hadEnergy += tower->hadEnergy();
01331 RBXColl[iRBX].emEnergy += tower->emEnergy();
01332 RBXColl[iRBX].hcalTime += tower->hcalTime();
01333 RBXColl[iRBX].ecalTime += tower->ecalTime();
01334 RBXColl[iRBX].nTowers++;
01335 }
01336
01337
01338
01339
01340
01341
01342 int iHPD = tower->iphi();
01343 if (tower->ieta() < 0) iHPD = iHPD + 72;
01344 if (iHPD < 144) {
01345 HPDColl[iHPD].et += tower->et();
01346 HPDColl[iHPD].hadEnergy += tower->hadEnergy();
01347 HPDColl[iHPD].emEnergy += tower->emEnergy();
01348 HPDColl[iHPD].hcalTime += tower->hcalTime();
01349 HPDColl[iHPD].ecalTime += tower->ecalTime();
01350 HPDColl[iHPD].nTowers++;
01351 }
01352
01353
01354
01355
01356
01357
01358
01359 }
01360
01361 }
01362
01363 ECALvHCAL->Fill(HCALTotalCaloTowerE, ECALTotalCaloTowerE);
01364 ECALvHCALEta1->Fill(HCALTotalCaloTowerE_Eta1, ECALTotalCaloTowerE_Eta1);
01365 ECALvHCALEta2->Fill(HCALTotalCaloTowerE_Eta2, ECALTotalCaloTowerE_Eta2);
01366 ECALvHCALEta3->Fill(HCALTotalCaloTowerE_Eta3, ECALTotalCaloTowerE_Eta3);
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388 int nRBX = 0;
01389 int nTowers = 0;
01390 for (int i=0;i<36;i++) {
01391 RBX_et->Fill(RBXColl[i].et);
01392 RBX_hadEnergy->Fill(RBXColl[i].hadEnergy);
01393 RBX_hcalTime->Fill(RBXColl[i].hcalTime / RBXColl[i].nTowers);
01394 RBX_nTowers->Fill(RBXColl[i].nTowers);
01395 if (RBXColl[i].hadEnergy > 3.0) {
01396 nRBX++;
01397 nTowers = RBXColl[i].nTowers;
01398 }
01399 }
01400 RBX_N->Fill(nRBX);
01401 if ( (nRBX == 1) && (nTowers > 24) ) {
01402 evtType = 1;
01403 }
01404
01405
01406 int nHPD = 0;
01407 for (int i=0;i<144;i++) {
01408 HPD_et->Fill(HPDColl[i].et);
01409 HPD_hadEnergy->Fill(HPDColl[i].hadEnergy);
01410 HPD_hcalTime->Fill(HPDColl[i].hcalTime / HPDColl[i].nTowers);
01411 HPD_nTowers->Fill(HPDColl[i].nTowers);
01412 if (HPDColl[i].hadEnergy > 3.0) {
01413 nHPD++;
01414 nTowers = HPDColl[i].nTowers;
01415 }
01416 }
01417 HPD_N->Fill(nHPD);
01418 if ( (nHPD == 1) && (nTowers > 6) ) {
01419 evtType = 2;
01420 cout << " nHPD = " << nHPD
01421 << " Towers = " << nTowers
01422 << " Type = " << evtType
01423 << endl;
01424 }
01425
01426
01427
01428
01429
01430
01431 Handle<TriggerResults> triggerResults;
01432 evt.getByLabel(theTriggerResultsLabel, triggerResults);
01433
01434 Int_t JetLoPass = 0;
01435
01436 if (triggerResults.isValid()) {
01437 if (DEBUG) std::cout << "trigger valid " << std::endl;
01438
01439
01440 unsigned int n = triggerResults->size();
01441 for (unsigned int i=0; i!=n; i++) {
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460 }
01461
01462 } else {
01463
01464 edm::Handle<TriggerResults> *tr = new edm::Handle<TriggerResults>;
01465 triggerResults = (*tr);
01466
01467
01468
01469
01470
01471 if (DEBUG) std::cout << "trigger not valid " << std::endl;
01472 edm::LogInfo("myJetAna") << "TriggerResults::HLT not found, "
01473 "automatically select events";
01474
01475 }
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495 Handle<CaloJetCollection> caloJets;
01496 evt.getByLabel( CaloJetAlgorithm, caloJets );
01497
01498
01499 jetInd = 0;
01500 allJetInd = 0;
01501
01502 EtaOk10 = 0;
01503 EtaOk13 = 0;
01504 EtaOk40 = 0;
01505
01506
01507
01508
01509
01510 highestPt = 0.0;
01511 nextPt = 0.0;
01512
01513 for( CaloJetCollection::const_iterator cal = caloJets->begin(); cal != caloJets->end(); ++ cal ) {
01514
01515
01516 double scale = 1.0;
01517 double corPt = scale*cal->pt();
01518
01519
01520
01521 if (corPt>highestPt) {
01522 nextPt = highestPt;
01523 p4cortmp[1] = p4cortmp[0];
01524 highestPt = corPt;
01525 p4cortmp[0] = scale*cal->p4();
01526 } else if (corPt>nextPt) {
01527 nextPt = corPt;
01528 p4cortmp[1] = scale*cal->p4();
01529 }
01530
01531 allJetInd++;
01532 if (allJetInd == 1) {
01533 h_jet1Pt->Fill( cal->pt() );
01534 h_jet1Eta->Fill( cal->eta() );
01535 if (JetLoPass != 0) h_jet1PtHLT->Fill( cal->pt() );
01536 pt1 = cal->pt();
01537 p4tmp[0] = cal->p4();
01538 if ( fabs(cal->eta()) < 1.0) EtaOk10++;
01539 if ( fabs(cal->eta()) < 1.3) EtaOk13++;
01540 if ( fabs(cal->eta()) < 4.0) EtaOk40++;
01541 }
01542 if (allJetInd == 2) {
01543 h_jet2Pt->Fill( cal->pt() );
01544 h_jet2Eta->Fill( cal->eta() );
01545 p4tmp[1] = cal->p4();
01546 if ( fabs(cal->eta()) < 1.0) EtaOk10++;
01547 if ( fabs(cal->eta()) < 1.3) EtaOk13++;
01548 if ( fabs(cal->eta()) < 4.0) EtaOk40++;
01549 }
01550
01551 if ( cal->pt() > minJetPt) {
01552 const std::vector<CaloTowerPtr> jetCaloRefs = cal->getCaloConstituents();
01553 int nConstituents = jetCaloRefs.size();
01554 h_nTowersCal->Fill(nConstituents);
01555 h_EMFracCal->Fill(cal->emEnergyFraction());
01556 h_ptCal->Fill( cal->pt() );
01557 h_etaCal->Fill( cal->eta() );
01558 h_phiCal->Fill( cal->phi() );
01559 jetInd++;
01560 }
01561 }
01562
01563 h_nCalJets->Fill( jetInd );
01564
01565 if (jetInd > 1) {
01566 LeadMass = (p4tmp[0]+p4tmp[1]).mass();
01567 dijetMass->Fill( LeadMass );
01568 }
01569
01570
01571
01572
01573
01574
01575 int nTow1, nTow2, nTow3, nTow4;
01576
01577
01578
01579
01580
01581 int jjet = 0;
01582 for ( CaloJetCollection::const_iterator ijet=caloJets->begin(); ijet!=caloJets->end(); ijet++) {
01583 jjet++;
01584
01585 float hadEne = ijet->hadEnergyInHB() + ijet->hadEnergyInHO() +
01586 ijet->hadEnergyInHE() + ijet->hadEnergyInHF();
01587 float emEne = ijet->emEnergyInEB() + ijet->emEnergyInEE() + ijet->emEnergyInHF();
01588 float had = ijet->energyFractionHadronic();
01589 float j_et = ijet->et();
01590
01591
01592 if (fabs(ijet->eta()) < 1.3) {
01593 totEneLeadJetEta1->Fill(hadEne+emEne);
01594 hadEneLeadJetEta1->Fill(ijet->hadEnergyInHB());
01595 emEneLeadJetEta1->Fill(ijet->emEnergyInEB());
01596 if (ijet->pt() > minJetPt10) hadFracEta1->Fill(had);
01597 }
01598
01599
01600 if ((fabs(ijet->eta()) > 1.3) && (fabs(ijet->eta()) < 3.) ) {
01601 totEneLeadJetEta2->Fill(hadEne+emEne);
01602 hadEneLeadJetEta2->Fill(ijet->hadEnergyInHE());
01603 emEneLeadJetEta2->Fill(ijet->emEnergyInEE());
01604 if (ijet->pt() > minJetPt10) hadFracEta2->Fill(had);
01605 }
01606
01607
01608 if (fabs(ijet->eta()) > 3.) {
01609 totEneLeadJetEta3->Fill(hadEne+emEne);
01610 hadEneLeadJetEta3->Fill(hadEne);
01611 emEneLeadJetEta3->Fill(emEne);
01612 if (ijet->pt() > minJetPt10) hadFracEta3->Fill(had);
01613 }
01614
01615
01616 const std::vector<CaloTowerPtr> jetCaloRefs = ijet->getCaloConstituents();
01617 int nConstituents = jetCaloRefs.size();
01618 NTowers->Fill(nConstituents);
01619
01620 if (jjet == 1) {
01621
01622 nTow1 = nTow2 = nTow3 = nTow4 = 0;
01623 for (int i = 0; i <nConstituents ; i++){
01624
01625 float et = jetCaloRefs[i]->et();
01626
01627 if (et > 0.5) nTow1++;
01628 if (et > 1.0) nTow2++;
01629 if (et > 1.5) nTow3++;
01630 if (et > 2.0) nTow4++;
01631
01632 hf_TowerJetEt->Fill(et/j_et);
01633
01634 }
01635
01636 nTowersLeadJetPt1->Fill(nTow1);
01637 nTowersLeadJetPt2->Fill(nTow2);
01638 nTowersLeadJetPt3->Fill(nTow3);
01639 nTowersLeadJetPt4->Fill(nTow4);
01640
01641 }
01642
01643 }
01644
01645
01646
01647
01648
01649
01650 double SumPtJet(0);
01651
01652 double SumEtNotJets(0);
01653 double SumEtJets(0);
01654 double SumEtTowers(0);
01655 double TotalClusteredE(0);
01656 double TotalUnclusteredE(0);
01657
01658 double sumJetPx(0);
01659 double sumJetPy(0);
01660
01661 double sumTowerAllPx(0);
01662 double sumTowerAllPy(0);
01663
01664 double sumTowerAllEx(0);
01665 double sumTowerAllEy(0);
01666
01667 double HCALTotalE, HBTotalE, HETotalE, HOTotalE, HFTotalE;
01668 double ECALTotalE, EBTotalE, EETotalE;
01669
01670 std::vector<CaloTowerPtr> UsedTowerList;
01671 std::vector<CaloTower> TowerUsedInJets;
01672 std::vector<CaloTower> TowerNotUsedInJets;
01673
01674
01675
01676
01677
01678 edm::Handle<HcalSourcePositionData> spd;
01679
01680 HCALTotalE = HBTotalE = HETotalE = HOTotalE = HFTotalE = 0.;
01681 try {
01682 std::vector<edm::Handle<HBHERecHitCollection> > colls;
01683 evt.getManyByType(colls);
01684 std::vector<edm::Handle<HBHERecHitCollection> >::iterator i;
01685 for (i=colls.begin(); i!=colls.end(); i++) {
01686
01687
01688 for (HBHERecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
01689
01690 if (j->id().subdet() == HcalBarrel) {
01691 HBEne->Fill(j->energy());
01692 HBTime->Fill(j->time());
01693 if (!Pass_NoiseSummary) HBTimeFlagged2->Fill(j->time());
01694 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HBTimeFlagged->Fill(j->time());
01695 HBTvsE->Fill(j->energy(), j->time());
01696
01697 if (j->time() > 20.) HBEneTThr->Fill(j->energy());
01698
01699 if ((j->time()<-25.) || (j->time()>75.)) {
01700 HBEneOOT->Fill(j->energy());
01701 if (j->energy() > HBHEThreshold) HBEneOOTTh->Fill(j->energy());
01702 if (j->energy() > HBHEThreshold1) HBEneOOTTh1->Fill(j->energy());
01703 }
01704 if (j->energy() > HBHEThreshold) {
01705 HBEneTh->Fill(j->energy());
01706 HBTimeTh->Fill(j->time());
01707 if (!Pass_NoiseSummary) HBTimeThFlagged2->Fill(j->time());
01708 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HBTimeThFlagged->Fill(j->time());
01709
01710 if (evt.id().run() >= StableRun) HBTimeThR->Fill(j->time());
01711 HBTotalE += j->energy();
01712 HBocc->Fill(j->id().ieta(),j->id().iphi());
01713 hitEta->Fill(j->id().ieta());
01714 hitPhi->Fill(j->id().iphi());
01715 }
01716 if (j->energy() > HBHEThreshold1) {
01717 HBEneTh1->Fill(j->energy());
01718 HBTimeTh1->Fill(j->time());
01719 if (!Pass_NoiseSummary) HBTimeTh1Flagged2->Fill(j->time());
01720 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HBTimeTh1Flagged->Fill(j->time());
01721
01722 if (evt.id().run() >= StableRun) HBTimeTh1R->Fill(j->time());
01723 if ((j->time()<-25.) || (j->time()>75.)) {
01724 HBoccOOT->Fill(j->id().ieta(),j->id().iphi());
01725 }
01726 }
01727 if (j->energy() > HBHEThreshold2) {
01728 HBTimeTh2->Fill(j->time());
01729 if (!Pass_NoiseSummary) HBTimeTh2Flagged2->Fill(j->time());
01730 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HBTimeTh2Flagged->Fill(j->time());
01731
01732 if (evt.id().run() >= StableRun) HBTimeTh2R->Fill(j->time());
01733 }
01734 if (j->energy() > HBHEThreshold3) {
01735 HBTimeTh3->Fill(j->time());
01736 if (evt.id().run() >= StableRun) HBTimeTh3R->Fill(j->time());
01737 }
01738 if ( (evt.id().run() == 120020) && (evt.id().event() == 453) ) {
01739 HBEneX->Fill(j->energy());
01740 if (j->energy() > HBHEThreshold) HBTimeX->Fill(j->time());
01741 }
01742 if ( (evt.id().run() == 120020) && (evt.id().event() == 457) ) {
01743 HBEneY->Fill(j->energy());
01744 if (j->energy() > HBHEThreshold) HBTimeY->Fill(j->time());
01745 }
01746 }
01747 if (j->id().subdet() == HcalEndcap) {
01748 HEEne->Fill(j->energy());
01749 HETime->Fill(j->time());
01750 if (!Pass_NoiseSummary) HETimeFlagged2->Fill(j->time());
01751 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HETimeFlagged->Fill(j->time());
01752 HETvsE->Fill(j->energy(), j->time());
01753
01754 if (j->time() > 20.) HEEneTThr->Fill(j->energy());
01755
01756 if ((j->time()<-25.) || (j->time()>75.)) {
01757 HEEneOOT->Fill(j->energy());
01758 if (j->energy() > HBHEThreshold) HEEneOOTTh->Fill(j->energy());
01759 if (j->energy() > HBHEThreshold1) HEEneOOTTh1->Fill(j->energy());
01760 }
01761
01762 if (j->energy() > HBHEThreshold) {
01763 HEEneTh->Fill(j->energy());
01764 HETimeTh->Fill(j->time());
01765 if (!Pass_NoiseSummary) HETimeThFlagged2->Fill(j->time());
01766 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HETimeThFlagged->Fill(j->time());
01767
01768 if (evt.id().run() >= StableRun) HETimeThR->Fill(j->time());
01769 HETotalE += j->energy();
01770 HEocc->Fill(j->id().ieta(),j->id().iphi());
01771 hitEta->Fill(j->id().ieta());
01772 hitPhi->Fill(j->id().iphi());
01773 }
01774 if (j->energy() > HBHEThreshold1) {
01775 HEEneTh1->Fill(j->energy());
01776 HETimeTh1->Fill(j->time());
01777 if (!Pass_NoiseSummary) HETimeTh1Flagged2->Fill(j->time());
01778 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HETimeTh1Flagged->Fill(j->time());
01779 if (evt.id().run() >= StableRun) HETimeTh1R->Fill(j->time());
01780 if ((j->time()<-25.) || (j->time()>75.)) {
01781 HEoccOOT->Fill(j->id().ieta(),j->id().iphi());
01782 }
01783 }
01784 if (j->energy() > HBHEThreshold2) {
01785 HETimeTh2->Fill(j->time());
01786 if (!Pass_NoiseSummary) HETimeTh2Flagged2->Fill(j->time());
01787 if (j->flagField(HcalCaloFlagLabels::HBHETimingShapedCutsBits) != 0) HETimeTh2Flagged->Fill(j->time());
01788 if (evt.id().run() >= StableRun) HETimeTh2R->Fill(j->time());
01789 }
01790 if (j->energy() > HBHEThreshold3) {
01791 HETimeTh3->Fill(j->time());
01792 if (evt.id().run() >= StableRun) HETimeTh3R->Fill(j->time());
01793 }
01794
01795 if ( (evt.id().run() == 120020) && (evt.id().event() == 453) ) {
01796 HEEneX->Fill(j->energy());
01797 if (j->energy() > HBHEThreshold) HETimeX->Fill(j->time());
01798 }
01799 if ( (evt.id().run() == 120020) && (evt.id().event() == 457) ) {
01800 HEEneY->Fill(j->energy());
01801 if (j->energy() > HBHEThreshold) HETimeY->Fill(j->time());
01802 }
01803
01804
01805 if (j->id().ieta()<0) {
01806 HEnegEne->Fill(j->energy());
01807 if (j->energy() > HBHEThreshold) {
01808 HEnegTime->Fill(j->time());
01809 }
01810 } else {
01811 HEposEne->Fill(j->energy());
01812 if (j->energy() > HBHEThreshold) {
01813 HEposTime->Fill(j->time());
01814 }
01815 }
01816
01817 }
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828 }
01829 }
01830 } catch (...) {
01831 cout << "No HB/HE RecHits." << endl;
01832 }
01833
01834
01835 HFM_ETime = 0.;
01836 HFM_E = 0.;
01837 HFP_ETime = 0.;
01838 HFP_E = 0.;
01839
01840 int NPMTHits;
01841 NPMTHits = 0;
01842 try {
01843 std::vector<edm::Handle<HFRecHitCollection> > colls;
01844 evt.getManyByType(colls);
01845 std::vector<edm::Handle<HFRecHitCollection> >::iterator i;
01846 for (i=colls.begin(); i!=colls.end(); i++) {
01847 for (HFRecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
01848 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) ||
01849 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01850 NPMTHits++;
01851 }
01852 }
01853 break;
01854 }
01855 } catch (...) {
01856 cout << "No HF RecHits." << endl;
01857 }
01858
01859
01860 PMTHits->Fill(NPMTHits);
01861
01862 try {
01863 std::vector<edm::Handle<HFRecHitCollection> > colls;
01864 evt.getManyByType(colls);
01865 std::vector<edm::Handle<HFRecHitCollection> >::iterator i;
01866 for (i=colls.begin(); i!=colls.end(); i++) {
01867 for (HFRecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879 if (j->id().subdet() == HcalForward) {
01880
01881 if (NPMTHits == 1) {
01882 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) ||
01883 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01884 HFEtaFlagged->Fill(j->id().ieta());
01885 if (j->id().depth() == 1) HFEtaFlaggedL->Fill(j->id().ieta());
01886 if (j->id().depth() == 2) HFEtaFlaggedS->Fill(j->id().ieta());
01887 } else {
01888 HFEtaNFlagged->Fill(j->id().ieta(), j->energy());
01889 HFEtaPhiNFlagged->Fill(j->id().ieta(),j->id().iphi(),j->energy());
01890 }
01891 }
01892 if (j->energy() > 20.) {
01893 if (NPMTHits == 0) {
01894 HFEnePMT0->Fill(j->energy());
01895 HFTimePMT0->Fill(j->time());
01896 }
01897 if (NPMTHits == 1) {
01898 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) ||
01899 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01900 HFEnePMT1->Fill(j->energy());
01901 HFTimePMT1->Fill(j->time());
01902 }
01903 }
01904 if (NPMTHits > 1) {
01905 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) ||
01906 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01907 HFEnePMT2->Fill(j->energy());
01908 HFTimePMT2->Fill(j->time());
01909 }
01910 }
01911 }
01912
01913 HFTimeVsiEtaP->Fill(j->id().ieta(), j->time());
01914 HFTimeVsiEtaM->Fill(j->id().ieta(), j->time());
01915
01916 if (j->energy() > 5.) {
01917 HFTimeVsiEtaP5->Fill(j->id().ieta(), j->time());
01918 HFTimeVsiEtaM5->Fill(j->id().ieta(), j->time());
01919 }
01920
01921 if (j->energy() > 20.) {
01922 HFTimeVsiEtaP20->Fill(j->id().ieta(), j->time());
01923 HFTimeVsiEtaM20->Fill(j->id().ieta(), j->time());
01924 }
01925
01926 HFEne->Fill(j->energy());
01927 HFTime->Fill(j->time());
01928 HFTvsE->Fill(j->energy(), j->time());
01929
01930 if (j->time() > 20.) HFEneTThr->Fill(j->energy());
01931
01932 if (j->energy() > 10.) HFTvsEThr->Fill(j->energy(), j->time());
01933
01934 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1)||
01935 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01936 HFEneFlagged->Fill(j->energy());
01937 HFoccFlagged->Fill(j->id().ieta(),j->id().iphi());
01938 HFTimeFlagged->Fill(j->time());
01939 HFTvsEFlagged->Fill(j->energy(), j->time());
01940
01941
01942
01943
01944 }
01945
01946
01947 if (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) {
01948 HFEneFlagged2->Fill(j->energy());
01949 HFoccFlagged2->Fill(j->id().ieta(),j->id().iphi());
01950 HFTimeFlagged2->Fill(j->time());
01951 HFTvsEFlagged2->Fill(j->energy(), j->time());
01952 if (j->energy() > 10.) HFTvsEFlagged2Thr->Fill(j->energy(), j->time());
01953 }
01954
01955 if (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) {
01956 HFTimeFlagged3->Fill(j->time());
01957 }
01958
01959 if (j->energy() > HFThreshold) {
01960 HFEneTh->Fill(j->energy());
01961 HFTimeTh->Fill(j->time());
01962 if (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) HFTimeThFlagged2->Fill(j->time());
01963 if (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) HFTimeThFlagged3->Fill(j->time());
01964
01965 if (evt.id().run() >= StableRun) HFTimeThR->Fill(j->time());
01966 if ( (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1)||
01967 (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) ) {
01968
01969 HFTimeThFlagged->Fill(j->time());
01970
01971 if (j->energy() > HFThreshold2) HFTimeTh2Flagged->Fill(j->time());
01972 if (j->energy() > HFThreshold3) HFTimeTh3Flagged->Fill(j->time());
01973
01974 if (evt.id().run() >= StableRun) {
01975 HFTimeThFlaggedR->Fill(j->time());
01976 if (NPMTHits == 1) HFTimeThFlaggedR1->Fill(j->time());
01977 if (NPMTHits == 2) HFTimeThFlaggedR2->Fill(j->time());
01978 if (NPMTHits == 3) HFTimeThFlaggedR3->Fill(j->time());
01979 if (NPMTHits == 4) HFTimeThFlaggedR4->Fill(j->time());
01980 if (NPMTHits > 1) HFTimeThFlaggedRM->Fill(j->time());
01981 }
01982 }
01983 HFTotalE += j->energy();
01984 HFocc->Fill(j->id().ieta(),j->id().iphi());
01985 hitEta->Fill(j->id().ieta());
01986 hitPhi->Fill(j->id().iphi());
01987 }
01988
01989 if (j->energy() > HFThreshold1) {
01990 HFEneTh1->Fill(j->energy());
01991 HFTimeTh1->Fill(j->time());
01992 if (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) HFTimeTh1Flagged2->Fill(j->time());
01993 if (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) HFTimeTh1Flagged3->Fill(j->time());
01994 if (evt.id().run() >= StableRun) HFTimeTh1R->Fill(j->time());
01995 if ((j->time()<-20.) || (j->time()>20.)) {
01996 HFoccOOT->Fill(j->id().ieta(),j->id().iphi());
01997 }
01998 }
01999 if (j->energy() > HFThreshold2) {
02000 HFTimeTh2->Fill(j->time());
02001 if (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) HFTimeTh2Flagged2->Fill(j->time());
02002 if (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) HFTimeTh2Flagged3->Fill(j->time());
02003 if (evt.id().run() >= StableRun) HFTimeTh2R->Fill(j->time());
02004 }
02005 if (j->energy() > HFThreshold3) {
02006 HFTimeTh3->Fill(j->time());
02007 if (j->flagField(HcalCaloFlagLabels::HFLongShort) == 1) HFTimeTh3Flagged2->Fill(j->time());
02008 if (j->flagField(HcalCaloFlagLabels::HFDigiTime) == 1) HFTimeTh3Flagged3->Fill(j->time());
02009 if (evt.id().run() >= StableRun) HFTimeTh3R->Fill(j->time());
02010 }
02011
02012 if (j->id().ieta()<0) {
02013 if (j->energy() > HFThreshold) {
02014
02015 HFEneM->Fill(j->energy());
02016 HFM_ETime += j->energy()*j->time();
02017 HFM_E += j->energy();
02018 }
02019 } else {
02020 if (j->energy() > HFThreshold) {
02021
02022 HFEneP->Fill(j->energy());
02023 HFP_ETime += j->energy()*j->time();
02024 HFP_E += j->energy();
02025 }
02026 }
02027
02028
02029 if (j->id().depth() == 1){
02030 HFLEne->Fill(j->energy());
02031 if (j->energy() > HFThreshold) HFLTime->Fill(j->time());
02032 } else {
02033 HFSEne->Fill(j->energy());
02034 if (j->energy() > HFThreshold) HFSTime->Fill(j->time());
02035 }
02036 }
02037 }
02038 break;
02039
02040 }
02041
02042 } catch (...) {
02043 cout << "No HF RecHits." << endl;
02044 }
02045
02046
02047
02048 for (int ieta=0; ieta<100; ieta++) {
02049 for (int iphi=0; iphi<100; iphi++) {
02050 double longF, shortF;
02051 if (HFRecHit[ieta][iphi][0] == -10.) {
02052 longF = 0.;
02053 } else {
02054 longF = HFRecHit[ieta][iphi][0];
02055 }
02056 if (HFRecHit[ieta][iphi][1] == -10.) {
02057 shortF = 0.;
02058 } else {
02059 shortF = HFRecHit[ieta][iphi][1];
02060 }
02061
02062
02063 if (longF > 0.) HFLEneAll->Fill(longF);
02064 if (shortF > 0.) HFSEneAll->Fill(shortF);
02065
02066
02067 if ((longF > 20.) || (shortF > 20.)) {
02068 double R = (longF-shortF)/(longF+shortF);
02069 HFLSRatio->Fill(R);
02070 if (fabs(R) > 0.995) {
02071
02072
02073
02074 if (longF > (162.4-10.19*abs(ieta-41)+.21*abs(ieta-41)*abs(ieta-41)) ) {
02075 HFRecHitFlagN[ieta+41][iphi][0] = 1;
02076 HFEtaFlaggedLN->Fill(ieta-41);
02077
02078 HFLEneAllF->Fill(longF);
02079
02080 if (shortF == 0.) HFLEneNoSFlaggedN->Fill(longF);
02081 }
02082
02083
02084 if (shortF > (129.9-6.61*abs(ieta-41)+0.1153*abs(ieta-41)*abs(ieta-41)) ) {
02085 HFRecHitFlagN[ieta+41][iphi][1] = 1;
02086 HFEtaFlaggedSN->Fill(ieta-41);
02087
02088 HFSEneAllF->Fill(shortF);
02089
02090 if (longF == 0.) HFSEneNoLFlaggedN->Fill(shortF);
02091 }
02092 }
02093 }
02094
02095
02096
02097
02098
02099
02100
02101
02102 HFLvsS->Fill(HFRecHit[ieta][iphi][1], HFRecHit[ieta][iphi][0]);
02103 if ( (HFRecHit[ieta][iphi][1] == -10.) && (HFRecHit[ieta][iphi][0] != -10.) ) {
02104 HFLEneNoS->Fill(HFRecHit[ieta][iphi][0]);
02105 if (HFRecHitFlag[ieta][iphi][0] !=0 ) HFLEneNoSFlagged->Fill(HFRecHit[ieta][iphi][0]);
02106 }
02107 if ( (HFRecHit[ieta][iphi][0] == -10.) && (HFRecHit[ieta][iphi][1] != -10.) ) {
02108 HFSEneNoL->Fill(HFRecHit[ieta][iphi][1]);
02109 if (HFRecHitFlag[ieta][iphi][1] !=0 ) HFSEneNoLFlagged->Fill(HFRecHit[ieta][iphi][1]);
02110 }
02111
02112 }
02113 }
02114
02115 if (HFP_E > 0.) HFTimeP->Fill(HFP_ETime / HFP_E);
02116 if (HFM_E > 0.) HFTimeM->Fill(HFM_ETime / HFM_E);
02117
02118 if ((HFP_E > 0.) && (HFM_E > 0.)) {
02119 HF_PMM = (HFP_ETime / HFP_E) - (HFM_ETime / HFM_E);
02120 HFTimePM->Fill(HF_PMM);
02121 } else {
02122 HF_PMM = INVALID;
02123 }
02124
02125
02126
02127 try {
02128 std::vector<edm::Handle<HORecHitCollection> > colls;
02129 evt.getManyByType(colls);
02130 std::vector<edm::Handle<HORecHitCollection> >::iterator i;
02131 for (i=colls.begin(); i!=colls.end(); i++) {
02132 for (HORecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
02133 if (j->id().subdet() == HcalOuter) {
02134 HOEne->Fill(j->energy());
02135 HOTime->Fill(j->time());
02136 HOTvsE->Fill(j->energy(), j->time());
02137 if (j->energy() > HOThreshold1) {
02138 HOEneTh1->Fill(j->energy());
02139 }
02140 if (j->energy() > HOThreshold) {
02141 HOEneTh->Fill(j->energy());
02142 HOTimeTh->Fill(j->time());
02143 HOTotalE += j->energy();
02144 HOocc->Fill(j->id().ieta(),j->id().iphi());
02145 }
02146
02147
02148 if (((j->id().iphi()>=59 && j->id().iphi()<=70 &&
02149 j->id().ieta()>=11 && j->id().ieta()<=15) ||
02150 (j->id().iphi()>=47 && j->id().iphi()<=58 &&
02151 j->id().ieta()>=5 && j->id().ieta()<=10)))
02152 {
02153 HOSEne->Fill(j->energy());
02154 if (j->energy() > HOThreshold) HOSTime->Fill(j->time());
02155 } else if ((j->id().iphi()<59 || j->id().iphi()>70 ||
02156 j->id().ieta()<11 || j->id().ieta()>15) &&
02157 (j->id().iphi()<47 || j->id().iphi()>58 ||
02158 j->id().ieta()<5 || j->id().ieta()>10))
02159 {
02160 HOHEne->Fill(j->energy());
02161 if (j->energy() > HOThreshold) HOHTime->Fill(j->time());
02162
02163 if (j->id().ieta()<= -11){
02164 HOHrm2Ene->Fill(j->energy());
02165 if (j->energy() > HOThreshold) HOHrm2Time->Fill(j->time());
02166 } else if (j->id().ieta()>= -10 && j->id().ieta() <= -5) {
02167 HOHrm1Ene->Fill(j->energy());
02168 if (j->energy() > HOThreshold) HOHrm1Time->Fill(j->time());
02169 } else if (j->id().ieta()>= -4 && j->id().ieta() <= 4) {
02170 HOHr0Ene->Fill(j->energy());
02171 if (j->energy() > HOThreshold) HOHr0Time->Fill(j->time());
02172 } else if (j->id().ieta()>= 5 && j->id().ieta() <= 10) {
02173 HOHrp1Ene->Fill(j->energy());
02174 if (j->energy() > HOThreshold) HOHrp1Time->Fill(j->time());
02175 } else if (j->id().ieta()>= 11) {
02176 HOHrp2Ene->Fill(j->energy());
02177 if (j->energy() > HOThreshold) HOHrp2Time->Fill(j->time());
02178 } else {
02179 std::cout << "Finding events that are in no ring !?!" << std::endl;
02180 std::cout << "eta = " << j->id().ieta() << std::endl;
02181
02182 }
02183 } else {
02184 std::cout << "Finding events that are neither SiPM nor HPD!?" << std::endl;
02185 }
02186
02187
02188
02189 }
02190
02191 }
02192 }
02193 } catch (...) {
02194 cout << "No HO RecHits." << endl;
02195 }
02196
02197 HCALTotalE = HBTotalE + HETotalE + HFTotalE + HOTotalE;
02198 ECALTotalE = EBTotalE = EETotalE = 0.;
02199
02200
02201 try {
02202 std::vector<edm::Handle<EcalRecHitCollection> > colls;
02203 evt.getManyByType(colls);
02204 std::vector<edm::Handle<EcalRecHitCollection> >::iterator i;
02205 for (i=colls.begin(); i!=colls.end(); i++) {
02206 for (EcalRecHitCollection::const_iterator j=(*i)->begin(); j!=(*i)->end(); j++) {
02207 if (j->id().subdetId() == EcalBarrel) {
02208 EBEne->Fill(j->energy());
02209 EBTime->Fill(j->time());
02210 if (j->energy() > EBEEThreshold) {
02211 EBEneTh->Fill(j->energy());
02212 EBTimeTh->Fill(j->time());
02213 }
02214 if ( (evt.id().run() == 120020) && (evt.id().event() == 453) ) {
02215 EBEneX->Fill(j->energy());
02216 EBTimeX->Fill(j->time());
02217 }
02218 if ( (evt.id().run() == 120020) && (evt.id().event() == 457) ) {
02219 EBEneY->Fill(j->energy());
02220 EBTimeY->Fill(j->time());
02221 }
02222 EBTotalE += j->energy();
02223 }
02224 if (j->id().subdetId() == EcalEndcap) {
02225 EEEne->Fill(j->energy());
02226 EETime->Fill(j->time());
02227 if (j->energy() > EBEEThreshold) {
02228 EEEneTh->Fill(j->energy());
02229 EETimeTh->Fill(j->time());
02230 }
02231 if ( (evt.id().run() == 120020) && (evt.id().event() == 453) ) {
02232 EEEneX->Fill(j->energy());
02233 EETimeX->Fill(j->time());
02234 }
02235 if ( (evt.id().run() == 120020) && (evt.id().event() == 457 ) ) {
02236 EEEneY->Fill(j->energy());
02237 EETimeY->Fill(j->time());
02238 }
02239 EETotalE += j->energy();
02240 }
02241
02242
02243 }
02244 }
02245 } catch (...) {
02246 cout << "No ECAL RecHits." << endl;
02247 }
02248
02249 EBvHB->Fill(HBTotalE, EBTotalE);
02250 EEvHE->Fill(HETotalE, EETotalE);
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301
02302 ECALTotalE = EBTotalE + EETotalE;
02303
02304 if ( (EBTotalE > 320000) && (EBTotalE < 330000) &&
02305 (HBTotalE > 2700000) && (HBTotalE < 2800000) ) {
02306
02307 std::cout << ">>> Off Axis! "
02308 << std::endl;
02309
02310 }
02311
02312
02313
02314
02315
02316
02317
02318
02319
02320
02321
02322
02323
02324
02325
02326
02327
02328 nTow1 = nTow2 = nTow3 = nTow4 = 0;
02329
02330 double sum_et = 0.0;
02331 double sum_ex = 0.0;
02332 double sum_ey = 0.0;
02333
02334 double HFsum_et = 0.0;
02335 double HFsum_ex = 0.0;
02336 double HFsum_ey = 0.0;
02337
02338
02339
02340
02341
02342 for (CaloTowerCollection::const_iterator tower = caloTowers->begin();
02343 tower != caloTowers->end(); tower++) {
02344
02345 Double_t et = tower->et();
02346 Double_t phix = tower->phi();
02347
02348 if (et > 0.5) nTow1++;
02349 if (et > 1.0) nTow2++;
02350 if (et > 1.5) nTow3++;
02351 if (et > 2.0) nTow4++;
02352
02353
02354
02355
02356
02357 if (tower->emEnergy() > 2.0) {
02358 h_EmEnergy->Fill (tower->ieta(), tower->iphi(), tower->emEnergy());
02359 }
02360 if (tower->hadEnergy() > 2.0) {
02361 h_HadEnergy->Fill (tower->ieta(), tower->iphi(), tower->hadEnergy());
02362 }
02363
02364 if (fabs(tower->ieta()) > 29) {
02365 HFsum_et += et;
02366 HFsum_ex += et*cos(phix);
02367 HFsum_ey += et*sin(phix);
02368 }
02369
02370
02371 if (et>0.5) {
02372
02373 ETime->Fill(tower->ecalTime());
02374 HTime->Fill(tower->hcalTime());
02375
02376
02377
02378
02379
02380
02381
02382 sum_et += et;
02383 sum_ex += et*cos(phix);
02384 sum_ey += et*sin(phix);
02385
02386
02387 Double_t phi = tower->phi();
02388 SumEtTowers += tower->et();
02389
02390 sumTowerAllEx += et*cos(phi);
02391 sumTowerAllEy += et*sin(phi);
02392
02393 }
02394
02395 }
02396
02397
02398
02399
02400 HFSumEt->Fill(HFsum_et);
02401 HFMET->Fill(sqrt( HFsum_ex*HFsum_ex + HFsum_ey*HFsum_ey));
02402
02403 hf_sumTowerAllEx->Fill(sumTowerAllEx);
02404 hf_sumTowerAllEy->Fill(sumTowerAllEy);
02405
02406 nTowers1->Fill(nTow1);
02407 nTowers2->Fill(nTow2);
02408 nTowers3->Fill(nTow3);
02409 nTowers4->Fill(nTow4);
02410
02411
02412
02413
02414
02415 UsedTowerList.clear();
02416 TowerUsedInJets.clear();
02417 TowerNotUsedInJets.clear();
02418
02419
02420
02421 for ( CaloJetCollection::const_iterator ijet=caloJets->begin(); ijet!=caloJets->end(); ijet++) {
02422
02423 Double_t jetPt = ijet->pt();
02424 Double_t jetEta = ijet->eta();
02425 Double_t jetPhi = ijet->phi();
02426
02427
02428
02429 Double_t jetPx = jetPt*cos(jetPhi);
02430 Double_t jetPy = jetPt*sin(jetPhi);
02431
02432 sumJetPx +=jetPx;
02433 sumJetPy +=jetPy;
02434
02435 const std::vector<CaloTowerPtr> jetCaloRefs = ijet->getCaloConstituents();
02436 int nConstituents = jetCaloRefs.size();
02437 for (int i = 0; i <nConstituents ; i++){
02438
02439 UsedTowerList.push_back(jetCaloRefs[i]);
02440 }
02441
02442 SumPtJet +=jetPt;
02443
02444
02445
02446 if ( (jetPt>80.0) && (fabs(jetEta) < 1.3) ){
02447 st_Pt->Fill( jetPt );
02448 int nConstituents = ijet->getCaloConstituents().size();
02449 st_Constituents->Fill( nConstituents );
02450
02451 float maxEne = 0.;
02452 float totEne = 0.;
02453
02454 for(unsigned twr=0; twr<ijet->getCaloConstituents().size(); ++twr){
02455 CaloTowerPtr tower = (ijet->getCaloConstituents())[twr];
02456
02457 if( tower->et()>0. ){
02458
02459 if (tower->energy() > maxEne) maxEne = tower->energy();
02460 totEne += tower->energy();
02461
02462 st_Energy->Fill( tower->energy() );
02463 st_EmEnergy->Fill( tower->emEnergy() );
02464 st_HadEnergy->Fill( tower->hadEnergy() );
02465 st_OuterEnergy->Fill( tower->outerEnergy() );
02466
02467 st_Eta->Fill( tower->eta() );
02468 st_Phi->Fill( tower->phi() );
02469
02470 st_iEta->Fill( tower->ieta() );
02471 st_iPhi->Fill( tower->iphi() );
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487 }
02488 }
02489 st_Frac->Fill( maxEne / totEne );
02490
02491 }
02492
02493 }
02494
02495 int NTowersUsed = UsedTowerList.size();
02496
02497
02498 for (CaloTowerCollection::const_iterator tower = caloTowers->begin();
02499 tower != caloTowers->end(); tower++) {
02500
02501 CaloTower t = *tower;
02502 Double_t et = tower->et();
02503
02504 if(et>0) {
02505
02506 Double_t phi = tower->phi();
02507 SumEtTowers += tower->et();
02508
02509 sumTowerAllPx += et*cos(phi);
02510 sumTowerAllPy += et*sin(phi);
02511
02512 bool used = false;
02513
02514 for(int i=0; i<NTowersUsed; i++){
02515 if(tower->id() == UsedTowerList[i]->id()){
02516 used=true;
02517 break;
02518 }
02519 }
02520
02521 if (used) {
02522 TowerUsedInJets.push_back(t);
02523 } else {
02524 TowerNotUsedInJets.push_back(t);
02525 }
02526 }
02527 }
02528
02529 int nUsed = TowerUsedInJets.size();
02530 int nNotUsed = TowerNotUsedInJets.size();
02531
02532 SumEtJets = 0;
02533 SumEtNotJets = 0;
02534 TotalClusteredE = 0;
02535 TotalUnclusteredE = 0;
02536
02537 for(int i=0;i<nUsed;i++){
02538 SumEtJets += TowerUsedInJets[i].et();
02539 h_ClusteredE->Fill(TowerUsedInJets[i].energy());
02540 if (TowerUsedInJets[i].energy() > 1.0)
02541 TotalClusteredE += TowerUsedInJets[i].energy();
02542 }
02543 h_jetEt->Fill(SumEtJets);
02544
02545 for(int i=0;i<nNotUsed;i++){
02546 if (TowerNotUsedInJets[i].et() > 0.5)
02547 SumEtNotJets += TowerNotUsedInJets[i].et();
02548 h_UnclusteredEt->Fill(TowerNotUsedInJets[i].et());
02549 h_UnclusteredEts->Fill(TowerNotUsedInJets[i].et());
02550 h_UnclusteredE->Fill(TowerNotUsedInJets[i].energy());
02551 if (TowerNotUsedInJets[i].energy() > 1.0)
02552 TotalUnclusteredE += TowerNotUsedInJets[i].energy();
02553 }
02554
02555 h_TotalClusteredE->Fill(TotalClusteredE);
02556 h_TotalUnclusteredE->Fill(TotalUnclusteredE);
02557 h_TotalUnclusteredEt->Fill(SumEtNotJets);
02558
02559
02560
02561
02562
02563 edm::Handle<reco::CaloMETCollection> calometcoll;
02564 evt.getByLabel("met", calometcoll);
02565 if (calometcoll.isValid()) {
02566 const CaloMETCollection *calometcol = calometcoll.product();
02567 const CaloMET *calomet;
02568 calomet = &(calometcol->front());
02569
02570 double caloSumET = calomet->sumEt();
02571 double caloMET = calomet->pt();
02572 double caloMETSig = calomet->mEtSig();
02573 double caloMEx = calomet->px();
02574 double caloMEy = calomet->py();
02575 double caloMETPhi = calomet->phi();
02576
02577 SumEt->Fill(caloSumET);
02578 MET->Fill(caloMET);
02579 if (std::abs(OER) > 0.8) OERMET->Fill(caloMET);
02580
02581 if (evtType == 0) MET_Tower->Fill(caloMET);
02582 if (evtType == 1) MET_RBX->Fill(caloMET);
02583 if (evtType == 2) MET_HPD->Fill(caloMET);
02584 METSig->Fill(caloMETSig);
02585 MEx->Fill(caloMEx);
02586 MEy->Fill(caloMEy);
02587 METPhi->Fill(caloMETPhi);
02588
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605 }
02606
02607
02608
02609
02610 VTX = INVALID;
02611 nVTX = 0;
02612
02613 edm::Handle<reco::VertexCollection> vertexCollection;
02614 evt.getByLabel("offlinePrimaryVertices", vertexCollection);
02615 const reco::VertexCollection vC = *(vertexCollection.product());
02616
02617
02618 nVTX = vC.size();
02619
02620 for (reco::VertexCollection::const_iterator vertex=vC.begin(); vertex!=vC.end(); vertex++){
02621
02622 h_Vx->Fill(vertex->x());
02623 h_Vy->Fill(vertex->y());
02624 h_Vz->Fill(vertex->z());
02625 VTX = vertex->z();
02626
02627
02628
02629 }
02630
02631 if ((HF_PMM != INVALID) || (nVTX > 0)) {
02632 HFvsZ->Fill(HF_PMM,VTX);
02633 }
02634
02635
02636
02637
02638
02639
02640
02641
02642 SiClusters->Fill(clustColl.size());
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682 h_Trk_NTrk->Fill(tC.size());
02683 if (NPMTHits == 0) TrkMultFlagged0->Fill(tC.size());
02684 if (NPMTHits == 1) TrkMultFlagged1->Fill(tC.size());
02685 if (NPMTHits == 2) TrkMultFlagged2->Fill(tC.size());
02686 if (NPMTHits == 3) TrkMultFlagged3->Fill(tC.size());
02687 if (NPMTHits == 4) TrkMultFlagged4->Fill(tC.size());
02688 if (NPMTHits > 1) TrkMultFlaggedM->Fill(tC.size());
02689 for (reco::TrackCollection::const_iterator track=tC.begin(); track!=tC.end(); track++){
02690 h_Trk_pt->Fill(track->pt());
02691 }
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
02720
02721
02722
02723
02724
02725
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746 int iJet;
02747 iJet = 0;
02748 for( CaloJetCollection::const_iterator ijet = caloJets->begin(); ijet != caloJets->end(); ++ ijet ) {
02749
02750
02751
02752
02753
02754
02755
02756 iJet++;
02757
02758
02759
02760
02761
02762 h_pt->Fill(ijet->pt());
02763 if (evtType == 0) h_ptTower->Fill(ijet->pt());
02764 if (evtType == 1) h_ptRBX->Fill(ijet->pt());
02765 if (evtType == 2) h_ptHPD->Fill(ijet->pt());
02766 h_et->Fill(ijet->et());
02767 h_eta->Fill(ijet->eta());
02768 h_phi->Fill(ijet->phi());
02769
02770 jetHOEne->Fill(ijet->hadEnergyInHO());
02771 jetEMFraction->Fill(ijet->emEnergyFraction());
02772
02773
02774 }
02775
02776
02777
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791
02792
02793
02794
02795
02796
02797
02798
02799
02800
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815 }
02816
02817 }
02818
02819
02820
02821 void myJetAna::endJob() {
02822
02823 for (int i=0; i<4000; i++) {
02824 if ((nBNC[i]/totBNC) > 0.05) {
02825 std::cout << "+++ " << i << " "
02826 << (nBNC[i]/totBNC) << " "
02827 << nBNC[i] << " "
02828 << totBNC << " "
02829 << std::endl;
02830 }
02831 }
02832
02833
02834 }
02835 #include "FWCore/Framework/interface/MakerMacros.h"
02836 DEFINE_FWK_MODULE(myJetAna);
1.7.3