| 1 |
// remkarks:
|
| 2 |
// !!! in the W selection every electron is taken, also the
|
| 3 |
// non isolated !!!
|
| 4 |
|
| 5 |
|
| 6 |
// implement conversion removal for robust...
|
| 7 |
|
| 8 |
|
| 9 |
|
| 10 |
|
| 11 |
|
| 12 |
|
| 13 |
#define analysisClass_cxx
|
| 14 |
#include "analysisClass.h"
|
| 15 |
|
| 16 |
#include <TH2.h>
|
| 17 |
#include <TF2.h>
|
| 18 |
#include <TH1F.h>
|
| 19 |
#include <TStyle.h>
|
| 20 |
#include <TCanvas.h>
|
| 21 |
#include <TLorentzVector.h>
|
| 22 |
#include <TVector2.h>
|
| 23 |
#include <TVector3.h>
|
| 24 |
#include <TTree.h>
|
| 25 |
|
| 26 |
analysisClass::analysisClass(string * inputList, string * cutFile, string * treeName, string * outputFileName, string * cutEfficFile)
|
| 27 |
:baseClass(inputList, cutFile, treeName, outputFileName, cutEfficFile)
|
| 28 |
{
|
| 29 |
std::cout << "analysisClass::analysisClass(): begins " << std::endl;
|
| 30 |
|
| 31 |
std::cout << "analysisClass::analysisClass(): ends " << std::endl;
|
| 32 |
}
|
| 33 |
|
| 34 |
analysisClass::~analysisClass()
|
| 35 |
{
|
| 36 |
std::cout << "analysisClass::~analysisClass(): begins " << std::endl;
|
| 37 |
|
| 38 |
std::cout << "analysisClass::~analysisClass(): ends " << std::endl;
|
| 39 |
}
|
| 40 |
|
| 41 |
|
| 42 |
|
| 43 |
|
| 44 |
void filler(myEvent electrons, TH1D *pt, TH1D *eta, TH1D *phi, TH1D *met, TH1D *charge,
|
| 45 |
TH1D *deltaPhi, TH1D *deltaEta, TH1D *oneOverEminusOneOverP, TH1D *transMass,
|
| 46 |
TH1D *ethIso, TH1D *trkIso, TH1D *ecalIso, TH1D *hcalIso, TH1D* HoverE,
|
| 47 |
TH1D *sigmaIetaIeta, TH1D *numberOfMissingInnerHits
|
| 48 |
)
|
| 49 |
|
| 50 |
{
|
| 51 |
pt->Fill(electrons.momentum[0]);
|
| 52 |
eta->Fill(electrons.fourvector[0].Eta());
|
| 53 |
phi->Fill(electrons.fourvector[0].Phi());
|
| 54 |
met->Fill(electrons.missinget);
|
| 55 |
charge->Fill(electrons.charge[0]);
|
| 56 |
|
| 57 |
deltaPhi->Fill(fabs(electrons.deltaPhi[0]));
|
| 58 |
deltaEta->Fill(fabs(electrons.deltaEta[0]));
|
| 59 |
oneOverEminusOneOverP->Fill(fabs(electrons.oneOverEminusOverP[0]));
|
| 60 |
transMass->Fill(electrons.transverseMass[0]);
|
| 61 |
ethIso->Fill(electrons.ethIso[0]);
|
| 62 |
trkIso->Fill(electrons.trkIso[0]);
|
| 63 |
ecalIso->Fill(electrons.ecalIso[0]);
|
| 64 |
hcalIso->Fill(electrons.hcalIso[0]);
|
| 65 |
HoverE->Fill(electrons.HoverE[0]);
|
| 66 |
sigmaIetaIeta->Fill(electrons.sigmaIetaIeta[0]);
|
| 67 |
numberOfMissingInnerHits->Fill(electrons.numberOfMissingInnerHits[0]);
|
| 68 |
|
| 69 |
}
|
| 70 |
|
| 71 |
void scaleHisto(TH1D* histo, double factor) {
|
| 72 |
int binnumber=histo->GetNbinsX();
|
| 73 |
for(int i=0;i<=binnumber+1;i++) {
|
| 74 |
double bincontent=histo->GetBinContent(i);
|
| 75 |
double newbincontent=bincontent*factor;
|
| 76 |
histo->SetBinContent(i,newbincontent);
|
| 77 |
double binerror=histo->GetBinError(i);
|
| 78 |
double newbinerror=binerror*factor;
|
| 79 |
histo->SetBinError(i,newbinerror);
|
| 80 |
}
|
| 81 |
}
|
| 82 |
|
| 83 |
|
| 84 |
|
| 85 |
void analysisClass::Loop()
|
| 86 |
{
|
| 87 |
std::cout << "analysisClass::Loop() begins" <<std::endl;
|
| 88 |
|
| 89 |
if (fChain == 0) return;
|
| 90 |
|
| 91 |
|
| 92 |
//getHLTtable();
|
| 93 |
|
| 94 |
|
| 95 |
double PtCorrection = 1.;
|
| 96 |
|
| 97 |
|
| 98 |
int counterSize=15;
|
| 99 |
int* counter = new int[counterSize];
|
| 100 |
memset(counter,0,counterSize*sizeof(int));
|
| 101 |
|
| 102 |
int cNa = 0;
|
| 103 |
int cNb = 0;
|
| 104 |
|
| 105 |
FILE *out=fopen("out.txt","w");
|
| 106 |
FILE *out_Z=fopen("out_z.txt","w");
|
| 107 |
fprintf(out_Z,"Run \tEvent \tLS \tDiLeptonMass \tPt_1 \tPt2 \tEta_1 \tEta_2 \tDiLeptonPt \tsumJetPt \n");
|
| 108 |
|
| 109 |
|
| 110 |
// --------------------------------------------------------------------------------------------------------------------
|
| 111 |
// Analysis input parameters
|
| 112 |
// --------------------------------------------------------------------------------------------------------------------
|
| 113 |
int workingPoint = 95; // -1 takes hard coded values (which are the old robust tight values...)
|
| 114 |
double sampleSize=-1;
|
| 115 |
|
| 116 |
bool isdata=false;
|
| 117 |
bool printInfo=false;
|
| 118 |
bool noInnerHitInfo=false;
|
| 119 |
bool writeIdPlots=true;
|
| 120 |
bool writeN1Plots=true;
|
| 121 |
bool writeWenuPlots=true;
|
| 122 |
bool applyDeltaCorrection=false;
|
| 123 |
bool applyJetVeto=false;
|
| 124 |
|
| 125 |
// --------------------------------------------------------------------------------------------------------------------
|
| 126 |
|
| 127 |
double Pi=2*acos(0); // pi=3.14159...
|
| 128 |
double ptMin=20;
|
| 129 |
double jetEtaMax=2.5;
|
| 130 |
double jetPtMin=30.;
|
| 131 |
double deltaRMax=0.3; // delta R for jet veto
|
| 132 |
|
| 133 |
|
| 134 |
int MAXE=41;
|
| 135 |
|
| 136 |
double totalNumberOfEvents=0;
|
| 137 |
vector<double> WorkingPointCuts;
|
| 138 |
vector<double> EthCuts;
|
| 139 |
|
| 140 |
vector<int> electronIndex;
|
| 141 |
vector<int> jetIndex;
|
| 142 |
|
| 143 |
|
| 144 |
// --------------------------------------------------------------------------------------------------------------------
|
| 145 |
// tag and probe counters
|
| 146 |
// --------------------------------------------------------------------------------------------------------------------
|
| 147 |
int N_tt=0;
|
| 148 |
int N_t0=0;
|
| 149 |
|
| 150 |
|
| 151 |
// --------------------------------------------------------------------------------------------------------------------
|
| 152 |
// Electron Cuts
|
| 153 |
// --------------------------------------------------------------------------------------------------------------------
|
| 154 |
|
| 155 |
// Geometry
|
| 156 |
double etaBarrelMax=1.44;
|
| 157 |
double etaEndcapMin=1.56;
|
| 158 |
double etaEndcapMax=2.5;
|
| 159 |
// Preselection
|
| 160 |
double Pre_HoverEMin=0.15;
|
| 161 |
double Pre_deltaEtaMax=0.02;
|
| 162 |
double Pre_deltaPhiMax=0.15;
|
| 163 |
double Pre_pt=20.;
|
| 164 |
// ETH ID
|
| 165 |
double ETH_oneOverEminusOneOverP_B=0.005;
|
| 166 |
double ETH_deltaEtaMax_B=0.004;
|
| 167 |
double ETH_deltaPhiMax_B=0.02;
|
| 168 |
double ETH_iso_B=0.1;
|
| 169 |
int ETH_missingHits_B=1;
|
| 170 |
double ETH_oneOverEminusOneOverP_E=0.007;
|
| 171 |
double ETH_deltaEtaMax_E=0.006;
|
| 172 |
double ETH_deltaPhiMax_E=0.02;
|
| 173 |
double ETH_iso_E=0.1;
|
| 174 |
int ETH_missingHits_E=1;
|
| 175 |
|
| 176 |
// double Rob_HoverE_B=0.0201;
|
| 177 |
// double Rob_SigmaIetaIeta_B=0.0102;
|
| 178 |
// double Rob_deltaPhi_B=0.0211;
|
| 179 |
// double Rob_deltaEta_B=0.00606;
|
| 180 |
// double Rob_trkIso_B=2.34;
|
| 181 |
// double Rob_ecalIso_B=3.24;
|
| 182 |
// double Rob_hcalIso_B=4.51;
|
| 183 |
// double Rob_combIso_B=0.;
|
| 184 |
// int Rob_missingHits_B=1;
|
| 185 |
|
| 186 |
// double Rob_HoverE_E=0.00253;
|
| 187 |
// double Rob_SigmaIetaIeta_E=0.0291;
|
| 188 |
// double Rob_deltaPhi_E=0.022;
|
| 189 |
// double Rob_deltaEta_E=0.0032;
|
| 190 |
// double Rob_trkIso_E=0.826;
|
| 191 |
// double Rob_ecalIso_E=2.7;
|
| 192 |
// double Rob_hcalIso_E=0.255;
|
| 193 |
// double Rob_combIso_E=0.;
|
| 194 |
// int Rob_missingHits_E=1;
|
| 195 |
// double Rob_dist_E=0.02;
|
| 196 |
// double Rob_cot_E=0.02;
|
| 197 |
|
| 198 |
int debug=0;
|
| 199 |
|
| 200 |
|
| 201 |
|
| 202 |
// fill the eth cuts vector
|
| 203 |
EthCuts.push_back(ETH_deltaPhiMax_B);
|
| 204 |
EthCuts.push_back(ETH_deltaEtaMax_B);
|
| 205 |
EthCuts.push_back(ETH_oneOverEminusOneOverP_B);
|
| 206 |
EthCuts.push_back(ETH_iso_B);
|
| 207 |
EthCuts.push_back(ETH_missingHits_B);
|
| 208 |
EthCuts.push_back(ETH_deltaPhiMax_E);
|
| 209 |
EthCuts.push_back(ETH_deltaEtaMax_E);
|
| 210 |
EthCuts.push_back(ETH_oneOverEminusOneOverP_E);
|
| 211 |
EthCuts.push_back(ETH_iso_E);
|
| 212 |
EthCuts.push_back(ETH_missingHits_E);
|
| 213 |
|
| 214 |
|
| 215 |
|
| 216 |
|
| 217 |
// --------------------------------------------------------------------------------------------------------------------
|
| 218 |
// read the cut values from include/workingPoints.txt
|
| 219 |
// --------------------------------------------------------------------------------------------------------------------
|
| 220 |
|
| 221 |
// check if it is a possible working point
|
| 222 |
if(workingPoint>0 && (
|
| 223 |
workingPoint!=60 &&
|
| 224 |
workingPoint!=70 &&
|
| 225 |
workingPoint!=80 &&
|
| 226 |
workingPoint!=85 &&
|
| 227 |
workingPoint!=90 &&
|
| 228 |
workingPoint!=95 )
|
| 229 |
) {
|
| 230 |
cerr<<"ERROR: "<<workingPoint<<" is NOT a valid working point!!!"<<endl;
|
| 231 |
exit(0);
|
| 232 |
}
|
| 233 |
// read the file
|
| 234 |
if(workingPoint>0) {
|
| 235 |
const char *file="include/workingPoints.txt";
|
| 236 |
cout<<"Opening file: "<<file<<"..."<<endl;
|
| 237 |
ifstream toread (file);
|
| 238 |
if(!toread.is_open()) {
|
| 239 |
cerr<<"File "<<file<<" not found!!"<<endl;
|
| 240 |
//goto END;
|
| 241 |
}
|
| 242 |
else {
|
| 243 |
cout<<"File opened..."<<endl;
|
| 244 |
}
|
| 245 |
|
| 246 |
// build the working point variable
|
| 247 |
char wpB [20];
|
| 248 |
char wpE [20];
|
| 249 |
sprintf(wpB,"B%d",workingPoint);
|
| 250 |
sprintf(wpE,"E%d",workingPoint);
|
| 251 |
|
| 252 |
|
| 253 |
// read every line in the file
|
| 254 |
if(toread.is_open()) {
|
| 255 |
string line;
|
| 256 |
float value;
|
| 257 |
char name[100];
|
| 258 |
//cout<<"Reading working point input file"<<endl;
|
| 259 |
while(!toread.eof()) {
|
| 260 |
getline (toread, line);
|
| 261 |
|
| 262 |
if(line.substr(0,1)=="#") continue;
|
| 263 |
//cout<<line<<endl;
|
| 264 |
|
| 265 |
char wp[20];
|
| 266 |
float v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10;
|
| 267 |
sscanf (line.c_str(), "%s\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f", wp, &v0, &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9, &v10);
|
| 268 |
// barrel values
|
| 269 |
if(!strcmp(wp, wpB)) {
|
| 270 |
WorkingPointCuts.push_back(v0); // 0 see
|
| 271 |
WorkingPointCuts.push_back(v1); // 1 dphi
|
| 272 |
WorkingPointCuts.push_back(v2); // 2 deta
|
| 273 |
WorkingPointCuts.push_back(v3); // 3 hoe
|
| 274 |
WorkingPointCuts.push_back(v4); // 4 tkIso
|
| 275 |
WorkingPointCuts.push_back(v5); // 5 ecalIso
|
| 276 |
WorkingPointCuts.push_back(v6); // 6 hcalIso
|
| 277 |
WorkingPointCuts.push_back(v7); // 7 combIso
|
| 278 |
}
|
| 279 |
// endcap values
|
| 280 |
if(!strcmp(wp, wpE)) {
|
| 281 |
WorkingPointCuts.push_back(v0); // 8 see
|
| 282 |
WorkingPointCuts.push_back(v1); // 9 dphi
|
| 283 |
WorkingPointCuts.push_back(v2); // 10 deta
|
| 284 |
WorkingPointCuts.push_back(v3); // 11 hoe
|
| 285 |
WorkingPointCuts.push_back(v4); // 12 tkIso
|
| 286 |
WorkingPointCuts.push_back(v5); // 13 ecalIso
|
| 287 |
WorkingPointCuts.push_back(v6); // 14 hcalIso
|
| 288 |
WorkingPointCuts.push_back(v7); // 15 combIso
|
| 289 |
WorkingPointCuts.push_back(v8); // 16 hits
|
| 290 |
WorkingPointCuts.push_back(v9); // 17 dist
|
| 291 |
}
|
| 292 |
|
| 293 |
} // read line
|
| 294 |
} // read file
|
| 295 |
} // get working points
|
| 296 |
|
| 297 |
cout<<WorkingPointCuts[4]<<endl;
|
| 298 |
cout<<WorkingPointCuts[5]<<endl;
|
| 299 |
cout<<WorkingPointCuts[6]<<endl;
|
| 300 |
cout<<WorkingPointCuts[7]<<endl;
|
| 301 |
cout<<WorkingPointCuts[8]<<endl;
|
| 302 |
cout<<WorkingPointCuts[9]<<endl;
|
| 303 |
|
| 304 |
|
| 305 |
// Robust ID
|
| 306 |
|
| 307 |
// if(workingPoint==-1) {
|
| 308 |
// WorkingPointCuts.push_back(Rob_SigmaIetaIeta_B);
|
| 309 |
// WorkingPointCuts.push_back(Rob_deltaPhi_B);
|
| 310 |
// WorkingPointCuts.push_back(Rob_deltaEta_B);
|
| 311 |
// WorkingPointCuts.push_back(Rob_HoverE_B);
|
| 312 |
// WorkingPointCuts.push_back(Rob_trkIso_B);
|
| 313 |
// WorkingPointCuts.push_back(Rob_ecalIso_B);
|
| 314 |
// WorkingPointCuts.push_back(Rob_hcalIso_B);
|
| 315 |
// WorkingPointCuts.push_back(Rob_missingHits_B);
|
| 316 |
// WorkingPointCuts.push_back(Rob_SigmaIetaIeta_E);
|
| 317 |
// WorkingPointCuts.push_back(Rob_deltaPhi_E);
|
| 318 |
// WorkingPointCuts.push_back(Rob_deltaEta_E);
|
| 319 |
// WorkingPointCuts.push_back(Rob_HoverE_E);
|
| 320 |
// WorkingPointCuts.push_back(Rob_trkIso_E);
|
| 321 |
// WorkingPointCuts.push_back(Rob_ecalIso_E);
|
| 322 |
// WorkingPointCuts.push_back(Rob_hcalIso_E);
|
| 323 |
// WorkingPointCuts.push_back(Rob_missingHits_E);
|
| 324 |
// WorkingPointCuts.push_back(Rob_dist_E);
|
| 325 |
// WorkingPointCuts.push_back(Rob_cot_E);
|
| 326 |
// }
|
| 327 |
|
| 328 |
// if(workingPoint>0) {
|
| 329 |
// Rob_SigmaIetaIeta_B=WorkingPointCuts[0];
|
| 330 |
// Rob_deltaPhi_B=WorkingPointCuts[1];
|
| 331 |
// Rob_deltaEta_B=WorkingPointCuts[2];
|
| 332 |
// Rob_HoverE_B=WorkingPointCuts[3];
|
| 333 |
// Rob_trkIso_B=WorkingPointCuts[4];
|
| 334 |
// Rob_ecalIso_B=WorkingPointCuts[5];
|
| 335 |
// Rob_hcalIso_B=WorkingPointCuts[6];
|
| 336 |
// Rob_combIso_B=WorkingPointCuts[7];
|
| 337 |
// Rob_missingHits_B=WorkingPointCuts[16];
|
| 338 |
|
| 339 |
// Rob_SigmaIetaIeta_E=WorkingPointCuts[8];
|
| 340 |
// Rob_deltaPhi_E=WorkingPointCuts[9];
|
| 341 |
// Rob_deltaEta_E=WorkingPointCuts[10];
|
| 342 |
// Rob_HoverE_E=WorkingPointCuts[11];
|
| 343 |
// Rob_trkIso_E=WorkingPointCuts[12];
|
| 344 |
// Rob_ecalIso_E=WorkingPointCuts[13];
|
| 345 |
// Rob_hcalIso_E=WorkingPointCuts[14];
|
| 346 |
// Rob_combIso_E=WorkingPointCuts[15];
|
| 347 |
// Rob_missingHits_E=WorkingPointCuts[16];
|
| 348 |
// Rob_dist_E=WorkingPointCuts[17];
|
| 349 |
// Rob_cot_E=WorkingPointCuts[17];
|
| 350 |
// }
|
| 351 |
|
| 352 |
cout<<"Running the analysis with working point "<<workingPoint<<endl;
|
| 353 |
cout<<"Value for barrel / endcap"<<endl;
|
| 354 |
char *cutName[8] = {"sigmaIetaIeta", "delta phi at vtx", "delta eta at vtx", "H/E", "trkIso", "ecalIso", "hcalIso", "# inner hits"};
|
| 355 |
for(int i=0; i< 8;i++) {
|
| 356 |
cout<<cutName[i]<<" < "<<WorkingPointCuts[i]<<" / "<<WorkingPointCuts[8+i]<<endl;
|
| 357 |
}
|
| 358 |
|
| 359 |
// --------------------------------------------------------------------------------------------------------------------
|
| 360 |
|
| 361 |
|
| 362 |
// --------------------------------------------------------------------------------------------------------------------
|
| 363 |
// define some counters
|
| 364 |
// --------------------------------------------------------------------------------------------------------------------
|
| 365 |
int c_robust_B=0;
|
| 366 |
int c_robust_E=0;
|
| 367 |
int c_robust_tree=0;
|
| 368 |
int c_eth_1=0;
|
| 369 |
int c_eth_2=0;
|
| 370 |
int counterTight=0;
|
| 371 |
int counterETH=0;
|
| 372 |
|
| 373 |
// --------------------------------------------------------------------------------------------------------------------
|
| 374 |
|
| 375 |
|
| 376 |
|
| 377 |
// --------------------------------------------------------------------------------------------------------------------
|
| 378 |
// --------------------------------------------------------------------------------------------------------------------
|
| 379 |
// double lumi=6710;
|
| 380 |
// double xsec=235500000.0;
|
| 381 |
// --------------------------------------------------------------------------------------------------------------------
|
| 382 |
|
| 383 |
|
| 384 |
|
| 385 |
|
| 386 |
// --------------------------------------------------------------------------------------------------------------------
|
| 387 |
// choose which cut should be applied
|
| 388 |
// this is only used for the sequential plots
|
| 389 |
// --------------------------------------------------------------------------------------------------------------------
|
| 390 |
bool applyCut [] = {true, // 0: not used...
|
| 391 |
true, // 1: Preselection, H/E
|
| 392 |
true, // 2: Preselection, delta phi
|
| 393 |
true, // 3: Preselection, delta eta
|
| 394 |
true, // 4: Preselection, pt
|
| 395 |
true, // 5: Trigger
|
| 396 |
true, // 6: ETH Barrel only (flag can not be changed, cut is always applyed)
|
| 397 |
true, // 7: ETH Barrel, ECAL driven
|
| 398 |
true, // 8: ETH Barrel, |1/E-1/p|
|
| 399 |
true, // 9: ETH Barrel, delta eta
|
| 400 |
true, //10: ETH Barrel, delta phi
|
| 401 |
true, //11: ETH Barrel, isolation
|
| 402 |
true, //12: ETH Barrel, conversions
|
| 403 |
true, //13: not used... (ETH Endcap)
|
| 404 |
true, //14: ETH Endcap, ECAL driven
|
| 405 |
true, //15: ETH Endcap, |1/E-1/p|
|
| 406 |
true, //16: ETH Endcap, delta eta
|
| 407 |
true, //17: ETH Endcap, delta phi
|
| 408 |
true, //18: ETH Endcap, isolation
|
| 409 |
true, //19: ETH Endcap, conversions
|
| 410 |
// true, //20: Robust Barrel,
|
| 411 |
// true, //21: Robust Barrel, H/E
|
| 412 |
// true, //22: Robust Barrel, sigma ieta ieta
|
| 413 |
// true, //23: Robust Barrel, delta phi
|
| 414 |
// true, //24: Robust Barrel, delta eta
|
| 415 |
// true, //25: Robust Barrel, track iso
|
| 416 |
// true, //26: Robust Barrel, ecal iso
|
| 417 |
// true, //27: Robust Barrel, hcal iso
|
| 418 |
// true, //28: Robust Barrel, conversions
|
| 419 |
// true, //29: Robust Endcap,
|
| 420 |
// true, //30: Robust Endcap, H/E
|
| 421 |
// true, //31: Robust Endcap, sigma ieta ieta
|
| 422 |
// true, //32: Robust Endcap, delta phi
|
| 423 |
// true, //33: Robust Endcap, delta eta
|
| 424 |
// true, //34: Robust Endcap, track iso
|
| 425 |
// true, //35: Robust Endcap, ecal iso
|
| 426 |
// true, //36: Robust Endcap, hcal iso
|
| 427 |
// true //37: Robust Endcap, conversions
|
| 428 |
};
|
| 429 |
|
| 430 |
//}
|
| 431 |
|
| 432 |
// --------------------------------------------------------------------------------------------------------------------
|
| 433 |
|
| 434 |
// --------------------------------------------------------------------------------------------------------------------
|
| 435 |
// number of events
|
| 436 |
// this histogram is filled for normalization purposes i.e. to keep track of the MC sample sizes
|
| 437 |
// --------------------------------------------------------------------------------------------------------------------
|
| 438 |
TH1I *h_numberOfEvents;
|
| 439 |
h_numberOfEvents=new TH1I("numberOfEvents", "numberOfEvents", 1, -0.01, 1.01);
|
| 440 |
// --------------------------------------------------------------------------------------------------------------------
|
| 441 |
|
| 442 |
|
| 443 |
|
| 444 |
// --------------------------------------------------------------------------------------------------------------------
|
| 445 |
// Electron plots
|
| 446 |
// --------------------------------------------------------------------------------------------------------------------
|
| 447 |
char name [50];
|
| 448 |
int nbins=12;
|
| 449 |
double start=0.;
|
| 450 |
double end=120.;
|
| 451 |
TH1D *hs_El_ElPt[MAXE];
|
| 452 |
TH1D *hs_El_ElEta[MAXE];
|
| 453 |
TH1D *hs_El_ElPhi[MAXE];
|
| 454 |
TH1D *hs_El_ElDeltaPhi[MAXE];
|
| 455 |
TH1D *hs_El_ElDeltaEta[MAXE];
|
| 456 |
TH1D *hs_El_ElOneOverEminusOneOverP[MAXE];
|
| 457 |
TH1D *hs_El_ElMet[MAXE];
|
| 458 |
TH1D *hs_El_ElTransMass[MAXE];
|
| 459 |
TH1D *hs_El_ElCharge[MAXE];
|
| 460 |
TH1D *hs_El_Njets[MAXE];
|
| 461 |
TH1D *hs_El_ElEthIso[MAXE];
|
| 462 |
TH1D *hs_El_ElTrkIso[MAXE];
|
| 463 |
TH1D *hs_El_ElEcalIso[MAXE];
|
| 464 |
TH1D *hs_El_ElHcalIso[MAXE];
|
| 465 |
TH1D *hs_El_ElCombIso[MAXE];
|
| 466 |
TH1D *hs_El_ElHoverE[MAXE];
|
| 467 |
TH1D *hs_El_ElSigmaIetaIeta[MAXE];
|
| 468 |
TH1D *hs_El_ElNumberOfMissingInnerHits[MAXE];
|
| 469 |
for(int i=0; i<MAXE; i++) {
|
| 470 |
sprintf(name,"s_El_ElPt_%d",i);
|
| 471 |
hs_El_ElPt[i]=new TH1D(name, name, nbins, start, end);
|
| 472 |
hs_El_ElPt[i]->SetXTitle("p_{T} [GeV]");
|
| 473 |
hs_El_ElPt[i]->SetYTitle("events / bin");
|
| 474 |
sprintf(name,"s_El_ElEta_%d",i);
|
| 475 |
hs_El_ElEta[i]=new TH1D(name, name, 10, -2.5, 2.5);
|
| 476 |
hs_El_ElEta[i]->SetXTitle("#eta");
|
| 477 |
hs_El_ElEta[i]->SetYTitle("events / bin");
|
| 478 |
sprintf(name,"s_El_ElPhi_%d",i);
|
| 479 |
hs_El_ElPhi[i]=new TH1D(name, name, 15, -Pi,Pi);
|
| 480 |
hs_El_ElPhi[i]->SetXTitle("#phi");
|
| 481 |
hs_El_ElPhi[i]->SetYTitle("events / bin");
|
| 482 |
sprintf(name,"s_El_ElDeltaPhi_%d",i);
|
| 483 |
hs_El_ElDeltaPhi[i]=new TH1D(name, name, 30, -0.05001, 0.05001);
|
| 484 |
hs_El_ElDeltaPhi[i]->SetXTitle("#Delta #phi");
|
| 485 |
hs_El_ElDeltaPhi[i]->SetYTitle("events / bin");
|
| 486 |
sprintf(name,"s_El_ElDeltaEta_%d",i);
|
| 487 |
hs_El_ElDeltaEta[i]=new TH1D(name, name, 30, -0.05001, 0.05001);
|
| 488 |
hs_El_ElDeltaEta[i]->SetXTitle("#Delta #eta");
|
| 489 |
hs_El_ElDeltaEta[i]->SetYTitle("events / bin");
|
| 490 |
sprintf(name,"s_El_ElMet_%d",i);
|
| 491 |
hs_El_ElMet[i]=new TH1D(name, name, nbins, start, end);
|
| 492 |
hs_El_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
|
| 493 |
hs_El_ElMet[i]->SetYTitle("events / bin");
|
| 494 |
sprintf(name,"s_El_ElTransMass_%d",i);
|
| 495 |
hs_El_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
|
| 496 |
hs_El_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
|
| 497 |
hs_El_ElTransMass[i]->SetYTitle("events / bin");
|
| 498 |
sprintf(name,"s_El_ElCharge_%d",i);
|
| 499 |
hs_El_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
|
| 500 |
hs_El_ElCharge[i]->SetXTitle("Charge");
|
| 501 |
hs_El_ElCharge[i]->SetYTitle("events / bin");
|
| 502 |
sprintf(name,"s_El_Njets_%d",i);
|
| 503 |
hs_El_Njets[i]=new TH1D(name, name, 10, 0, 10);
|
| 504 |
hs_El_Njets[i]->SetXTitle("number of jets");
|
| 505 |
hs_El_Njets[i]->SetYTitle("events / bin");
|
| 506 |
sprintf(name,"s_El_ElOneOverEminusOneOverP_%d",i);
|
| 507 |
hs_El_ElOneOverEminusOneOverP[i]=new TH1D(name, name, 30, -0.01, 0.5);
|
| 508 |
hs_El_ElOneOverEminusOneOverP[i]->SetXTitle("|1/E-1/p|");
|
| 509 |
hs_El_ElOneOverEminusOneOverP[i]->SetYTitle("events / bin");
|
| 510 |
sprintf(name,"s_El_ElEthIso_%d",i);
|
| 511 |
// hs_El_ElEthIso[i]=new TH1D(name, name, 50, -0.01, 5.);
|
| 512 |
hs_El_ElEthIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
|
| 513 |
hs_El_ElEthIso[i]->SetXTitle("ETH Iso");
|
| 514 |
hs_El_ElEthIso[i]->SetYTitle("events / bin");
|
| 515 |
sprintf(name,"s_El_ElTrkIso_%d",i);
|
| 516 |
// hs_El_ElTrkIso[i]=new TH1D(name, name, 100, -0.01, 50.);
|
| 517 |
hs_El_ElTrkIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
|
| 518 |
hs_El_ElTrkIso[i]->SetXTitle("Trk Iso");
|
| 519 |
hs_El_ElTrkIso[i]->SetYTitle("events / bin");
|
| 520 |
sprintf(name,"s_El_ElEcalIso_%d",i);
|
| 521 |
hs_El_ElEcalIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
|
| 522 |
// hs_El_ElEcalIso[i]=new TH1D(name, name, 40, -0.01, 20.);
|
| 523 |
hs_El_ElEcalIso[i]->SetXTitle("ECAL Iso");
|
| 524 |
hs_El_ElEcalIso[i]->SetYTitle("events / bin");
|
| 525 |
sprintf(name,"s_El_ElHcalIso_%d",i);
|
| 526 |
hs_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 10.);
|
| 527 |
hs_El_ElHcalIso[i]->SetXTitle("HCAL Iso");
|
| 528 |
hs_El_ElHcalIso[i]->SetYTitle("events / bin");
|
| 529 |
|
| 530 |
sprintf(name,"s_El_ElCombIso_%d",i);
|
| 531 |
hs_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 3.1);
|
| 532 |
hs_El_ElCombIso[i]->SetXTitle("Combined Iso");
|
| 533 |
hs_El_ElCombIso[i]->SetYTitle("events / bin");
|
| 534 |
|
| 535 |
sprintf(name,"s_El_ElHoverE_%d",i);
|
| 536 |
hs_El_ElHoverE[i]=new TH1D(name, name, 30, -0.01, 0.5);
|
| 537 |
hs_El_ElHoverE[i]->SetXTitle("H/E");
|
| 538 |
hs_El_ElHoverE[i]->SetYTitle("events / bin");
|
| 539 |
sprintf(name,"s_El_ElSigmaIetaIeta_%d",i);
|
| 540 |
hs_El_ElSigmaIetaIeta[i]=new TH1D(name, name, 50, -0.01, 0.08);
|
| 541 |
hs_El_ElSigmaIetaIeta[i]->SetXTitle("#sigma_{i#eta i#eta}");
|
| 542 |
hs_El_ElSigmaIetaIeta[i]->SetYTitle("events / bin");
|
| 543 |
sprintf(name,"s_El_ElNumberOfMissingInnerHits_%d",i);
|
| 544 |
hs_El_ElNumberOfMissingInnerHits[i]=new TH1D(name, name, 10, 0., 10.);
|
| 545 |
hs_El_ElNumberOfMissingInnerHits[i]->SetXTitle("Number of missing inner hits");
|
| 546 |
hs_El_ElNumberOfMissingInnerHits[i]->SetYTitle("events / bin");
|
| 547 |
}
|
| 548 |
|
| 549 |
TH1D *hc_El_counter;
|
| 550 |
hc_El_counter=new TH1D("c_El_counter", "c_El_counter",15, 0, 15);
|
| 551 |
hc_El_counter->GetXaxis()->SetBinLabel(1,"# e preselection");
|
| 552 |
hc_El_counter->GetXaxis()->SetBinLabel(2,"# e presel, barrel");
|
| 553 |
hc_El_counter->GetXaxis()->SetBinLabel(3,"# e see");
|
| 554 |
hc_El_counter->GetXaxis()->SetBinLabel(4,"# e dphi");
|
| 555 |
hc_El_counter->GetXaxis()->SetBinLabel(5,"# e deta");
|
| 556 |
hc_El_counter->GetXaxis()->SetBinLabel(6,"# e hoe");
|
| 557 |
hc_El_counter->GetXaxis()->SetBinLabel(7,"# e combIso");
|
| 558 |
hc_El_counter->GetXaxis()->SetBinLabel(8,"# e conversion");
|
| 559 |
hc_El_counter->GetXaxis()->SetBinLabel(9,"# e presel, endcap");
|
| 560 |
hc_El_counter->GetXaxis()->SetBinLabel(10,"# e see");
|
| 561 |
hc_El_counter->GetXaxis()->SetBinLabel(11,"# e dphi");
|
| 562 |
hc_El_counter->GetXaxis()->SetBinLabel(12,"# e deta");
|
| 563 |
hc_El_counter->GetXaxis()->SetBinLabel(13,"# e hoe");
|
| 564 |
hc_El_counter->GetXaxis()->SetBinLabel(14,"# e combIso");
|
| 565 |
hc_El_counter->GetXaxis()->SetBinLabel(15,"# e conversion");
|
| 566 |
|
| 567 |
// acceptance plots
|
| 568 |
TH2D *h_ElEtaVsScEta;
|
| 569 |
h_ElEtaVsScEta = new TH2D("ElEtaVsScEta", "h_ElEtaVsScEta", 10, -2.5, 2.5, 10, -2.5, 2.5);
|
| 570 |
// TH2D *h_ElPhiVsScPhi;
|
| 571 |
// h_ElPhiVsScPhi = new TH2D("ElPhiVsScPhi", "h_ElPhiVsScPhi", 10, -Pi, Pi, 10, -Pi, Pi);
|
| 572 |
TH2D *h_ElPtVsScEt;
|
| 573 |
h_ElPtVsScEt = new TH2D("ElPtVsScEt", "ElPtVsScEt", 20, 0, 200, 20, 0, 200);
|
| 574 |
|
| 575 |
|
| 576 |
|
| 577 |
// --------------------------------------------------------------------------------------------------------------------
|
| 578 |
|
| 579 |
|
| 580 |
|
| 581 |
// --------------------------------------------------------------------------------------------------------------------
|
| 582 |
// Electron ID N-1 plots
|
| 583 |
// --------------------------------------------------------------------------------------------------------------------
|
| 584 |
int MAXN=4;
|
| 585 |
TH1D *hn1_El_ElDeltaPhi[MAXN];
|
| 586 |
TH1D *hn1_El_ElDeltaEta[MAXN];
|
| 587 |
TH1D *hn1_El_ElOneOverEminusOneOverP[MAXN];
|
| 588 |
// TH1D *hn1_El_ElPt[MAXN];
|
| 589 |
// TH1D *hn1_El_ElEta[MAXN];
|
| 590 |
// TH1D *hn1_El_ElPhi[MAXN];
|
| 591 |
// TH1D *hn1_El_ElMet[MAXN];
|
| 592 |
// TH1D *hn1_El_ElTransMass[MAXN];
|
| 593 |
// TH1D *hn1_El_ElCharge[MAXN];
|
| 594 |
// TH1D *hn1_El_Njets[MAXN];
|
| 595 |
TH1D *hn1_El_ElEthIso[MAXN];
|
| 596 |
// TH1D *hn1_El_ElTrkIso[MAXN];
|
| 597 |
// TH1D *hn1_El_ElEcalIso[MAXN];
|
| 598 |
// TH1D *hn1_El_ElHcalIso[MAXN];
|
| 599 |
TH1D *hn1_El_ElCombIso[MAXN];
|
| 600 |
TH1D *hn1_El_ElHoverE[MAXN];
|
| 601 |
TH1D *hn1_El_ElSigmaIetaIeta[MAXN];
|
| 602 |
TH1D *hn1_El_ElNumberOfMissingInnerHits[MAXN];
|
| 603 |
|
| 604 |
|
| 605 |
for(int i=0; i<MAXN;i++) {
|
| 606 |
sprintf(name,"n1_El_ElDeltaPhi_%d",i);
|
| 607 |
hn1_El_ElDeltaPhi[i]=new TH1D(name, name, 30, -0.05001, 0.05001); // plotting absolut value
|
| 608 |
// hn1_El_ElDeltaPhi[i]=new TH1D(name, name, 15, -0.05001, 0.05001); // plotting real value
|
| 609 |
hn1_El_ElDeltaPhi[i]->SetXTitle("#Delta #phi");
|
| 610 |
hn1_El_ElDeltaPhi[i]->SetYTitle("events / bin");
|
| 611 |
sprintf(name,"n1_El_ElDeltaEta_%d",i);
|
| 612 |
hn1_El_ElDeltaEta[i]=new TH1D(name, name, 30, -0.02001, 0.02001); // plotting absolut value
|
| 613 |
// hn1_El_ElDeltaEta[i]=new TH1D(name, name, 15, -0.05001, 0.05001); // plotting real value
|
| 614 |
hn1_El_ElDeltaEta[i]->SetXTitle("#Delta #eta");
|
| 615 |
hn1_El_ElDeltaEta[i]->SetYTitle("events / bin");
|
| 616 |
sprintf(name,"n1_El_ElOneOverEminusOneOverP_%d",i);
|
| 617 |
hn1_El_ElOneOverEminusOneOverP[i]=new TH1D(name, name, 15, -0.0001, 0.05001);
|
| 618 |
hn1_El_ElOneOverEminusOneOverP[i]->SetXTitle("|1/E-1/p|");
|
| 619 |
hn1_El_ElOneOverEminusOneOverP[i]->SetYTitle("events / bin");
|
| 620 |
sprintf(name,"n1_El_ElEthIso_%d",i);
|
| 621 |
hn1_El_ElEthIso[i]=new TH1D(name, name, 50, -0.01, 5.);
|
| 622 |
hn1_El_ElEthIso[i]->SetXTitle("Isolation");
|
| 623 |
hn1_El_ElEthIso[i]->SetYTitle("events / bin");
|
| 624 |
|
| 625 |
|
| 626 |
// sprintf(name,"n1_El_ElPt_%d",i);
|
| 627 |
// hn1_El_ElPt[i]=new TH1D(name, name, nbins, start, end);
|
| 628 |
// hn1_El_ElPt[i]->SetXTitle("p_{T} [GeV]");
|
| 629 |
// hn1_El_ElPt[i]->SetYTitle("events / bin");
|
| 630 |
// sprintf(name,"n1_El_ElEta_%d",i);
|
| 631 |
// hn1_El_ElEta[i]=new TH1D(name, name, 30, -5., 5.);
|
| 632 |
// hn1_El_ElEta[i]->SetXTitle("#eta");
|
| 633 |
// hn1_El_ElEta[i]->SetYTitle("events / bin");
|
| 634 |
// sprintf(name,"n1_El_ElPhi_%d",i);
|
| 635 |
// hn1_El_ElPhi[i]=new TH1D(name, name, 30, -Pi,Pi);
|
| 636 |
// hn1_El_ElPhi[i]->SetXTitle("#phi");
|
| 637 |
// hn1_El_ElPhi[i]->SetYTitle("events / bin");
|
| 638 |
// sprintf(name,"n1_El_ElMet_%d",i);
|
| 639 |
// hn1_El_ElMet[i]=new TH1D(name, name, nbins, start, end);
|
| 640 |
// hn1_El_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
|
| 641 |
// hn1_El_ElMet[i]->SetYTitle("events / bin");
|
| 642 |
// sprintf(name,"n1_El_ElTransMass_%d",i);
|
| 643 |
// hn1_El_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
|
| 644 |
// hn1_El_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
|
| 645 |
// hn1_El_ElTransMass[i]->SetYTitle("events / bin");
|
| 646 |
// sprintf(name,"n1_El_ElCharge_%d",i);
|
| 647 |
// hn1_El_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
|
| 648 |
// hn1_El_ElCharge[i]->SetXTitle("Charge");
|
| 649 |
// hn1_El_ElCharge[i]->SetYTitle("events / bin");
|
| 650 |
// sprintf(name,"n1_El_Njets_%d",i);
|
| 651 |
// hn1_El_Njets[i]=new TH1D(name, name, 10, 0, 10);
|
| 652 |
// hn1_El_Njets[i]->SetXTitle("number of jets");
|
| 653 |
// hn1_El_Njets[i]->SetYTitle("events / bin");
|
| 654 |
|
| 655 |
// sprintf(name,"n1_El_ElTrkIso_%d",i);
|
| 656 |
// // sprintf(name,"n1_El_ElTrkIso_%d",i);
|
| 657 |
// hn1_El_ElTrkIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
|
| 658 |
// hn1_El_ElTrkIso[i]->SetXTitle("Trk Iso");
|
| 659 |
// hn1_El_ElTrkIso[i]->SetYTitle("events / bin");
|
| 660 |
// sprintf(name,"n1_El_ElEcalIso_%d",i);
|
| 661 |
// hn1_El_ElEcalIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
|
| 662 |
// // hn1_El_ElEcalIso[i]=new TH1D(name, name, 40, -0.01, 20.);
|
| 663 |
// hn1_El_ElEcalIso[i]->SetXTitle("ECAL Iso");
|
| 664 |
// hn1_El_ElEcalIso[i]->SetYTitle("events / bin");
|
| 665 |
// sprintf(name,"n1_El_ElHcalIso_%d",i);
|
| 666 |
// hn1_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
|
| 667 |
// // hn1_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 10.);
|
| 668 |
// hn1_El_ElHcalIso[i]->SetXTitle("HCAL Iso");
|
| 669 |
// hn1_El_ElHcalIso[i]->SetYTitle("events / bin");
|
| 670 |
|
| 671 |
sprintf(name,"n1_El_ElCombIso_%d",i);
|
| 672 |
hn1_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 0.5);
|
| 673 |
// hn1_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 10.);
|
| 674 |
hn1_El_ElCombIso[i]->SetXTitle("Combined Iso");
|
| 675 |
hn1_El_ElCombIso[i]->SetYTitle("events / bin");
|
| 676 |
|
| 677 |
sprintf(name,"n1_El_ElHoverE_%d",i);
|
| 678 |
hn1_El_ElHoverE[i]=new TH1D(name, name, 30, -0.01, 0.2);
|
| 679 |
hn1_El_ElHoverE[i]->SetXTitle("H/E");
|
| 680 |
hn1_El_ElHoverE[i]->SetYTitle("events / bin");
|
| 681 |
sprintf(name,"n1_El_ElSigmaIetaIeta_%d",i);
|
| 682 |
hn1_El_ElSigmaIetaIeta[i]=new TH1D(name, name, 50, -0.01, 0.08);
|
| 683 |
hn1_El_ElSigmaIetaIeta[i]->SetXTitle("#sigma_{i#eta i#eta}");
|
| 684 |
hn1_El_ElSigmaIetaIeta[i]->SetYTitle("events / bin");
|
| 685 |
sprintf(name,"n1_El_ElNumberOfMissingInnerHits_%d",i);
|
| 686 |
hn1_El_ElNumberOfMissingInnerHits[i]=new TH1D(name, name, 10, 0., 10.);
|
| 687 |
hn1_El_ElNumberOfMissingInnerHits[i]->SetXTitle("Number of missing inner hits");
|
| 688 |
hn1_El_ElNumberOfMissingInnerHits[i]->SetYTitle("events / bin");
|
| 689 |
|
| 690 |
|
| 691 |
}
|
| 692 |
|
| 693 |
// --------------------------------------------------------------------------------------------------------------------
|
| 694 |
|
| 695 |
|
| 696 |
|
| 697 |
|
| 698 |
// --------------------------------------------------------------------------------------------------------------------
|
| 699 |
// W Selection plots
|
| 700 |
// --------------------------------------------------------------------------------------------------------------------
|
| 701 |
int MAXS=29;
|
| 702 |
// char name [50];
|
| 703 |
// int nbins=20;
|
| 704 |
// double start=0.;
|
| 705 |
// double end=120.;
|
| 706 |
TH1D *hs_W_ElPt[MAXS];
|
| 707 |
TH1D *hs_W_ElEta[MAXS];
|
| 708 |
TH1D *hs_W_ElPhi[MAXS];
|
| 709 |
TH1D *hs_W_ElDeltaPhi[MAXS];
|
| 710 |
TH1D *hs_W_ElMet[MAXS];
|
| 711 |
TH1D *hs_W_ElTransMass[MAXS];
|
| 712 |
TH1D *hs_W_ElCharge[MAXS];
|
| 713 |
TH1D *hs_W_Njets[MAXS];
|
| 714 |
for(int i=0; i<MAXS; i++) {
|
| 715 |
sprintf(name,"s_W_ElPt_%d",i);
|
| 716 |
hs_W_ElPt[i]=new TH1D(name, name, nbins, start, end);
|
| 717 |
hs_W_ElPt[i]->SetXTitle("p_{T} [GeV]");
|
| 718 |
hs_W_ElPt[i]->SetYTitle("events / bin");
|
| 719 |
sprintf(name,"s_W_ElEta_%d",i);
|
| 720 |
hs_W_ElEta[i]=new TH1D(name, name, 30, -5., 5.);
|
| 721 |
hs_W_ElEta[i]->SetXTitle("#eta");
|
| 722 |
hs_W_ElEta[i]->SetYTitle("events / bin");
|
| 723 |
sprintf(name,"s_W_ElPhi_%d",i);
|
| 724 |
hs_W_ElPhi[i]=new TH1D(name, name, 30, -Pi,Pi);
|
| 725 |
hs_W_ElPhi[i]->SetXTitle("#phi");
|
| 726 |
hs_W_ElPhi[i]->SetYTitle("events / bin");
|
| 727 |
sprintf(name,"s_W_ElDeltaPhi_%d",i);
|
| 728 |
hs_W_ElDeltaPhi[i]=new TH1D(name, name, 15, 0., Pi);
|
| 729 |
hs_W_ElDeltaPhi[i]->SetXTitle("#Delta #phi_{e,#slash{E}_{T}}");
|
| 730 |
hs_W_ElDeltaPhi[i]->SetYTitle("events / bin");
|
| 731 |
sprintf(name,"s_W_ElMet_%d",i);
|
| 732 |
hs_W_ElMet[i]=new TH1D(name, name, nbins, start, end);
|
| 733 |
hs_W_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
|
| 734 |
hs_W_ElMet[i]->SetYTitle("events / bin");
|
| 735 |
sprintf(name,"s_W_ElTransMass_%d",i);
|
| 736 |
hs_W_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
|
| 737 |
hs_W_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
|
| 738 |
hs_W_ElTransMass[i]->SetYTitle("events / bin");
|
| 739 |
sprintf(name,"s_W_ElCharge_%d",i);
|
| 740 |
hs_W_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
|
| 741 |
hs_W_ElCharge[i]->SetXTitle("Charge");
|
| 742 |
hs_W_ElCharge[i]->SetYTitle("events / bin");
|
| 743 |
sprintf(name,"s_W_Njets_%d",i);
|
| 744 |
hs_W_Njets[i]=new TH1D(name, name, 10, 0, 10);
|
| 745 |
hs_W_Njets[i]->SetXTitle("number of jets");
|
| 746 |
hs_W_Njets[i]->SetYTitle("events / bin");
|
| 747 |
}
|
| 748 |
|
| 749 |
int MAXWcounter=16;
|
| 750 |
int *Wcounter = new int[MAXWcounter];
|
| 751 |
memset(Wcounter,0,MAXWcounter*sizeof(int));
|
| 752 |
|
| 753 |
|
| 754 |
TH1D *hc_W_counter;
|
| 755 |
hc_W_counter=new TH1D("c_W_counter", "c_W_counter",16, 0, 16 );
|
| 756 |
hc_W_counter->GetXaxis()->SetBinLabel(1,"# e, N jets, Preselection");
|
| 757 |
hc_W_counter->GetXaxis()->SetBinLabel(2,"# W, N jets");
|
| 758 |
hc_W_counter->GetXaxis()->SetBinLabel(3,"# W+, N jets");
|
| 759 |
hc_W_counter->GetXaxis()->SetBinLabel(4,"# W-, N jets");
|
| 760 |
hc_W_counter->GetXaxis()->SetBinLabel(5,"# e, 0 jets, Preselection");
|
| 761 |
hc_W_counter->GetXaxis()->SetBinLabel(6,"# W, 0 jets");
|
| 762 |
hc_W_counter->GetXaxis()->SetBinLabel(7,"# W+, 0 jets");
|
| 763 |
hc_W_counter->GetXaxis()->SetBinLabel(8,"# W-, 0 jets");
|
| 764 |
hc_W_counter->GetXaxis()->SetBinLabel(9,"# e, 1 jet, Preselection");
|
| 765 |
hc_W_counter->GetXaxis()->SetBinLabel(10,"# W, 1 jet");
|
| 766 |
hc_W_counter->GetXaxis()->SetBinLabel(11,"# W+, 1 jet");
|
| 767 |
hc_W_counter->GetXaxis()->SetBinLabel(12,"# W-, 1 jet");
|
| 768 |
hc_W_counter->GetXaxis()->SetBinLabel(13,"# e, >1 jets, Preselection");
|
| 769 |
hc_W_counter->GetXaxis()->SetBinLabel(14,"# W, >1 jets");
|
| 770 |
hc_W_counter->GetXaxis()->SetBinLabel(15,"# W+, >1 jets");
|
| 771 |
hc_W_counter->GetXaxis()->SetBinLabel(16,"# W-, >1jets");
|
| 772 |
|
| 773 |
// --------------------------------------------------------------------------------------------------------------------
|
| 774 |
|
| 775 |
|
| 776 |
// --------------------------------------------------------------------------------------------------------------------
|
| 777 |
// Z plots
|
| 778 |
// --------------------------------------------------------------------------------------------------------------------
|
| 779 |
int MAXZ=4;
|
| 780 |
TH1D *h_Z_invMass[MAXZ];
|
| 781 |
TH1D *h_Z_ptAll[MAXZ];
|
| 782 |
TH1D *h_Z_etaAll[MAXZ];
|
| 783 |
TH1D *h_Z_phiAll[MAXZ];
|
| 784 |
TH1D *h_Z_deltaPhi[MAXZ];
|
| 785 |
TH1D *h_Z_ptDiLepton[MAXZ];
|
| 786 |
TH1D *h_Z_etaDiLepton[MAXZ];
|
| 787 |
TH1D *h_Z_phiDiLepton[MAXZ];
|
| 788 |
|
| 789 |
TH1D *h_Z_leadingJetPt[MAXZ];
|
| 790 |
TH1D *h_Z_summedJetPt[MAXZ];
|
| 791 |
TH1D *h_Z_leadingJetEta[MAXZ];
|
| 792 |
TH1D *h_Z_summedJetEta[MAXZ];
|
| 793 |
TH1D *h_Z_leadingJetPhi[MAXZ];
|
| 794 |
TH1D *h_Z_summedJetPhi[MAXZ];
|
| 795 |
TH1D *h_Z_nJets[MAXZ];
|
| 796 |
TH1D *h_Z_leadingJetDeltaPt[MAXZ];
|
| 797 |
TH1D *h_Z_leadingJetDeltaEta[MAXZ];
|
| 798 |
TH1D *h_Z_leadingJetDeltaPhi[MAXZ];
|
| 799 |
TH1D *h_Z_summedJetDeltaPt[MAXZ];
|
| 800 |
TH1D *h_Z_summedJetDeltaEta[MAXZ];
|
| 801 |
TH1D *h_Z_summedJetDeltaPhi[MAXZ];
|
| 802 |
TH1D *h_Z_recoilPt[MAXZ];
|
| 803 |
TH1D *h_Z_recoilEta[MAXZ];
|
| 804 |
TH1D *h_Z_recoilPhi[MAXZ];
|
| 805 |
TH1D *h_Z_metPt[MAXZ];
|
| 806 |
TH1D *h_Z_metEta[MAXZ];
|
| 807 |
TH1D *h_Z_metPhi[MAXZ];
|
| 808 |
|
| 809 |
|
| 810 |
|
| 811 |
for(int i=0; i<MAXZ; i++) {
|
| 812 |
sprintf(name,"h_Z_invMass_%d",i);
|
| 813 |
h_Z_invMass[i] = new TH1D(name,name,80,0,200);
|
| 814 |
h_Z_invMass[i]->SetXTitle("m_{ee} [GeV/c^{2}]");
|
| 815 |
h_Z_invMass[i]->SetYTitle("events / bin");
|
| 816 |
|
| 817 |
sprintf(name,"h_Z_ptAll_%d",i);
|
| 818 |
h_Z_ptAll[i] = new TH1D(name,name,20,0,200);
|
| 819 |
h_Z_ptAll[i]->SetXTitle("p_{T} [GeV]");
|
| 820 |
h_Z_ptAll[i]->SetYTitle("events / bin");
|
| 821 |
sprintf(name,"h_Z_etaAll_%d",i);
|
| 822 |
h_Z_etaAll[i] = new TH1D(name,name,12,-3.,3.);
|
| 823 |
h_Z_etaAll[i]->SetXTitle("#eta");
|
| 824 |
h_Z_etaAll[i]->SetYTitle("events / bin");
|
| 825 |
sprintf(name,"h_Z_phiAll_%d",i);
|
| 826 |
h_Z_phiAll[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 827 |
h_Z_phiAll[i]->SetXTitle("#phi");
|
| 828 |
h_Z_phiAll[i]->SetYTitle("events / bin");
|
| 829 |
sprintf(name,"h_Z_deltaPhi_%d",i);
|
| 830 |
h_Z_deltaPhi[i] = new TH1D(name,name,15,0,Pi);
|
| 831 |
h_Z_deltaPhi[i]->SetXTitle("#Delta #phi_{ee}");
|
| 832 |
h_Z_deltaPhi[i]->SetYTitle("events / bin");
|
| 833 |
|
| 834 |
sprintf(name,"h_Z_ptDiLepton_%d",i);
|
| 835 |
h_Z_ptDiLepton[i] = new TH1D(name,name,20,0,200);
|
| 836 |
h_Z_ptDiLepton[i]->SetXTitle("p_{T} [GeV]");
|
| 837 |
h_Z_ptDiLepton[i]->SetYTitle("events / bin");
|
| 838 |
sprintf(name,"h_Z_etaDiLepton_%d",i);
|
| 839 |
h_Z_etaDiLepton[i] = new TH1D(name,name,16,-8.,8.);
|
| 840 |
h_Z_etaDiLepton[i]->SetXTitle("#eta");
|
| 841 |
h_Z_etaDiLepton[i]->SetYTitle("events / bin");
|
| 842 |
sprintf(name,"h_Z_phiDiLepton_%d",i);
|
| 843 |
h_Z_phiDiLepton[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 844 |
h_Z_phiDiLepton[i]->SetXTitle("#phi");
|
| 845 |
h_Z_phiDiLepton[i]->SetYTitle("events / bin");
|
| 846 |
|
| 847 |
|
| 848 |
sprintf(name,"h_Z_leadingJetPt_%d",i);
|
| 849 |
h_Z_leadingJetPt[i] = new TH1D(name,name,20,0,200);
|
| 850 |
h_Z_leadingJetPt[i]->SetXTitle("p_{T} [GeV]");
|
| 851 |
h_Z_leadingJetPt[i]->SetYTitle("events / bin");
|
| 852 |
sprintf(name,"h_Z_summedJetPt_%d",i);
|
| 853 |
h_Z_summedJetPt[i] = new TH1D(name,name,20,0,200);
|
| 854 |
h_Z_summedJetPt[i]->SetXTitle("p_{T} [GeV]");
|
| 855 |
h_Z_summedJetPt[i]->SetYTitle("events / bin");
|
| 856 |
sprintf(name,"h_Z_leadingJetEta_%d",i);
|
| 857 |
h_Z_leadingJetEta[i] = new TH1D(name,name,12,-3,3);
|
| 858 |
h_Z_leadingJetEta[i]->SetXTitle("#eta");
|
| 859 |
h_Z_leadingJetEta[i]->SetYTitle("events / bin");
|
| 860 |
sprintf(name,"h_Z_summedJetEta_%d",i);
|
| 861 |
h_Z_summedJetEta[i] = new TH1D(name,name,16,-8,8);
|
| 862 |
h_Z_summedJetEta[i]->SetXTitle("#eta");
|
| 863 |
h_Z_summedJetEta[i]->SetYTitle("events / bin");
|
| 864 |
sprintf(name,"h_Z_leadingJetPhi_%d",i);
|
| 865 |
h_Z_leadingJetPhi[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 866 |
h_Z_leadingJetPhi[i]->SetXTitle("#phi");
|
| 867 |
h_Z_leadingJetPhi[i]->SetYTitle("events / bin");
|
| 868 |
sprintf(name,"h_Z_summedJetPhi_%d",i);
|
| 869 |
h_Z_summedJetPhi[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 870 |
h_Z_summedJetPhi[i]->SetXTitle("#phi");
|
| 871 |
h_Z_summedJetPhi[i]->SetYTitle("events / bin");
|
| 872 |
|
| 873 |
sprintf(name,"h_Z_nJets_%d",i);
|
| 874 |
h_Z_nJets[i] = new TH1D(name,name,11,0,11);
|
| 875 |
h_Z_nJets[i]->SetXTitle("jet number");
|
| 876 |
h_Z_nJets[i]->SetYTitle("events / bin");
|
| 877 |
|
| 878 |
sprintf(name,"h_Z_leadingJetDeltaPt_%d",i);
|
| 879 |
h_Z_leadingJetDeltaPt[i] = new TH1D(name,name,60,-150,150);
|
| 880 |
h_Z_leadingJetDeltaPt[i]->SetXTitle("#Delta p_{T,jZ} [GeV]");
|
| 881 |
h_Z_leadingJetDeltaPt[i]->SetYTitle("events / bin");
|
| 882 |
sprintf(name,"h_Z_leadingJetDeltaEta_%d",i);
|
| 883 |
h_Z_leadingJetDeltaEta[i] = new TH1D(name,name,16,-8,8);
|
| 884 |
h_Z_leadingJetDeltaEta[i]->SetXTitle("#Delta #eta_{jZ}");
|
| 885 |
h_Z_leadingJetDeltaEta[i]->SetYTitle("events / bin");
|
| 886 |
sprintf(name,"h_Z_leadingJetDeltaPhi_%d",i);
|
| 887 |
h_Z_leadingJetDeltaPhi[i] = new TH1D(name,name,15,0,Pi);
|
| 888 |
h_Z_leadingJetDeltaPhi[i]->SetXTitle("#Delta #phi_{jZ}");
|
| 889 |
h_Z_leadingJetDeltaPhi[i]->SetYTitle("events / bin");
|
| 890 |
|
| 891 |
sprintf(name,"h_Z_summedJetDeltaPt_%d",i);
|
| 892 |
h_Z_summedJetDeltaPt[i] = new TH1D(name,name,60,-150,150);
|
| 893 |
h_Z_summedJetDeltaPt[i]->SetXTitle("#Delta p_{T,jZ} [GeV]");
|
| 894 |
h_Z_summedJetDeltaPt[i]->SetYTitle("events / bin");
|
| 895 |
sprintf(name,"h_Z_summedJetDeltaEta_%d",i);
|
| 896 |
h_Z_summedJetDeltaEta[i] = new TH1D(name,name,16,-8,8);
|
| 897 |
h_Z_summedJetDeltaEta[i]->SetXTitle("#Delta #eta_{jZ}");
|
| 898 |
h_Z_summedJetDeltaEta[i]->SetYTitle("events / bin");
|
| 899 |
sprintf(name,"h_Z_summedJetDeltaPhi_%d",i);
|
| 900 |
h_Z_summedJetDeltaPhi[i] = new TH1D(name,name,15,0,Pi);
|
| 901 |
h_Z_summedJetDeltaPhi[i]->SetXTitle("#Delta #phi_{jZ}");
|
| 902 |
h_Z_summedJetDeltaPhi[i]->SetYTitle("events / bin");
|
| 903 |
|
| 904 |
sprintf(name,"h_Z_recoilPt_%d",i);
|
| 905 |
h_Z_recoilPt[i] = new TH1D(name,name,20,0,200);
|
| 906 |
h_Z_recoilPt[i]->SetXTitle("p_{T,j+Z} [GeV]");
|
| 907 |
h_Z_recoilPt[i]->SetYTitle("events / bin");
|
| 908 |
sprintf(name,"h_Z_recoilEta_%d",i);
|
| 909 |
h_Z_recoilEta[i] = new TH1D(name,name,16,-8,8);
|
| 910 |
h_Z_recoilEta[i]->SetXTitle("#eta_{j+Z}");
|
| 911 |
h_Z_recoilEta[i]->SetYTitle("events / bin");
|
| 912 |
sprintf(name,"h_Z_recoilPhi_%d",i);
|
| 913 |
h_Z_recoilPhi[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 914 |
h_Z_recoilPhi[i]->SetXTitle("#phi_{j+Z}");
|
| 915 |
h_Z_recoilPhi[i]->SetYTitle("events / bin");
|
| 916 |
|
| 917 |
sprintf(name,"h_Z_metPt_%d",i);
|
| 918 |
h_Z_metPt[i] = new TH1D(name,name,20,0,200);
|
| 919 |
h_Z_metPt[i]->SetXTitle("#slash{p}_{T} [GeV]");
|
| 920 |
h_Z_metPt[i]->SetYTitle("events / bin");
|
| 921 |
sprintf(name,"h_Z_metEta_%d",i);
|
| 922 |
h_Z_metEta[i] = new TH1D(name,name,16,-8,8);
|
| 923 |
h_Z_metEta[i]->SetXTitle("#eta_{#slash{p}_{T}}");
|
| 924 |
h_Z_metEta[i]->SetYTitle("events / bin");
|
| 925 |
sprintf(name,"h_Z_metPhi_%d",i);
|
| 926 |
h_Z_metPhi[i] = new TH1D(name,name,30,-Pi,Pi);
|
| 927 |
h_Z_metPhi[i]->SetXTitle("#phi_{#slash{p}_{T}}");
|
| 928 |
h_Z_metPhi[i]->SetYTitle("events / bin");
|
| 929 |
|
| 930 |
// TH2D *h_Z_summedJetDeltaPhi_VS_deltaPhi("summedJetDeltaPhi_VS_deltaPhi", "summedJetDeltaPhi_VS_deltaPhi", 30,-Pi,Pi,15,0,Pi);
|
| 931 |
|
| 932 |
}
|
| 933 |
// --------------------------------------------------------------------------------------------------------------------
|
| 934 |
|
| 935 |
|
| 936 |
// --------------------------------------------------------------------------------------------------------------------
|
| 937 |
// get the trigger map this is done once per input file
|
| 938 |
// check that all files in the same input file have the
|
| 939 |
// same trigger table
|
| 940 |
// --------------------------------------------------------------------------------------------------------------------
|
| 941 |
getHLTtable();
|
| 942 |
// --------------------------------------------------------------------------------------------------------------------
|
| 943 |
|
| 944 |
|
| 945 |
////////////////////////////////////////////////////////////////////
|
| 946 |
////////////////////Loop over entries starts here //////////////////
|
| 947 |
////////////////////////////////////////////////////////////////////
|
| 948 |
|
| 949 |
|
| 950 |
|
| 951 |
|
| 952 |
TH1D *h_jetPt = new TH1D("h_jetPt", "jet_Pt",100,0,100);
|
| 953 |
|
| 954 |
/////////initialize variables
|
| 955 |
|
| 956 |
Long64_t nentries = fChain->GetEntriesFast();
|
| 957 |
std::cout << "analysisClass::Loop(): nentries = " << nentries << std::endl;
|
| 958 |
|
| 959 |
////// The following ~7 lines have been taken from rootNtupleClass->Loop() /////
|
| 960 |
////// If the root version is updated and rootNtupleClass regenerated, /////
|
| 961 |
////// these lines may need to be updated. /////
|
| 962 |
Long64_t nb = 0;
|
| 963 |
|
| 964 |
|
| 965 |
for (Long64_t jentry=0; jentry<nentries;jentry++) { // loop over all events (entries) in the tree/chain
|
| 966 |
|
| 967 |
|
| 968 |
Long64_t ientry = fChain->LoadTree(jentry); // ientry: this is a counter over each single file in the input list
|
| 969 |
|
| 970 |
if (ientry < 0) {cerr<<"WARNING: ientry = "<<ientry<<" is smaller than 0! (this is ok if the end of the file is reached...)"<<endl; break; }
|
| 971 |
|
| 972 |
nb=fChain->GetEntry(jentry);
|
| 973 |
//fChain->GetEntry(jentry);
|
| 974 |
|
| 975 |
if(jentry < 10 || jentry%1000 == 0) {
|
| 976 |
std::cout << "analysisClass::Loop(): Events processed = " << jentry << std::endl;
|
| 977 |
}
|
| 978 |
|
| 979 |
if(sampleSize!=-1 && sampleSize==jentry) {
|
| 980 |
goto END;
|
| 981 |
}
|
| 982 |
totalNumberOfEvents++;
|
| 983 |
h_numberOfEvents->Fill(1);
|
| 984 |
|
| 985 |
////////////////////////////////////////////////////////////////////
|
| 986 |
////////////////////// User's code starts here /////////////////////
|
| 987 |
////////////////////////////////////////////////////////////////////
|
| 988 |
|
| 989 |
// check the methods defined in baseClass
|
| 990 |
|
| 991 |
testEvent lepton;
|
| 992 |
lepton = fillTestEvent();
|
| 993 |
for(int ii=0;ii<NEles;ii++) {
|
| 994 |
// cout<<"pt: "<<lepton.fourMomentum[ii].Perp()<<endl;
|
| 995 |
}
|
| 996 |
|
| 997 |
jetIndex.clear();
|
| 998 |
electronIndex.clear();
|
| 999 |
|
| 1000 |
|
| 1001 |
vector<TLorentzVector> electronsTight;
|
| 1002 |
vector<TLorentzVector> electronsETH;
|
| 1003 |
vector<TLorentzVector> electronsTightIsolated;
|
| 1004 |
vector<TLorentzVector> electronsETHIsolated;
|
| 1005 |
vector<TLorentzVector> jets;
|
| 1006 |
electronsTight.clear();
|
| 1007 |
electronsETH.clear();
|
| 1008 |
jets.clear();
|
| 1009 |
|
| 1010 |
|
| 1011 |
int BSC_techbit = 0;
|
| 1012 |
int BeamHalo = 0;
|
| 1013 |
|
| 1014 |
|
| 1015 |
// --------------------------------------------------------------------------------
|
| 1016 |
// get the MET
|
| 1017 |
// --------------------------------------------------------------------------------
|
| 1018 |
double met;
|
| 1019 |
double metPhi;
|
| 1020 |
// double metEta;
|
| 1021 |
double delPhiMet;
|
| 1022 |
met=PFMET;
|
| 1023 |
metPhi=PFMETphi;
|
| 1024 |
// metEta=PFMETeta;
|
| 1025 |
|
| 1026 |
// --------------------------------------------------------------------------------
|
| 1027 |
// get the number of jets
|
| 1028 |
// --------------------------------------------------------------------------------
|
| 1029 |
int njets=0;
|
| 1030 |
|
| 1031 |
|
| 1032 |
// vector<TLorentzVector> jets;
|
| 1033 |
for(int j=0;j<NJets;j++) {
|
| 1034 |
TLorentzVector vec;
|
| 1035 |
vec.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
|
| 1036 |
if(JPx[j]>jetPtMin) {
|
| 1037 |
jets.push_back(vec);
|
| 1038 |
}
|
| 1039 |
}
|
| 1040 |
vector<TLorentzVector> eles;
|
| 1041 |
for(int e=0;e<NEles;e++) {
|
| 1042 |
TLorentzVector vec;
|
| 1043 |
vec.SetPxPyPzE(ElPx[e],ElPy[e],ElPz[e],ElE[e]);
|
| 1044 |
myEvent ele;
|
| 1045 |
ele.fourvector.push_back(vec);
|
| 1046 |
ele.momentum.push_back(ElPt[e]);
|
| 1047 |
ele.missinget=met;
|
| 1048 |
ele.charge.push_back(ElCharge[e]);
|
| 1049 |
double dEtaCorrection=0;
|
| 1050 |
double dPhiCorrection=0;
|
| 1051 |
if(isdata==true && applyDeltaCorrection==true) {
|
| 1052 |
dEtaCorrection=detaCorrections(ElEta[e], ElPhi[e]);
|
| 1053 |
dPhiCorrection=dphiCorrections(ElEta[e], ElPhi[e]);
|
| 1054 |
}
|
| 1055 |
ele.deltaPhi.push_back(ElDeltaPhiSuperClusterAtVtx[e] - dPhiCorrection);
|
| 1056 |
ele.deltaEta.push_back(ElDeltaEtaSuperClusterAtVtx[e] - dEtaCorrection);
|
| 1057 |
ele.oneOverEminusOverP.push_back(fabs(1/ElCaloEnergy[e]-1/ElTrkMomAtVtx[e]));
|
| 1058 |
ele.transverseMass.push_back(transverseMass(ElPt[e], met, deltaPhi(ElPhi[e],metPhi)));
|
| 1059 |
ele.ethIso.push_back(ElDR03TkSumPt[e]/ElCaloEnergy[e]);
|
| 1060 |
if(workingPoint>0) {
|
| 1061 |
ele.trkIso.push_back(ElDR03TkSumPt[e]/ElPt[e]);
|
| 1062 |
ele.ecalIso.push_back(ElDR03EcalRecHitSumEt[e]/ElPt[e]);
|
| 1063 |
ele.hcalIso.push_back(ElDR03HcalTowerSumEt[e]/ElPt[e]);
|
| 1064 |
}
|
| 1065 |
if(workingPoint<0) {
|
| 1066 |
ele.trkIso.push_back(ElDR03TkSumPt[e]);
|
| 1067 |
ele.ecalIso.push_back(ElDR04EcalRecHitSumEt[e]);
|
| 1068 |
ele.hcalIso.push_back(ElDR04HcalTowerSumEt[e]);
|
| 1069 |
}
|
| 1070 |
ele.HoverE.push_back(ElHcalOverEcal[e]);
|
| 1071 |
ele.sigmaIetaIeta.push_back(ElSigmaIetaIeta[e]);
|
| 1072 |
if(noInnerHitInfo==false) {
|
| 1073 |
ele.numberOfMissingInnerHits.push_back(ElNumberOfMissingInnerHits[e]);
|
| 1074 |
}
|
| 1075 |
else if(noInnerHitInfo==true) {
|
| 1076 |
ele.numberOfMissingInnerHits.push_back(0);
|
| 1077 |
}
|
| 1078 |
// check if really only one electron is filled
|
| 1079 |
if(ele.fourvector.size()>1) {
|
| 1080 |
cout<<"ele size to large!!!: "<<ele.fourvector.size()<<endl;
|
| 1081 |
break;
|
| 1082 |
}
|
| 1083 |
|
| 1084 |
if(WorkingPointID(ele, WorkingPointCuts)==true && ele.momentum[0]>20) {
|
| 1085 |
eles.push_back(vec);
|
| 1086 |
//debug++;
|
| 1087 |
}
|
| 1088 |
}
|
| 1089 |
|
| 1090 |
int matched=0;
|
| 1091 |
double dR=9999.;
|
| 1092 |
for(int nj=0;nj<jets.size();nj++) {
|
| 1093 |
for(int ne=0;ne<eles.size();ne++) {
|
| 1094 |
|
| 1095 |
double deltaR=fabs(jets[nj].DeltaR(eles[ne]));
|
| 1096 |
if(deltaR<dR) dR=deltaR;
|
| 1097 |
}
|
| 1098 |
if(dR>deltaRMax) njets++;
|
| 1099 |
}
|
| 1100 |
|
| 1101 |
// --------------------------------------------------------------------------------
|
| 1102 |
// ugly implemented JET VETO and MET cut
|
| 1103 |
// --------------------------------------------------------------------------------
|
| 1104 |
|
| 1105 |
|
| 1106 |
if(applyJetVeto==true && (njets>0 || met<25)) continue;
|
| 1107 |
|
| 1108 |
// --------------------------------------------------------------------------------
|
| 1109 |
|
| 1110 |
// --------------------------------------------------------------------------------
|
| 1111 |
// Let's have a look at the electrons
|
| 1112 |
// --------------------------------------------------------------------------------
|
| 1113 |
|
| 1114 |
|
| 1115 |
// define the different electrons
|
| 1116 |
myEvent tightElectrons;
|
| 1117 |
myEvent ethElectrons;
|
| 1118 |
|
| 1119 |
|
| 1120 |
double etaMaxBarrel=1.44;
|
| 1121 |
double etaMaxEndcap=2.5;
|
| 1122 |
|
| 1123 |
double deltaPhiCut=0.02;
|
| 1124 |
double deltaEtaCut=0.004;
|
| 1125 |
double oneOverEminusOneOverPCut=0.005;
|
| 1126 |
bool ethIDpassed=false;
|
| 1127 |
|
| 1128 |
|
| 1129 |
|
| 1130 |
// loop over all electrons in one event
|
| 1131 |
for(int i=0; i<NEles; i++) {
|
| 1132 |
|
| 1133 |
// if(ElectronPreselection(i)==0) debug++;
|
| 1134 |
|
| 1135 |
|
| 1136 |
// --------------------------------------------------------------------------------
|
| 1137 |
// check acceptance region of the electrons...
|
| 1138 |
// --------------------------------------------------------------------------------
|
| 1139 |
double accEta;
|
| 1140 |
// accEta = ElEta[i];
|
| 1141 |
accEta = ElSCEta[i]; // use the SC eta to define acceptance
|
| 1142 |
// --------------------------------------------------------------------------------
|
| 1143 |
|
| 1144 |
|
| 1145 |
|
| 1146 |
|
| 1147 |
// --------------------------------------------------------------------------------
|
| 1148 |
// apply corrections for delta eta and delta phi
|
| 1149 |
// --------------------------------------------------------------------------------
|
| 1150 |
double dEtaCorrection=0;
|
| 1151 |
double dPhiCorrection=0;
|
| 1152 |
if(isdata==true && applyDeltaCorrection==true) {
|
| 1153 |
dEtaCorrection=detaCorrections(accEta, ElPhi[i]);
|
| 1154 |
dPhiCorrection=dphiCorrections(accEta, ElPhi[i]);
|
| 1155 |
}
|
| 1156 |
// --------------------------------------------------------------------------------
|
| 1157 |
|
| 1158 |
// --------------------------------------------------------------------------------
|
| 1159 |
// fill the myevent
|
| 1160 |
// --------------------------------------------------------------------------------
|
| 1161 |
TLorentzVector vec;
|
| 1162 |
vec.SetPxPyPzE(ElPx[i],ElPy[i],ElPz[i],ElE[i]);
|
| 1163 |
myEvent candidate;
|
| 1164 |
candidate.fourvector.push_back(vec);
|
| 1165 |
candidate.momentum.push_back(ElPt[i]);
|
| 1166 |
candidate.missinget=met;
|
| 1167 |
candidate.charge.push_back(ElCharge[i]);
|
| 1168 |
candidate.deltaPhi.push_back(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection);
|
| 1169 |
candidate.deltaEta.push_back(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection);
|
| 1170 |
candidate.oneOverEminusOverP.push_back(fabs(1/ElCaloEnergy[i]-1/ElTrkMomAtVtx[i]));
|
| 1171 |
candidate.transverseMass.push_back(transverseMass(ElPt[i], met, deltaPhi(ElPhi[i],metPhi)));
|
| 1172 |
candidate.ethIso.push_back(ElDR03TkSumPt[i]/ElCaloEnergy[i]);
|
| 1173 |
if(workingPoint>0) {
|
| 1174 |
candidate.trkIso.push_back(ElDR03TkSumPt[i]/ElPt[i]);
|
| 1175 |
candidate.ecalIso.push_back(ElDR03EcalRecHitSumEt[i]/ElPt[i]);
|
| 1176 |
candidate.hcalIso.push_back(ElDR03HcalTowerSumEt[i]/ElPt[i]);
|
| 1177 |
}
|
| 1178 |
if(workingPoint<0) {
|
| 1179 |
candidate.trkIso.push_back(ElDR03TkSumPt[i]);
|
| 1180 |
candidate.ecalIso.push_back(ElDR04EcalRecHitSumEt[i]);
|
| 1181 |
candidate.hcalIso.push_back(ElDR04HcalTowerSumEt[i]);
|
| 1182 |
}
|
| 1183 |
candidate.HoverE.push_back(ElHcalOverEcal[i]);
|
| 1184 |
candidate.sigmaIetaIeta.push_back(ElSigmaIetaIeta[i]);
|
| 1185 |
if(noInnerHitInfo==false) {
|
| 1186 |
candidate.numberOfMissingInnerHits.push_back(ElNumberOfMissingInnerHits[i]);
|
| 1187 |
}
|
| 1188 |
else if(noInnerHitInfo==true) {
|
| 1189 |
candidate.numberOfMissingInnerHits.push_back(0);
|
| 1190 |
}
|
| 1191 |
|
| 1192 |
// check if really only one electron is filled
|
| 1193 |
if(candidate.fourvector.size()>1) {
|
| 1194 |
cout<<"candidate size to large!!!: "<<candidate.fourvector.size()<<endl;
|
| 1195 |
break;
|
| 1196 |
}
|
| 1197 |
// --------------------------------------------------------------------------------
|
| 1198 |
|
| 1199 |
// check if electron is in acceptance region of the detector
|
| 1200 |
if(fabs(accEta)<etaEndcapMax) {
|
| 1201 |
|
| 1202 |
|
| 1203 |
// fill a set of plots for the gsf electron candidates
|
| 1204 |
int cut=0;
|
| 1205 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1206 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1207 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1208 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1209 |
);
|
| 1210 |
|
| 1211 |
// make the electron preselection
|
| 1212 |
if(applyCut[1]==false || ElHcalOverEcal[i]<Pre_HoverEMin) {
|
| 1213 |
cut=1;
|
| 1214 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1215 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1216 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1217 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1218 |
);
|
| 1219 |
if(applyCut[2]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] -dPhiCorrection)<Pre_deltaPhiMax) {
|
| 1220 |
cut=2;
|
| 1221 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1222 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1223 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1224 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1225 |
);
|
| 1226 |
if(applyCut[3]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<Pre_deltaEtaMax) {
|
| 1227 |
cut=3;
|
| 1228 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1229 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1230 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1231 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1232 |
);
|
| 1233 |
|
| 1234 |
if(applyCut[4]==false || ElPt[i]>Pre_pt) {
|
| 1235 |
cut=4;
|
| 1236 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1237 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1238 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1239 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1240 |
);
|
| 1241 |
|
| 1242 |
|
| 1243 |
// now the preselection is done...
|
| 1244 |
|
| 1245 |
// ask for triggers HLT_Photon10
|
| 1246 |
// cout<<"Trigger: 53: "<<HLTResults[53]<<"/ 54: "<<HLTResults[54]<<"/ 55: "<<HLTResults[55]<<endl;
|
| 1247 |
|
| 1248 |
// get the right trigger bit
|
| 1249 |
int Photon10;
|
| 1250 |
int Photon15;
|
| 1251 |
int Photon10_Cleaned;
|
| 1252 |
int Ele15;
|
| 1253 |
Photon10 = getHLTtriggerBit("HLT_Photon10_L1R");
|
| 1254 |
Photon15 = getHLTtriggerBit("HLT_Photon15_L1R");
|
| 1255 |
// Photon10_Cleaned = getHLTtriggerBit("HLT_Photon10_Cleaned_L1R");
|
| 1256 |
Ele15 = getHLTtriggerBit("HLT_Ele15_LW_L1R");
|
| 1257 |
|
| 1258 |
if(applyCut[5]==false || HLTResults[Photon10]==1 || HLTResults[Photon15]==1 || HLTResults[Ele15]==1) {
|
| 1259 |
// if(true) {
|
| 1260 |
cut=5;
|
| 1261 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1262 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1263 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1264 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1265 |
);
|
| 1266 |
|
| 1267 |
|
| 1268 |
// now the different IDs
|
| 1269 |
|
| 1270 |
// check if electron from conversion...
|
| 1271 |
bool isConversion;
|
| 1272 |
if((fabs(ElConvPartnerTrkDist[i])<0.02 && fabs(ElConvPartnerTrkDCot[i])<0.02) || ElNumberOfMissingInnerHits[i]>1) isConversion=true;
|
| 1273 |
else isConversion=false;
|
| 1274 |
|
| 1275 |
|
| 1276 |
|
| 1277 |
|
| 1278 |
// first the ETH one for the barrel
|
| 1279 |
double OneoverEminusOneoverP=fabs(1/ElCaloEnergy[i]-1/ElTrkMomAtVtx[i]);
|
| 1280 |
if(fabs(accEta)<etaBarrelMax) {
|
| 1281 |
cut=6;
|
| 1282 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1283 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1284 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1285 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1286 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1287 |
);
|
| 1288 |
// only ECAL driven electrons
|
| 1289 |
if(applyCut[7]==false || ElEcalDriven[i]==1) {
|
| 1290 |
cut=7;
|
| 1291 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1292 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1293 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1294 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1295 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1296 |
);
|
| 1297 |
// |1/E-1/p|
|
| 1298 |
if(applyCut[8]==false || OneoverEminusOneoverP<ETH_oneOverEminusOneOverP_B) {
|
| 1299 |
cut=8;
|
| 1300 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1301 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1302 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1303 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1304 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1305 |
);
|
| 1306 |
// delta eta
|
| 1307 |
if(applyCut[9]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<ETH_deltaEtaMax_B) {
|
| 1308 |
cut=9;
|
| 1309 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1310 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1311 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1312 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1313 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1314 |
);
|
| 1315 |
// delta phi
|
| 1316 |
if(applyCut[10]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection)<ETH_deltaPhiMax_B) {
|
| 1317 |
cut=10;
|
| 1318 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1319 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1320 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1321 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1322 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1323 |
);
|
| 1324 |
// isolation
|
| 1325 |
double iso=ElDR04TkSumPt[i]/ElCaloEnergy[i];
|
| 1326 |
if(applyCut[11]==false || iso<ETH_iso_B) {
|
| 1327 |
cut=11;
|
| 1328 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1329 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1330 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1331 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1332 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1333 |
);
|
| 1334 |
// remove conversions
|
| 1335 |
// if(applyCut[12]==false || (ElNumberOfMissingInnerHits[i]<2 && ElConvPartnerTrkDist[i]<Rob_dist_E && ElConvPartnerTrkDCot[i]<Rob_cot_E) ) {
|
| 1336 |
if(applyCut[12]==false || isConversion==false) {
|
| 1337 |
cut=12;
|
| 1338 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1339 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1340 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1341 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1342 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1343 |
);
|
| 1344 |
} // conversions
|
| 1345 |
} // isolation
|
| 1346 |
} //delta phi, barrel
|
| 1347 |
} //delta eta, barrel
|
| 1348 |
} // 1/e-1/p, barrel
|
| 1349 |
} // ECAL driven, barrel
|
| 1350 |
} // ETH barrel
|
| 1351 |
|
| 1352 |
// now the ETH ID for the endcaps
|
| 1353 |
else if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
|
| 1354 |
cut=13;
|
| 1355 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1356 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1357 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1358 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1359 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1360 |
);
|
| 1361 |
// only ECAL driven electrons
|
| 1362 |
if(applyCut[14]==false || ElEcalDriven[i]==1) {
|
| 1363 |
cut=14;
|
| 1364 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1365 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1366 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1367 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1368 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1369 |
);
|
| 1370 |
// |1/E-1/p|
|
| 1371 |
if(applyCut[15]==false || OneoverEminusOneoverP<ETH_oneOverEminusOneOverP_E) {
|
| 1372 |
cut=15;
|
| 1373 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1374 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1375 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1376 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1377 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1378 |
);
|
| 1379 |
// delta eta
|
| 1380 |
if(applyCut[16]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<ETH_deltaEtaMax_E) {
|
| 1381 |
cut=16;
|
| 1382 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1383 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1384 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1385 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1386 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1387 |
);
|
| 1388 |
// delta phi
|
| 1389 |
if(applyCut[17]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection)<ETH_deltaPhiMax_E) {
|
| 1390 |
cut=17;
|
| 1391 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1392 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1393 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1394 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1395 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1396 |
);
|
| 1397 |
// isolation
|
| 1398 |
double iso=ElDR04TkSumPt[i]/ElCaloEnergy[i];
|
| 1399 |
if(applyCut[18]==false || iso<ETH_iso_E) {
|
| 1400 |
cut=18;
|
| 1401 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1402 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1403 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1404 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1405 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1406 |
);
|
| 1407 |
// remove conversions
|
| 1408 |
if(applyCut[19]==false || isConversion==false) {
|
| 1409 |
cut=19;
|
| 1410 |
//filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
|
| 1411 |
filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
|
| 1412 |
hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
|
| 1413 |
hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
|
| 1414 |
hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
|
| 1415 |
);
|
| 1416 |
} // conversions
|
| 1417 |
} // isolation
|
| 1418 |
} //delta phi
|
| 1419 |
} //delta eta
|
| 1420 |
} // 1/e-1/p
|
| 1421 |
} // ECAL driven
|
| 1422 |
|
| 1423 |
} // ETH endcap
|
| 1424 |
|
| 1425 |
// now let's do the Robust one
|
| 1426 |
|
| 1427 |
|
| 1428 |
// --------------------------------------------------------------------------------------------------------------------
|
| 1429 |
// Fill the N-1 plots
|
| 1430 |
// --------------------------------------------------------------------------------------------------------------------
|
| 1431 |
|
| 1432 |
// ETH
|
| 1433 |
|
| 1434 |
// delta phi plot
|
| 1435 |
// barrel deltaPhi
|
| 1436 |
|
| 1437 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaPhi", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1438 |
fabs(ElEta[i])<etaBarrelMax) {
|
| 1439 |
hn1_El_ElDeltaPhi[0]->Fill(fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection));
|
| 1440 |
}
|
| 1441 |
// endcap
|
| 1442 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaPhi", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1443 |
fabs(ElEta[i])>etaBarrelMax &&
|
| 1444 |
fabs(ElEta[i])<etaEndcapMax) {
|
| 1445 |
hn1_El_ElDeltaPhi[1]->Fill(fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection));
|
| 1446 |
}
|
| 1447 |
// delta eta
|
| 1448 |
// barrel
|
| 1449 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaEta", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1450 |
fabs(ElEta[i])<etaBarrelMax) {
|
| 1451 |
hn1_El_ElDeltaEta[0]->Fill(fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection));
|
| 1452 |
}
|
| 1453 |
// endcap
|
| 1454 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaEta", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1455 |
fabs(ElEta[i])>etaBarrelMax &&
|
| 1456 |
fabs(ElEta[i])<etaEndcapMax) {
|
| 1457 |
hn1_El_ElDeltaEta[1]->Fill(fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection));
|
| 1458 |
}
|
| 1459 |
// 1/e-1/p
|
| 1460 |
// barrel
|
| 1461 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "oneOverEminusOneOverP", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1462 |
fabs(ElEta[i])<etaBarrelMax) {
|
| 1463 |
hn1_El_ElOneOverEminusOneOverP[0]->Fill(fabs(1/ElCaloEnergy[i] - 1/ElTrkMomAtVtx[i]));
|
| 1464 |
}
|
| 1465 |
// endcap
|
| 1466 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "oneOverEminusOneOverP", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1467 |
fabs(ElEta[i])>etaBarrelMax &&
|
| 1468 |
fabs(ElEta[i])<etaEndcapMax) {
|
| 1469 |
hn1_El_ElOneOverEminusOneOverP[1]->Fill(fabs(1/ElCaloEnergy[i] - 1/ElTrkMomAtVtx[i]));
|
| 1470 |
}
|
| 1471 |
// isolation
|
| 1472 |
// barrel
|
| 1473 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "iso", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1474 |
fabs(ElEta[i])<etaBarrelMax) {
|
| 1475 |
hn1_El_ElEthIso[0]->Fill(ElDR04TkSumPt[i]/ ElCaloEnergy[i]);
|
| 1476 |
}
|
| 1477 |
// endcap
|
| 1478 |
if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "iso", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
|
| 1479 |
fabs(ElEta[i])>etaBarrelMax &&
|
| 1480 |
fabs(ElEta[i])<etaEndcapMax) {
|
| 1481 |
hn1_El_ElEthIso[1]->Fill(ElDR04TkSumPt[i]/ ElCaloEnergy[i]);
|
| 1482 |
}
|
| 1483 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1484 |
|
| 1485 |
|
| 1486 |
} //HLT_Photon10 trigger
|
| 1487 |
}// pt
|
| 1488 |
} // delta eta
|
| 1489 |
} // delta phi
|
| 1490 |
} // H/E
|
| 1491 |
} // acceptance region
|
| 1492 |
|
| 1493 |
|
| 1494 |
|
| 1495 |
|
| 1496 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1497 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1498 |
// new code with WPelectronID function
|
| 1499 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1500 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1501 |
|
| 1502 |
int cut;
|
| 1503 |
double Pt=ElPt[i] * PtCorrection;
|
| 1504 |
double Eta=ElEta[i];
|
| 1505 |
double Phi=ElPhi[i];
|
| 1506 |
double Charge=ElCharge[i];
|
| 1507 |
double delPhi=ElDeltaPhiSuperClusterAtVtx[i]-dphiCorrections(ElEta[i], ElPhi[i]);
|
| 1508 |
double delEta=ElDeltaEtaSuperClusterAtVtx[i]-detaCorrections(ElEta[i], ElPhi[i]);
|
| 1509 |
double transMass=transverseMass(ElPt[i] * PtCorrection, PFMET, deltaPhi(ElPhi[i],metPhi));
|
| 1510 |
double Hoe=ElHcalOverEcal[i];
|
| 1511 |
double trkIso = ElDR03TkSumPt[i];
|
| 1512 |
double ecalIso = ElDR03EcalRecHitSumEt[i];
|
| 1513 |
double hcalIso = ElDR03HcalTowerSumEt[i];
|
| 1514 |
double combIso_B=(trkIso + max(0., ecalIso - 1.) + hcalIso) / ( ElPt[i] * PtCorrection);
|
| 1515 |
double combIso_E=(trkIso + ecalIso + hcalIso) / (ElPt[i] * PtCorrection);
|
| 1516 |
double See=ElSigmaIetaIeta[i];
|
| 1517 |
double missingHits=ElNumberOfMissingInnerHits[i];
|
| 1518 |
|
| 1519 |
|
| 1520 |
|
| 1521 |
// check if trigger fired
|
| 1522 |
int Photon10 = getHLTtriggerBit("HLT_Photon10_L1R");
|
| 1523 |
int Photon15 = getHLTtriggerBit("HLT_Photon15_L1R");
|
| 1524 |
// int bit = getHLTtriggerBit("HLT_Photon10_Cleaned_L1R");
|
| 1525 |
int Ele15 = getHLTtriggerBit("HLT_Ele15_LW_L1R");
|
| 1526 |
|
| 1527 |
if(HLTResults[Photon10]!=1 && HLTResults[Photon15]!=1 && HLTResults[Ele15]!=1) continue;
|
| 1528 |
|
| 1529 |
|
| 1530 |
if(Event==27837545 || Event==73939173 || Event==15512525 || Event==191815699 || Event==29377895 || Event==29377895 || Event==74868952 || Event==76643965 || Event==62016483 || Event==4352136) {
|
| 1531 |
cout<<"##################################"<<endl;
|
| 1532 |
cout<<"Event: "<<Event<<" Run: "<<Run<<endl;
|
| 1533 |
cout<<"Preselection: "<<ElectronPreselection(i)<<endl;
|
| 1534 |
cout<<"Selection: "<<WPElectronID(i, all, WorkingPointCuts)<<endl;
|
| 1535 |
|
| 1536 |
|
| 1537 |
cout<<"##################################"<<endl;
|
| 1538 |
|
| 1539 |
}
|
| 1540 |
|
| 1541 |
// check if electron is preselected
|
| 1542 |
if(ElectronPreselection(i)!=0) continue;
|
| 1543 |
|
| 1544 |
|
| 1545 |
// cout<<"acc: "<<accEta<<endl;
|
| 1546 |
// cout<<"eta: "<<ElEta[i]<<endl;
|
| 1547 |
// cout<<"SC: "<<ElSCEta[i]<<endl;
|
| 1548 |
|
| 1549 |
// the N-1 plots
|
| 1550 |
if(fabs(accEta)<etaBarrelMax) {
|
| 1551 |
if(WPElectronID(i, see, WorkingPointCuts)==0) hn1_El_ElSigmaIetaIeta[2]->Fill(See);
|
| 1552 |
if(WPElectronID(i, dphi, WorkingPointCuts)==0) hn1_El_ElDeltaPhi[2]->Fill(delPhi);
|
| 1553 |
if(WPElectronID(i, deta, WorkingPointCuts)==0) hn1_El_ElDeltaEta[2]->Fill(delEta);
|
| 1554 |
if(WPElectronID(i, hoe, WorkingPointCuts)==0) hn1_El_ElHoverE[2]->Fill(Hoe);
|
| 1555 |
if(WPElectronID(i, combiso, WorkingPointCuts)==0) hn1_El_ElCombIso[2]->Fill(combIso_B);
|
| 1556 |
if(WPElectronID(i, conversion, WorkingPointCuts)==0) hn1_El_ElNumberOfMissingInnerHits[2]->Fill(missingHits);
|
| 1557 |
}
|
| 1558 |
if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
|
| 1559 |
if(WPElectronID(i, see, WorkingPointCuts)==0) hn1_El_ElSigmaIetaIeta[3]->Fill(See);
|
| 1560 |
if(WPElectronID(i, dphi, WorkingPointCuts)==0) hn1_El_ElDeltaPhi[3]->Fill(delPhi);
|
| 1561 |
if(WPElectronID(i, deta, WorkingPointCuts)==0) hn1_El_ElDeltaEta[3]->Fill(delEta);
|
| 1562 |
if(WPElectronID(i, hoe, WorkingPointCuts)==0) hn1_El_ElHoverE[3]->Fill(Hoe);
|
| 1563 |
if(WPElectronID(i, combiso, WorkingPointCuts)==0) hn1_El_ElCombIso[3]->Fill(combIso_E);
|
| 1564 |
if(WPElectronID(i, conversion, WorkingPointCuts)==0) hn1_El_ElNumberOfMissingInnerHits[3]->Fill(missingHits);
|
| 1565 |
}
|
| 1566 |
|
| 1567 |
if(WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1568 |
// count the number of electrons in one event
|
| 1569 |
electronIndex.push_back(i);
|
| 1570 |
|
| 1571 |
fprintf(out,"%i\t%i\n",Run, Event);
|
| 1572 |
// cout<<"Run: "<<Run<<" Event: "<<Event<<endl;
|
| 1573 |
|
| 1574 |
// look at the charges of the IDed electrons
|
| 1575 |
int cGsf=ElCharge[i];
|
| 1576 |
int cSc=ElScPixCharge[i];
|
| 1577 |
|
| 1578 |
if(cGsf==cSc) cNa++;
|
| 1579 |
else cNb++;
|
| 1580 |
|
| 1581 |
// check the acceptance (etc.) variables
|
| 1582 |
h_ElEtaVsScEta->Fill(ElEta[i], ElSCEta[i]);
|
| 1583 |
// h_ElPhiVsScPhi->Fill(ElPhi[i], El);
|
| 1584 |
TVector3 track;
|
| 1585 |
track.SetXYZ(ElPx[i], ElPy[i], ElPz[i]);
|
| 1586 |
double trackEta=track.Eta();
|
| 1587 |
h_ElPtVsScEt->Fill(ElPt[i] * PtCorrection , ElCaloEnergy[i]/cosh(trackEta));
|
| 1588 |
|
| 1589 |
|
| 1590 |
|
| 1591 |
|
| 1592 |
}
|
| 1593 |
|
| 1594 |
|
| 1595 |
|
| 1596 |
|
| 1597 |
|
| 1598 |
|
| 1599 |
// the sequential counting and filling
|
| 1600 |
// preselection
|
| 1601 |
counter[0]++;
|
| 1602 |
// split in barrel and endcap
|
| 1603 |
if(fabs(accEta)<etaBarrelMax) {
|
| 1604 |
// preselected in barrel
|
| 1605 |
counter[1]++;
|
| 1606 |
//fillIt(i, 20);
|
| 1607 |
// fill the (right) histos
|
| 1608 |
cut=20;
|
| 1609 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1610 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1611 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1612 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1613 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1614 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1615 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1616 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1617 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1618 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1619 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1620 |
// hs_El_ElMet[cut]
|
| 1621 |
// hs_El_ElOneOverEminusOneOverP[cut]
|
| 1622 |
// hs_El_ElEthIso[cut]
|
| 1623 |
// hs_El_ElTrkIso[cut]
|
| 1624 |
// hs_El_ElEcalIso[cut]
|
| 1625 |
// hs_El_ElHcalIso[cut]
|
| 1626 |
|
| 1627 |
// after see cut
|
| 1628 |
if(WPElectronID(i, all, WorkingPointCuts)>1 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1629 |
counter[2]++;
|
| 1630 |
cut=21;
|
| 1631 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1632 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1633 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1634 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1635 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1636 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1637 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1638 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1639 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1640 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1641 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1642 |
}
|
| 1643 |
|
| 1644 |
// after dphi
|
| 1645 |
if(WPElectronID(i, all, WorkingPointCuts)>2 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1646 |
counter[3]++;
|
| 1647 |
cut=22;
|
| 1648 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1649 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1650 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1651 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1652 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1653 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1654 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1655 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1656 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1657 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1658 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1659 |
}
|
| 1660 |
// after deta
|
| 1661 |
if(WPElectronID(i, all, WorkingPointCuts)>3 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1662 |
counter[4]++;
|
| 1663 |
cut=23;
|
| 1664 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1665 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1666 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1667 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1668 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1669 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1670 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1671 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1672 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1673 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1674 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1675 |
}
|
| 1676 |
// after hoe
|
| 1677 |
if(WPElectronID(i, all, WorkingPointCuts)>4 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1678 |
counter[5]++;
|
| 1679 |
cut=24;
|
| 1680 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1681 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1682 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1683 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1684 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1685 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1686 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1687 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1688 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1689 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1690 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1691 |
}
|
| 1692 |
// after iso
|
| 1693 |
if(WPElectronID(i, all, WorkingPointCuts)>5 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1694 |
counter[6]++;
|
| 1695 |
cut=25;
|
| 1696 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1697 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1698 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1699 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1700 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1701 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1702 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1703 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1704 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1705 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1706 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1707 |
}
|
| 1708 |
// after conversion == total IDed
|
| 1709 |
if(WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1710 |
counter[7]++;
|
| 1711 |
cut=26;
|
| 1712 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1713 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1714 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1715 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1716 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1717 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1718 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1719 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1720 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1721 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1722 |
hs_El_ElCombIso[cut]->Fill(combIso_B);
|
| 1723 |
}
|
| 1724 |
} //barrel
|
| 1725 |
if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
|
| 1726 |
// preselected in endcaps
|
| 1727 |
counter[8]++;
|
| 1728 |
cut=27;
|
| 1729 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1730 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1731 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1732 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1733 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1734 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1735 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1736 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1737 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1738 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1739 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1740 |
|
| 1741 |
// after see cut
|
| 1742 |
if(WPElectronID(i, all, WorkingPointCuts)>1 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1743 |
counter[9]++;
|
| 1744 |
cut=28;
|
| 1745 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1746 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1747 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1748 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1749 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1750 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1751 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1752 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1753 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1754 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1755 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1756 |
}
|
| 1757 |
// after dphi
|
| 1758 |
if(WPElectronID(i, all, WorkingPointCuts)>2 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1759 |
counter[10]++;
|
| 1760 |
cut=29;
|
| 1761 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1762 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1763 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1764 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1765 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1766 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1767 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1768 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1769 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1770 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1771 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1772 |
}
|
| 1773 |
// after deta
|
| 1774 |
if(WPElectronID(i, all, WorkingPointCuts)>3 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1775 |
counter[11]++;
|
| 1776 |
cut=30;
|
| 1777 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1778 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1779 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1780 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1781 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1782 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1783 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1784 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1785 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1786 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1787 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1788 |
}
|
| 1789 |
// after hoe
|
| 1790 |
if(WPElectronID(i, all, WorkingPointCuts)>4 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1791 |
counter[12]++;
|
| 1792 |
cut=31;
|
| 1793 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1794 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1795 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1796 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1797 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1798 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1799 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1800 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1801 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1802 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1803 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1804 |
}
|
| 1805 |
// after iso
|
| 1806 |
if(WPElectronID(i, all, WorkingPointCuts)>5 || WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1807 |
counter[13]++;
|
| 1808 |
cut=32;
|
| 1809 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1810 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1811 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1812 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1813 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1814 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1815 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1816 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1817 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1818 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1819 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1820 |
}
|
| 1821 |
// after conversion == total IDed
|
| 1822 |
if(WPElectronID(i, all, WorkingPointCuts)==0) {
|
| 1823 |
counter[14]++;
|
| 1824 |
cut=33;
|
| 1825 |
hs_El_ElPt[cut]->Fill(Pt);
|
| 1826 |
hs_El_ElEta[cut]->Fill(Eta);
|
| 1827 |
hs_El_ElPhi[cut]->Fill(Phi);
|
| 1828 |
hs_El_ElCharge[cut]->Fill(Charge);
|
| 1829 |
hs_El_ElDeltaPhi[cut]->Fill(delPhi);
|
| 1830 |
hs_El_ElDeltaEta[cut]->Fill(delEta);
|
| 1831 |
hs_El_ElTransMass[cut]->Fill(transMass);
|
| 1832 |
hs_El_ElHoverE[cut]->Fill(Hoe);
|
| 1833 |
hs_El_ElSigmaIetaIeta[cut]->Fill(See);
|
| 1834 |
hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
|
| 1835 |
hs_El_ElCombIso[cut]->Fill(combIso_E);
|
| 1836 |
}
|
| 1837 |
} // endcaps
|
| 1838 |
|
| 1839 |
|
| 1840 |
|
| 1841 |
|
| 1842 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1843 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1844 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1845 |
|
| 1846 |
|
| 1847 |
// ID the electrons
|
| 1848 |
bool tightid=false;
|
| 1849 |
bool ethid=false;
|
| 1850 |
if(ElIDTight[i]==1) tightid=true;
|
| 1851 |
if(ethID(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i])==true) ethid=true;
|
| 1852 |
|
| 1853 |
// check wether the elcetrons are in the barrel or the endcaps
|
| 1854 |
bool isbarrel=false;
|
| 1855 |
bool isendcap=false;
|
| 1856 |
if(fabs(ElEta[i])<etaMaxBarrel) isbarrel=true;
|
| 1857 |
if(fabs(ElEta[i])>etaMaxBarrel && fabs(ElEta[i])<etaMaxEndcap) isendcap=true;
|
| 1858 |
|
| 1859 |
// Isolate the electrons
|
| 1860 |
double isolated=false;
|
| 1861 |
if(isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])==true) isolated=true;
|
| 1862 |
|
| 1863 |
|
| 1864 |
|
| 1865 |
|
| 1866 |
// fill histos for tight ID
|
| 1867 |
|
| 1868 |
if(tightid==true) {
|
| 1869 |
TLorentzVector vec;
|
| 1870 |
vec.SetPxPyPzE(ElPx[i],ElPy[i],ElPz[i],ElE[i]);
|
| 1871 |
electronsTight.push_back(vec);
|
| 1872 |
if(isolated==true) {
|
| 1873 |
electronsTightIsolated.push_back(vec);
|
| 1874 |
}
|
| 1875 |
|
| 1876 |
// fill the myEvent
|
| 1877 |
if(vec.Pt()>ptMin) {
|
| 1878 |
tightElectrons.fourvector.push_back(vec);
|
| 1879 |
tightElectrons.charge.push_back(ElCharge[i]);
|
| 1880 |
if(isolated==true) tightElectrons.isolation.push_back(true);
|
| 1881 |
else if(isolated==false) tightElectrons.isolation.push_back(false);
|
| 1882 |
}
|
| 1883 |
|
| 1884 |
}
|
| 1885 |
|
| 1886 |
|
| 1887 |
|
| 1888 |
|
| 1889 |
|
| 1890 |
} // loop over all electrons in one event
|
| 1891 |
|
| 1892 |
|
| 1893 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1894 |
// jet cleaning (new)
|
| 1895 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1896 |
|
| 1897 |
// the new number of jets is the size of the jetIndex vector
|
| 1898 |
// use that for jet veto...
|
| 1899 |
TLorentzVector electron;
|
| 1900 |
TLorentzVector jet;
|
| 1901 |
for(int j=0; j<NJets; j++) {
|
| 1902 |
if(JPt[j]<jetPtMin || fabs(JEta[j])>jetEtaMax) continue;
|
| 1903 |
jet.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
|
| 1904 |
|
| 1905 |
double deltaR=999; // have to calculate the minimal deltaR for EACH jet!
|
| 1906 |
for(int e=0;e<electronIndex.size();e++) {
|
| 1907 |
int index=electronIndex[e];
|
| 1908 |
electron.SetPtEtaPhiE(ElPt[index] * PtCorrection ,ElEta[index],ElPhi[index],ElE[index]);
|
| 1909 |
|
| 1910 |
double dR=fabs(jet.DeltaR(electron));
|
| 1911 |
if(dR<deltaR) deltaR=dR;
|
| 1912 |
// cout<<"delta R: "<<deltaR<<endl;
|
| 1913 |
}
|
| 1914 |
if(deltaR<deltaRMax) continue;
|
| 1915 |
jetIndex.push_back(j);
|
| 1916 |
}
|
| 1917 |
|
| 1918 |
|
| 1919 |
//////////////////////
|
| 1920 |
// now check the ordering of the jets!
|
| 1921 |
//////////////////////
|
| 1922 |
|
| 1923 |
|
| 1924 |
// for(int ji=0; ji<jetIndex.size; ji++) {
|
| 1925 |
|
| 1926 |
// }
|
| 1927 |
|
| 1928 |
|
| 1929 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1930 |
|
| 1931 |
|
| 1932 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1933 |
// Tag and Probe efficiency measurement
|
| 1934 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1935 |
|
| 1936 |
// an event gets tagged, if it consists of one IDed and isolated electron
|
| 1937 |
// AND a gsf candidate with pt>20 GeV in the fiducial region
|
| 1938 |
// AND the invariant mass is close to the Z mass
|
| 1939 |
|
| 1940 |
bool isTagged=false;
|
| 1941 |
if(electronIndex.size()>0 && NEles>1) {
|
| 1942 |
for(int i=0; i<NEles; i++) {
|
| 1943 |
// should also cut on the invariant mass !!!!!
|
| 1944 |
if(i==electronIndex[0] || ElPt[i]<20 || (fabs(ElEta[i])>1.44 && fabs(ElEta[i])<1.56 )|| fabs(ElEta[i])>2.5) continue;
|
| 1945 |
isTagged=true;
|
| 1946 |
}
|
| 1947 |
}
|
| 1948 |
// now the Z event is tagged
|
| 1949 |
if(isTagged==true) {
|
| 1950 |
// increment the various counters
|
| 1951 |
N_t0++;
|
| 1952 |
// check the event contains two IDed electrons
|
| 1953 |
if(electronIndex.size()==2) N_tt++;
|
| 1954 |
|
| 1955 |
|
| 1956 |
}
|
| 1957 |
|
| 1958 |
|
| 1959 |
//--------------------------------------------------------------------------------------------------------------------
|
| 1960 |
|
| 1961 |
|
| 1962 |
|
| 1963 |
// --------------------------------------------------------------------------------------------------------------------
|
| 1964 |
// Z Selection (new)
|
| 1965 |
// --------------------------------------------------------------------------------------------------------------------
|
| 1966 |
if(electronIndex.size()==2) {
|
| 1967 |
// calculate the invariant mass
|
| 1968 |
double invMass;
|
| 1969 |
TLorentzVector e1, e2;
|
| 1970 |
e1.SetPtEtaPhiE(ElPt[electronIndex[0]] * PtCorrection ,ElEta[electronIndex[0]],ElPhi[electronIndex[0]],ElE[electronIndex[0]]);
|
| 1971 |
e2.SetPtEtaPhiE(ElPt[electronIndex[1]] * PtCorrection ,ElEta[electronIndex[1]],ElPhi[electronIndex[1]],ElE[electronIndex[1]]);
|
| 1972 |
invMass = (e1+e2).M();
|
| 1973 |
|
| 1974 |
double summedJetPt;
|
| 1975 |
double summedJetEta;
|
| 1976 |
double summedJetPhi;
|
| 1977 |
double recoilPt;
|
| 1978 |
double recoilEta;
|
| 1979 |
double recoilPhi;
|
| 1980 |
|
| 1981 |
// these variables are only defined if there really are jets...
|
| 1982 |
TLorentzVector jsum;
|
| 1983 |
if(jetIndex.size()>0) {
|
| 1984 |
for(int ji=0; ji<jetIndex.size(); ji++) {
|
| 1985 |
TLorentzVector vec;
|
| 1986 |
vec.SetPxPyPzE(JPx[ji], JPy[ji], JPz[ji], JE[ji]);
|
| 1987 |
jsum=jsum+vec;
|
| 1988 |
}
|
| 1989 |
summedJetPt = jsum.Pt();
|
| 1990 |
summedJetEta = jsum.Eta();
|
| 1991 |
summedJetPhi = jsum.Phi();
|
| 1992 |
// add also the Z
|
| 1993 |
jsum+=e1;
|
| 1994 |
jsum+=e2;
|
| 1995 |
recoilPt = jsum.Pt();
|
| 1996 |
recoilEta = jsum.Eta();
|
| 1997 |
recoilPhi = jsum.Phi();
|
| 1998 |
}
|
| 1999 |
|
| 2000 |
fprintf(out_Z,"%i \t%i \t%i \t%f \t%f \t%f \t%f \t%f\n",Run, Event, LumiSection, invMass, ElPt[electronIndex[0]], ElPt[electronIndex[1]], (e1+e2).Pt(), summedJetPt);
|
| 2001 |
|
| 2002 |
h_Z_invMass[0]->Fill(invMass);
|
| 2003 |
h_Z_ptAll[0]->Fill(ElPt[electronIndex[0]]);
|
| 2004 |
h_Z_ptAll[0]->Fill(ElPt[electronIndex[1]]);
|
| 2005 |
h_Z_etaAll[0]->Fill(ElEta[electronIndex[0]]);
|
| 2006 |
h_Z_etaAll[0]->Fill(ElEta[electronIndex[1]]);
|
| 2007 |
h_Z_phiAll[0]->Fill(ElPhi[electronIndex[0]]);
|
| 2008 |
h_Z_phiAll[0]->Fill(ElPhi[electronIndex[1]]);
|
| 2009 |
h_Z_deltaPhi[0]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
|
| 2010 |
h_Z_ptDiLepton[0]->Fill((e1+e2).Pt());
|
| 2011 |
h_Z_etaDiLepton[0]->Fill((e1+e2).Eta());
|
| 2012 |
h_Z_phiDiLepton[0]->Fill((e1+e2).Phi());
|
| 2013 |
|
| 2014 |
// now variables with "jetty" content
|
| 2015 |
|
| 2016 |
h_Z_nJets[0]->Fill(jetIndex.size());
|
| 2017 |
if(jetIndex.size()>0) {
|
| 2018 |
h_Z_leadingJetPt[0]->Fill(JPt[jetIndex[0]]);
|
| 2019 |
h_Z_leadingJetEta[0]->Fill(JEta[jetIndex[0]]);
|
| 2020 |
h_Z_leadingJetPhi[0]->Fill(JPhi[jetIndex[0]]);
|
| 2021 |
h_Z_summedJetPt[0]->Fill(summedJetPt);
|
| 2022 |
h_Z_summedJetEta[0]->Fill(summedJetEta);
|
| 2023 |
h_Z_summedJetPhi[0]->Fill(summedJetPhi);
|
| 2024 |
|
| 2025 |
h_Z_leadingJetDeltaPt[0]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
|
| 2026 |
h_Z_leadingJetDeltaEta[0]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
|
| 2027 |
h_Z_leadingJetDeltaPhi[0]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
|
| 2028 |
h_Z_summedJetDeltaPt[0]->Fill(summedJetPt - (e1+e2).Pt());
|
| 2029 |
h_Z_summedJetDeltaEta[0]->Fill(summedJetEta - (e1+e2).Eta());
|
| 2030 |
h_Z_summedJetDeltaPhi[0]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
|
| 2031 |
|
| 2032 |
h_Z_recoilPt[0]->Fill(recoilPt);
|
| 2033 |
h_Z_recoilEta[0]->Fill(recoilEta);
|
| 2034 |
h_Z_recoilPhi[0]->Fill(recoilPhi);
|
| 2035 |
h_Z_metPt[0]->Fill(met);
|
| 2036 |
// h_Z_metEta[0]->Fill(metEta);
|
| 2037 |
h_Z_metPhi[0]->Fill(metPhi);
|
| 2038 |
}
|
| 2039 |
|
| 2040 |
|
| 2041 |
|
| 2042 |
// check both in barrel
|
| 2043 |
if(fabs(ElEta[electronIndex[0]]) < etaBarrelMax && fabs(ElEta[electronIndex[1]]) < etaBarrelMax) {
|
| 2044 |
h_Z_invMass[1]->Fill(invMass);
|
| 2045 |
|
| 2046 |
h_Z_ptAll[1]->Fill(ElPt[electronIndex[0]]);
|
| 2047 |
h_Z_ptAll[1]->Fill(ElPt[electronIndex[1]]);
|
| 2048 |
h_Z_etaAll[1]->Fill(ElEta[electronIndex[0]]);
|
| 2049 |
h_Z_etaAll[1]->Fill(ElEta[electronIndex[1]]);
|
| 2050 |
h_Z_phiAll[1]->Fill(ElPhi[electronIndex[0]]);
|
| 2051 |
h_Z_phiAll[1]->Fill(ElPhi[electronIndex[1]]);
|
| 2052 |
h_Z_deltaPhi[1]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
|
| 2053 |
h_Z_ptDiLepton[1]->Fill((e1+e2).Pt());
|
| 2054 |
h_Z_etaDiLepton[1]->Fill((e1+e2).Eta());
|
| 2055 |
h_Z_phiDiLepton[1]->Fill((e1+e2).Phi());
|
| 2056 |
|
| 2057 |
// now variables with "jetty" content
|
| 2058 |
h_Z_nJets[1]->Fill(jetIndex.size());
|
| 2059 |
if(jetIndex.size()>0) {
|
| 2060 |
h_Z_leadingJetPt[1]->Fill(JPt[jetIndex[0]]);
|
| 2061 |
h_Z_leadingJetEta[1]->Fill(JEta[jetIndex[0]]);
|
| 2062 |
h_Z_leadingJetPhi[1]->Fill(JPhi[jetIndex[0]]);
|
| 2063 |
h_Z_summedJetPt[1]->Fill(summedJetPt);
|
| 2064 |
h_Z_summedJetEta[1]->Fill(summedJetEta);
|
| 2065 |
h_Z_summedJetPhi[1]->Fill(summedJetPhi);
|
| 2066 |
|
| 2067 |
h_Z_leadingJetDeltaPt[1]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
|
| 2068 |
h_Z_leadingJetDeltaEta[1]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
|
| 2069 |
h_Z_leadingJetDeltaPhi[1]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
|
| 2070 |
h_Z_summedJetDeltaPt[1]->Fill(summedJetPt - (e1+e2).Pt());
|
| 2071 |
h_Z_summedJetDeltaEta[1]->Fill(summedJetEta - (e1+e2).Eta());
|
| 2072 |
h_Z_summedJetDeltaPhi[1]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
|
| 2073 |
|
| 2074 |
h_Z_recoilPt[1]->Fill(recoilPt);
|
| 2075 |
h_Z_recoilEta[1]->Fill(recoilEta);
|
| 2076 |
h_Z_recoilPhi[1]->Fill(recoilPhi);
|
| 2077 |
h_Z_metPt[1]->Fill(met);
|
| 2078 |
// h_Z_metEta[1]->Fill(metEta);
|
| 2079 |
h_Z_metPhi[1]->Fill(metPhi);
|
| 2080 |
}
|
| 2081 |
|
| 2082 |
|
| 2083 |
|
| 2084 |
}
|
| 2085 |
// check both in endcaps
|
| 2086 |
if(fabs(ElEta[electronIndex[0]]) > etaBarrelMax && fabs(ElEta[electronIndex[1]]) > etaBarrelMax) {
|
| 2087 |
h_Z_invMass[2]->Fill(invMass);
|
| 2088 |
|
| 2089 |
h_Z_ptAll[2]->Fill(ElPt[electronIndex[0]]);
|
| 2090 |
h_Z_ptAll[2]->Fill(ElPt[electronIndex[1]]);
|
| 2091 |
h_Z_etaAll[2]->Fill(ElEta[electronIndex[0]]);
|
| 2092 |
h_Z_etaAll[2]->Fill(ElEta[electronIndex[1]]);
|
| 2093 |
h_Z_phiAll[2]->Fill(ElPhi[electronIndex[0]]);
|
| 2094 |
h_Z_phiAll[2]->Fill(ElPhi[electronIndex[1]]);
|
| 2095 |
h_Z_deltaPhi[2]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
|
| 2096 |
h_Z_ptDiLepton[2]->Fill((e1+e2).Pt());
|
| 2097 |
h_Z_etaDiLepton[2]->Fill((e1+e2).Eta());
|
| 2098 |
h_Z_phiDiLepton[2]->Fill((e1+e2).Phi());
|
| 2099 |
|
| 2100 |
// now variables with "jetty" content
|
| 2101 |
h_Z_nJets[2]->Fill(jetIndex.size());
|
| 2102 |
if(jetIndex.size()>0) {
|
| 2103 |
h_Z_leadingJetPt[2]->Fill(JPt[jetIndex[0]]);
|
| 2104 |
h_Z_leadingJetEta[2]->Fill(JEta[jetIndex[0]]);
|
| 2105 |
h_Z_leadingJetPhi[2]->Fill(JPhi[jetIndex[0]]);
|
| 2106 |
h_Z_summedJetPt[2]->Fill(summedJetPt);
|
| 2107 |
h_Z_summedJetEta[2]->Fill(summedJetEta);
|
| 2108 |
h_Z_summedJetPhi[2]->Fill(summedJetPhi);
|
| 2109 |
|
| 2110 |
h_Z_leadingJetDeltaPt[2]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
|
| 2111 |
h_Z_leadingJetDeltaEta[2]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
|
| 2112 |
h_Z_leadingJetDeltaPhi[2]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
|
| 2113 |
h_Z_summedJetDeltaPt[2]->Fill(summedJetPt - (e1+e2).Pt());
|
| 2114 |
h_Z_summedJetDeltaEta[2]->Fill(summedJetEta - (e1+e2).Eta());
|
| 2115 |
h_Z_summedJetDeltaPhi[2]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
|
| 2116 |
|
| 2117 |
h_Z_recoilPt[2]->Fill(recoilPt);
|
| 2118 |
h_Z_recoilEta[2]->Fill(recoilEta);
|
| 2119 |
h_Z_recoilPhi[2]->Fill(recoilPhi);
|
| 2120 |
h_Z_metPt[2]->Fill(met);
|
| 2121 |
// h_Z_metEta[2]->Fill(metEta);
|
| 2122 |
h_Z_metPhi[2]->Fill(metPhi);
|
| 2123 |
}
|
| 2124 |
|
| 2125 |
}
|
| 2126 |
// check one in barrel the other in endcap
|
| 2127 |
if((fabs(ElEta[electronIndex[0]]) < etaBarrelMax && fabs(ElEta[electronIndex[1]]) > etaBarrelMax) ||
|
| 2128 |
(fabs(ElEta[electronIndex[1]]) < etaBarrelMax && fabs(ElEta[electronIndex[0]]) > etaBarrelMax) ) {
|
| 2129 |
h_Z_invMass[3]->Fill(invMass);
|
| 2130 |
|
| 2131 |
h_Z_ptAll[3]->Fill(ElPt[electronIndex[0]]);
|
| 2132 |
h_Z_ptAll[3]->Fill(ElPt[electronIndex[1]]);
|
| 2133 |
h_Z_etaAll[3]->Fill(ElEta[electronIndex[0]]);
|
| 2134 |
h_Z_etaAll[3]->Fill(ElEta[electronIndex[1]]);
|
| 2135 |
h_Z_phiAll[3]->Fill(ElPhi[electronIndex[0]]);
|
| 2136 |
h_Z_phiAll[3]->Fill(ElPhi[electronIndex[1]]);
|
| 2137 |
h_Z_deltaPhi[3]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
|
| 2138 |
h_Z_ptDiLepton[3]->Fill((e1+e2).Pt());
|
| 2139 |
h_Z_etaDiLepton[3]->Fill((e1+e2).Eta());
|
| 2140 |
h_Z_phiDiLepton[3]->Fill((e1+e2).Phi());
|
| 2141 |
|
| 2142 |
// now variables with "jetty" content
|
| 2143 |
h_Z_nJets[3]->Fill(jetIndex.size());
|
| 2144 |
if(jetIndex.size()>0) {
|
| 2145 |
h_Z_leadingJetPt[3]->Fill(JPt[jetIndex[0]]);
|
| 2146 |
h_Z_leadingJetEta[3]->Fill(JEta[jetIndex[0]]);
|
| 2147 |
h_Z_leadingJetPhi[3]->Fill(JPhi[jetIndex[0]]);
|
| 2148 |
h_Z_summedJetPt[3]->Fill(summedJetPt);
|
| 2149 |
h_Z_summedJetEta[3]->Fill(summedJetEta);
|
| 2150 |
h_Z_summedJetPhi[3]->Fill(summedJetPhi);
|
| 2151 |
|
| 2152 |
h_Z_leadingJetDeltaPt[3]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
|
| 2153 |
h_Z_leadingJetDeltaEta[3]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
|
| 2154 |
h_Z_leadingJetDeltaPhi[3]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
|
| 2155 |
h_Z_summedJetDeltaPt[3]->Fill(summedJetPt - (e1+e2).Pt());
|
| 2156 |
h_Z_summedJetDeltaEta[3]->Fill(summedJetEta - (e1+e2).Eta());
|
| 2157 |
h_Z_summedJetDeltaPhi[3]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
|
| 2158 |
|
| 2159 |
h_Z_recoilPt[3]->Fill(recoilPt);
|
| 2160 |
h_Z_recoilEta[3]->Fill(recoilEta);
|
| 2161 |
h_Z_recoilPhi[3]->Fill(recoilPhi);
|
| 2162 |
h_Z_metPt[3]->Fill(met);
|
| 2163 |
// h_Z_metEta[3]->Fill(metEta);
|
| 2164 |
h_Z_metPhi[3]->Fill(metPhi);
|
| 2165 |
}
|
| 2166 |
}
|
| 2167 |
|
| 2168 |
|
| 2169 |
// debug++;
|
| 2170 |
}
|
| 2171 |
// --------------------------------------------------------------------------------------------------------------------
|
| 2172 |
|
| 2173 |
|
| 2174 |
// //--------------------------------------------------------------------------------------------------------------------
|
| 2175 |
// // jet cleaning (new)
|
| 2176 |
// //--------------------------------------------------------------------------------------------------------------------
|
| 2177 |
|
| 2178 |
// // the new number of jets is the size of the jetIndex vector
|
| 2179 |
// // use that for jet veto...
|
| 2180 |
// TLorentzVector electron;
|
| 2181 |
// TLorentzVector jet;
|
| 2182 |
// double deltaR=999;
|
| 2183 |
// for(int j=0; j<NJets; j++) {
|
| 2184 |
// if(JPt[j]<jetPtMin || fabs(JEta[j])>jetEtaMax) continue;
|
| 2185 |
// jet.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
|
| 2186 |
|
| 2187 |
// for(int e=0;e<electronIndex.size();e++) {
|
| 2188 |
// int index=electronIndex[e];
|
| 2189 |
// electron.SetPtEtaPhiE(ElPt[index] * PtCorrection ,ElEta[index],ElPhi[index],ElE[index]);
|
| 2190 |
|
| 2191 |
|
| 2192 |
// deltaR=jet.DeltaR(electron);
|
| 2193 |
// // cout<<deltaR<<endl;
|
| 2194 |
// }
|
| 2195 |
// if(deltaR<deltaRMax) continue;
|
| 2196 |
// jetIndex.push_back(j);
|
| 2197 |
// }
|
| 2198 |
|
| 2199 |
// //--------------------------------------------------------------------------------------------------------------------
|
| 2200 |
|
| 2201 |
|
| 2202 |
|
| 2203 |
//--------------------------------------------------------------------------------------------------------------------
|
| 2204 |
// W selection (new)
|
| 2205 |
//--------------------------------------------------------------------------------------------------------------------
|
| 2206 |
if(electronIndex.size()==1) {
|
| 2207 |
|
| 2208 |
|
| 2209 |
int Wcut;
|
| 2210 |
double dphiMax=2.8;
|
| 2211 |
double delPhiMet=deltaPhi(ElPhi[electronIndex[0]], PFMETphi);
|
| 2212 |
double Mt=transverseMass(ElPt[electronIndex[0]] * PtCorrection, met, delPhiMet);
|
| 2213 |
double Pt=ElPt[electronIndex[0]] * PtCorrection;
|
| 2214 |
double Eta=ElEta[electronIndex[0]];
|
| 2215 |
double Phi=ElPhi[electronIndex[0]];
|
| 2216 |
double Charge=ElCharge[electronIndex[0]];
|
| 2217 |
int Njets=jetIndex.size();
|
| 2218 |
|
| 2219 |
///////////////////
|
| 2220 |
// plots for barrel
|
| 2221 |
///////////////////
|
| 2222 |
|
| 2223 |
|
| 2224 |
// if(WSelection(electronIndex[0], full)==0) {
|
| 2225 |
// fprintf(out,"%i\t%i\n",Run, Event);
|
| 2226 |
// cout<<"Run: "<<Run<<" Event: "<<Event<<endl;
|
| 2227 |
// }
|
| 2228 |
|
| 2229 |
|
| 2230 |
|
| 2231 |
if(fabs(ElEta[electronIndex[0]])<etaBarrelMax) {
|
| 2232 |
|
| 2233 |
///////////
|
| 2234 |
// N jets
|
| 2235 |
//////////
|
| 2236 |
|
| 2237 |
// fill plots after preselection
|
| 2238 |
if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
|
| 2239 |
Wcounter[0]++;
|
| 2240 |
Wcut=0;
|
| 2241 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2242 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2243 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2244 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2245 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2246 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2247 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2248 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2249 |
}
|
| 2250 |
|
| 2251 |
// fill N-1 plots
|
| 2252 |
|
| 2253 |
if(WSelection(electronIndex[0], misset)==0) {
|
| 2254 |
Wcut=1;
|
| 2255 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2256 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2257 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2258 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2259 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2260 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2261 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2262 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2263 |
}
|
| 2264 |
if(WSelection(electronIndex[0], pt)==0) {
|
| 2265 |
Wcut=2;
|
| 2266 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2267 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2268 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2269 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2270 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2271 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2272 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2273 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2274 |
}
|
| 2275 |
if(WSelection(electronIndex[0], mt)==0) {
|
| 2276 |
Wcut=3;
|
| 2277 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2278 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2279 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2280 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2281 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2282 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2283 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2284 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2285 |
}
|
| 2286 |
if(WSelection(electronIndex[0], full)==0) {
|
| 2287 |
Wcounter[1]++;
|
| 2288 |
Wcut=4;
|
| 2289 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2290 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2291 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2292 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2293 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2294 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2295 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2296 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2297 |
// split charge
|
| 2298 |
if(Charge==1) {
|
| 2299 |
Wcounter[2]++;
|
| 2300 |
Wcut=5 ;
|
| 2301 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2302 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2303 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2304 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2305 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2306 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2307 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2308 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2309 |
}
|
| 2310 |
else if(Charge==-1) {
|
| 2311 |
Wcounter[3]++;
|
| 2312 |
Wcut=6 ;
|
| 2313 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2314 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2315 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2316 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2317 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2318 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2319 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2320 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2321 |
} // charge
|
| 2322 |
} // W selection
|
| 2323 |
|
| 2324 |
|
| 2325 |
///////////
|
| 2326 |
// 0 jets
|
| 2327 |
//////////
|
| 2328 |
|
| 2329 |
if(njets==0) {
|
| 2330 |
|
| 2331 |
// fill plots after preselection
|
| 2332 |
if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
|
| 2333 |
Wcounter[4]++;
|
| 2334 |
Wcut=7;
|
| 2335 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2336 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2337 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2338 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2339 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2340 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2341 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2342 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2343 |
}
|
| 2344 |
|
| 2345 |
// fill N-1 plots
|
| 2346 |
|
| 2347 |
if(WSelection(electronIndex[0], misset)==0) {
|
| 2348 |
Wcut=8;
|
| 2349 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2350 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2351 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2352 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2353 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2354 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2355 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2356 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2357 |
}
|
| 2358 |
if(WSelection(electronIndex[0], pt)==0) {
|
| 2359 |
Wcut=9;
|
| 2360 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2361 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2362 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2363 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2364 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2365 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2366 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2367 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2368 |
}
|
| 2369 |
if(WSelection(electronIndex[0], mt)==0) {
|
| 2370 |
Wcut=10;
|
| 2371 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2372 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2373 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2374 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2375 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2376 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2377 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2378 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2379 |
}
|
| 2380 |
if(WSelection(electronIndex[0], full)==0) {
|
| 2381 |
Wcounter[5]++;
|
| 2382 |
Wcut=11;
|
| 2383 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2384 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2385 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2386 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2387 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2388 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2389 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2390 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2391 |
|
| 2392 |
// split charge
|
| 2393 |
if(Charge==1) {
|
| 2394 |
Wcounter[6]++;
|
| 2395 |
Wcut=12;
|
| 2396 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2397 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2398 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2399 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2400 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2401 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2402 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2403 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2404 |
}
|
| 2405 |
else if(Charge==-1) {
|
| 2406 |
Wcounter[7]++;
|
| 2407 |
Wcut=13;
|
| 2408 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2409 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2410 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2411 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2412 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2413 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2414 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2415 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2416 |
}
|
| 2417 |
} // W selection
|
| 2418 |
} // 0 jets
|
| 2419 |
|
| 2420 |
///////////
|
| 2421 |
// 1 jet
|
| 2422 |
//////////
|
| 2423 |
|
| 2424 |
if(njets==1) {
|
| 2425 |
|
| 2426 |
// fill plots after preselection
|
| 2427 |
if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
|
| 2428 |
Wcounter[8]++;
|
| 2429 |
Wcut=14;
|
| 2430 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2431 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2432 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2433 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2434 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2435 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2436 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2437 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2438 |
}
|
| 2439 |
|
| 2440 |
// fill N-1 plots
|
| 2441 |
|
| 2442 |
// leaving the delta phi Wcut
|
| 2443 |
double dphi = deltaPhi(ElPhi[electronIndex[0]], JPhi[jetIndex[0]]);
|
| 2444 |
if(WSelection(electronIndex[0], full)==0) {
|
| 2445 |
Wcut=15;
|
| 2446 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2447 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2448 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2449 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2450 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2451 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2452 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2453 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2454 |
}
|
| 2455 |
|
| 2456 |
// now I have to apply the delta phi Wcut!
|
| 2457 |
|
| 2458 |
if(fabs(dphi)<dphiMax) {
|
| 2459 |
|
| 2460 |
if(WSelection(electronIndex[0], misset)==0) {
|
| 2461 |
Wcut=16;
|
| 2462 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2463 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2464 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2465 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2466 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2467 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2468 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2469 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2470 |
}
|
| 2471 |
if(WSelection(electronIndex[0], pt)==0) {
|
| 2472 |
Wcut=17;
|
| 2473 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2474 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2475 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2476 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2477 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2478 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2479 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2480 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2481 |
}
|
| 2482 |
if(WSelection(electronIndex[0], mt)==0) {
|
| 2483 |
Wcut=18;
|
| 2484 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2485 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2486 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2487 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2488 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2489 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2490 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2491 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2492 |
}
|
| 2493 |
if(WSelection(electronIndex[0], full)==0) {
|
| 2494 |
Wcounter[9]++;
|
| 2495 |
Wcut=19;
|
| 2496 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2497 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2498 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2499 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2500 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2501 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2502 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2503 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2504 |
// split charge
|
| 2505 |
if(Charge==1) {
|
| 2506 |
Wcounter[10]++;
|
| 2507 |
Wcut=20;
|
| 2508 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2509 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2510 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2511 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2512 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2513 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2514 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2515 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2516 |
}
|
| 2517 |
else if(Charge==-1) {
|
| 2518 |
Wcounter[11]++;
|
| 2519 |
Wcut=21;
|
| 2520 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2521 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2522 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2523 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2524 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2525 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2526 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2527 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2528 |
} // charge
|
| 2529 |
} // W sel
|
| 2530 |
} // dphi Wcut
|
| 2531 |
} // 1 jet
|
| 2532 |
|
| 2533 |
//////////
|
| 2534 |
// >1 jet
|
| 2535 |
//////////
|
| 2536 |
|
| 2537 |
if(njets>1) {
|
| 2538 |
|
| 2539 |
// fill plots after preselection
|
| 2540 |
if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
|
| 2541 |
Wcounter[12]++;
|
| 2542 |
Wcut=22;
|
| 2543 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2544 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2545 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2546 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2547 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2548 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2549 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2550 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2551 |
}
|
| 2552 |
|
| 2553 |
// fill N-1 plots
|
| 2554 |
|
| 2555 |
if(WSelection(electronIndex[0], misset)==0) {
|
| 2556 |
Wcut=23;
|
| 2557 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2558 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2559 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2560 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2561 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2562 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2563 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2564 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2565 |
}
|
| 2566 |
if(WSelection(electronIndex[0], pt)==0) {
|
| 2567 |
Wcut=24;
|
| 2568 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2569 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2570 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2571 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2572 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2573 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2574 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2575 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2576 |
}
|
| 2577 |
if(WSelection(electronIndex[0], mt)==0) {
|
| 2578 |
Wcut=25;
|
| 2579 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2580 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2581 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2582 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2583 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2584 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2585 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2586 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2587 |
}
|
| 2588 |
if(WSelection(electronIndex[0], full)==0) {
|
| 2589 |
Wcounter[13]++;
|
| 2590 |
Wcut=26;
|
| 2591 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2592 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2593 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2594 |
// hs_W_ElDeltaPhi[Wcut]->Fill();
|
| 2595 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2596 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2597 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2598 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2599 |
// split charge
|
| 2600 |
if(Charge==1) {
|
| 2601 |
Wcounter[14]++;
|
| 2602 |
Wcut=27;
|
| 2603 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2604 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2605 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2606 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2607 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2608 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2609 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2610 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2611 |
}
|
| 2612 |
else if(Charge==-1) {
|
| 2613 |
Wcounter[15]++;
|
| 2614 |
Wcut=28;
|
| 2615 |
hs_W_ElTransMass[Wcut]->Fill(Mt);
|
| 2616 |
hs_W_ElPt[Wcut]->Fill(Pt);
|
| 2617 |
hs_W_ElEta[Wcut]->Fill(Eta);
|
| 2618 |
hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
|
| 2619 |
hs_W_ElMet[Wcut]->Fill(met);
|
| 2620 |
hs_W_ElCharge[Wcut]->Fill(Charge);
|
| 2621 |
hs_W_Njets[Wcut]->Fill(njets);
|
| 2622 |
hs_W_ElPhi[Wcut]->Fill(Phi);
|
| 2623 |
} //charge
|
| 2624 |
} // w sel
|
| 2625 |
} // > 1 jets
|
| 2626 |
|
| 2627 |
} // barrel
|
| 2628 |
|
| 2629 |
else if(fabs(ElEta[electronIndex[0]])>etaBarrelMax && fabs(ElEta[electronIndex[0]])<etaEndcapMax) {
|
| 2630 |
if(WSelection(electronIndex[0], pre)==0) {debug++; cout<<"W found"<<endl;}
|
| 2631 |
// cout<<"Run: "<<Run<<" Event: "<<Event<<endl;
|
| 2632 |
|
| 2633 |
}
|
| 2634 |
|
| 2635 |
}
|
| 2636 |
//--------------------------------------------------------------------------------------------------------------------
|
| 2637 |
|
| 2638 |
|
| 2639 |
|
| 2640 |
|
| 2641 |
////////////////////////////////////////////////////////////////////
|
| 2642 |
////////////////////// User's code ends here ///////////////////////
|
| 2643 |
////////////////////////////////////////////////////////////////////
|
| 2644 |
|
| 2645 |
} // End loop over events
|
| 2646 |
|
| 2647 |
END:
|
| 2648 |
cerr<<"Program ended after "<<sampleSize<<" events ..."<<endl;
|
| 2649 |
|
| 2650 |
|
| 2651 |
for(int b=0;b<MAXWcounter;b++) {
|
| 2652 |
hc_W_counter->SetBinContent(b+1,Wcounter[b]);
|
| 2653 |
}
|
| 2654 |
for(int b=0;b<counterSize;b++) {
|
| 2655 |
hc_El_counter->SetBinContent(b+1,counter[b]);
|
| 2656 |
}
|
| 2657 |
|
| 2658 |
|
| 2659 |
fclose(out);
|
| 2660 |
fclose(out_Z);
|
| 2661 |
|
| 2662 |
|
| 2663 |
|
| 2664 |
cout<<counterTight<<endl;
|
| 2665 |
cout<<counterETH<<endl;
|
| 2666 |
|
| 2667 |
cout<<"Total number of robust electrons (sequential cuts): "<<c_robust_B/*+c_robust_E*/<<endl;
|
| 2668 |
cout<<"Total number of robust electrons (out of tree): "<<c_robust_tree<<endl;
|
| 2669 |
|
| 2670 |
cout<<"# of electrons with cGsf == cSC: "<<cNa<<endl;
|
| 2671 |
cout<<"# of electrons with cGsf != cSC: "<<cNb<<endl;
|
| 2672 |
|
| 2673 |
cout<<"N_t: "<<N_tt<<" N_t0: "<<N_t0<<endl;
|
| 2674 |
if(N_tt>0) {
|
| 2675 |
double effy = ((double) 2*N_tt/(N_t0+N_tt));
|
| 2676 |
cout<<"Electron ID efficiency (tag&probe): "<<effy<<endl;
|
| 2677 |
}
|
| 2678 |
else cout<<"No tag & probe available!"<<endl;
|
| 2679 |
cout<<"debug: "<<debug<<endl;
|
| 2680 |
|
| 2681 |
for(int ci=0; ci<15; ci++) {
|
| 2682 |
cout<<ci<<": "<<counter[ci]<<endl;
|
| 2683 |
}
|
| 2684 |
|
| 2685 |
|
| 2686 |
|
| 2687 |
delete [] counter;
|
| 2688 |
counter=NULL;
|
| 2689 |
delete [] Wcounter;
|
| 2690 |
Wcounter=NULL;
|
| 2691 |
|
| 2692 |
//////////write histos
|
| 2693 |
h_jetPt->Write();
|
| 2694 |
|
| 2695 |
// acceptance plots
|
| 2696 |
h_ElEtaVsScEta->Write();
|
| 2697 |
// h_ElPhiVsScPhi->Write();
|
| 2698 |
h_ElPtVsScEt->Write();
|
| 2699 |
|
| 2700 |
// sum barrel and endcap into general plots
|
| 2701 |
for(int a=34; a<MAXE; a++) {
|
| 2702 |
hs_El_ElPt[a]->Add(hs_El_ElPt[a-7]);
|
| 2703 |
hs_El_ElPt[a]->Add(hs_El_ElPt[a-14]);
|
| 2704 |
hs_El_ElEta[a]->Add(hs_El_ElEta[a-7]);
|
| 2705 |
hs_El_ElEta[a]->Add(hs_El_ElEta[a-14]);
|
| 2706 |
hs_El_ElPhi[a]->Add(hs_El_ElPhi[a-7]);
|
| 2707 |
hs_El_ElPhi[a]->Add(hs_El_ElPhi[a-14]);
|
| 2708 |
hs_El_ElCharge[a]->Add(hs_El_ElCharge[a-7]);
|
| 2709 |
hs_El_ElCharge[a]->Add(hs_El_ElCharge[a-14]);
|
| 2710 |
hs_El_ElDeltaPhi[a]->Add(hs_El_ElDeltaPhi[a-7]);
|
| 2711 |
hs_El_ElDeltaPhi[a]->Add(hs_El_ElDeltaPhi[a-14]);
|
| 2712 |
hs_El_ElDeltaEta[a]->Add(hs_El_ElDeltaEta[a-7]);
|
| 2713 |
hs_El_ElDeltaEta[a]->Add(hs_El_ElDeltaEta[a-14]);
|
| 2714 |
hs_El_ElTransMass[a]->Add(hs_El_ElTransMass[a-7]);
|
| 2715 |
hs_El_ElTransMass[a]->Add(hs_El_ElTransMass[a-14]);
|
| 2716 |
hs_El_ElHoverE[a]->Add(hs_El_ElHoverE[a-7]);
|
| 2717 |
hs_El_ElHoverE[a]->Add(hs_El_ElHoverE[a-14]);
|
| 2718 |
hs_El_ElSigmaIetaIeta[a]->Add(hs_El_ElSigmaIetaIeta[a-7]);
|
| 2719 |
hs_El_ElSigmaIetaIeta[a]->Add(hs_El_ElSigmaIetaIeta[a-14]);
|
| 2720 |
hs_El_ElNumberOfMissingInnerHits[a]->Add(hs_El_ElNumberOfMissingInnerHits[a-7]);
|
| 2721 |
hs_El_ElNumberOfMissingInnerHits[a]->Add(hs_El_ElNumberOfMissingInnerHits[a-14]);
|
| 2722 |
hs_El_ElCombIso[a]->Add(hs_El_ElCombIso[a-7]);
|
| 2723 |
hs_El_ElCombIso[a]->Add(hs_El_ElCombIso[a-14]);
|
| 2724 |
}
|
| 2725 |
|
| 2726 |
|
| 2727 |
|
| 2728 |
// write the plots to the *.root file
|
| 2729 |
|
| 2730 |
h_numberOfEvents->Write();
|
| 2731 |
|
| 2732 |
if(writeIdPlots==true) {
|
| 2733 |
for(int i=0;i<MAXE;i++) {
|
| 2734 |
hs_El_ElPt[i]->Write();
|
| 2735 |
hs_El_ElEta[i]->Write();
|
| 2736 |
hs_El_ElPhi[i]->Write();
|
| 2737 |
hs_El_ElDeltaPhi[i]->Write();
|
| 2738 |
hs_El_ElMet[i]->Write();
|
| 2739 |
hs_El_ElTransMass[i]->Write();
|
| 2740 |
hs_El_ElCharge[i]->Write();
|
| 2741 |
hs_El_Njets[i]->Write();
|
| 2742 |
hs_El_ElDeltaPhi[i]->Write();
|
| 2743 |
hs_El_ElDeltaEta[i]->Write();
|
| 2744 |
hs_El_ElOneOverEminusOneOverP[i]->Write();
|
| 2745 |
hs_El_ElTransMass[i]->Write();
|
| 2746 |
hs_El_Njets[i]->Write();
|
| 2747 |
hs_El_ElEthIso[i]->Write();
|
| 2748 |
hs_El_ElTrkIso[i]->Write();
|
| 2749 |
hs_El_ElEcalIso[i]->Write();
|
| 2750 |
hs_El_ElHcalIso[i]->Write();
|
| 2751 |
hs_El_ElCombIso[i]->Write();
|
| 2752 |
hs_El_ElHoverE[i]->Write();
|
| 2753 |
hs_El_ElSigmaIetaIeta[i]->Write();
|
| 2754 |
hs_El_ElNumberOfMissingInnerHits[i]->Write();
|
| 2755 |
}
|
| 2756 |
hc_El_counter->Write();
|
| 2757 |
}
|
| 2758 |
|
| 2759 |
|
| 2760 |
if(writeN1Plots==true) {
|
| 2761 |
for(int i=0; i<MAXN; i++) {
|
| 2762 |
hn1_El_ElDeltaPhi[i]->Write();
|
| 2763 |
hn1_El_ElDeltaEta[i]->Write();
|
| 2764 |
hn1_El_ElOneOverEminusOneOverP[i]->Write();
|
| 2765 |
|
| 2766 |
// hn1_El_ElPt[i]->Write();
|
| 2767 |
// hn1_El_ElEta[i]->Write();
|
| 2768 |
// hn1_El_ElPhi[i]->Write();
|
| 2769 |
// hn1_El_ElMet[i]->Write();
|
| 2770 |
// hn1_El_ElTransMass[i]->Write();
|
| 2771 |
// hn1_El_ElCharge[i]->Write();
|
| 2772 |
// hn1_El_Njets[i]->Write();
|
| 2773 |
// hn1_El_ElTransMass[i]->Write();
|
| 2774 |
// hn1_El_Njets[i]->Write();
|
| 2775 |
hn1_El_ElEthIso[i]->Write();
|
| 2776 |
// hn1_El_ElTrkIso[i]->Write();
|
| 2777 |
// hn1_El_ElEcalIso[i]->Write();
|
| 2778 |
// hn1_El_ElHcalIso[i]->Write();
|
| 2779 |
hn1_El_ElCombIso[i]->Write();
|
| 2780 |
hn1_El_ElHoverE[i]->Write();
|
| 2781 |
hn1_El_ElSigmaIetaIeta[i]->Write();
|
| 2782 |
hn1_El_ElNumberOfMissingInnerHits[i]->Write();
|
| 2783 |
}
|
| 2784 |
}
|
| 2785 |
if(writeWenuPlots) {
|
| 2786 |
for(int i=0;i<MAXS;i++) {
|
| 2787 |
hs_W_ElPt[i]->Write();
|
| 2788 |
hs_W_ElEta[i]->Write();
|
| 2789 |
hs_W_ElPhi[i]->Write();
|
| 2790 |
hs_W_ElDeltaPhi[i]->Write();
|
| 2791 |
hs_W_ElMet[i]->Write();
|
| 2792 |
hs_W_ElTransMass[i]->Write();
|
| 2793 |
hs_W_ElCharge[i]->Write();
|
| 2794 |
hs_W_Njets[i]->Write();
|
| 2795 |
}
|
| 2796 |
hc_W_counter->Write();
|
| 2797 |
}
|
| 2798 |
|
| 2799 |
for(int i=0;i<MAXZ;i++) {
|
| 2800 |
h_Z_invMass[i]->Write();
|
| 2801 |
h_Z_ptAll[i]->Write();
|
| 2802 |
h_Z_etaAll[i]->Write();
|
| 2803 |
h_Z_phiAll[i]->Write();
|
| 2804 |
h_Z_deltaPhi[i]->Write();
|
| 2805 |
h_Z_ptDiLepton[i]->Write();
|
| 2806 |
h_Z_etaDiLepton[i]->Write();
|
| 2807 |
h_Z_phiDiLepton[i]->Write();
|
| 2808 |
|
| 2809 |
h_Z_leadingJetPt[i]->Write();
|
| 2810 |
h_Z_summedJetPt[i]->Write();
|
| 2811 |
h_Z_leadingJetEta[i]->Write();
|
| 2812 |
h_Z_summedJetEta[i]->Write();
|
| 2813 |
h_Z_leadingJetPhi[i]->Write();
|
| 2814 |
h_Z_summedJetPhi[i]->Write();
|
| 2815 |
h_Z_nJets[i]->Write();
|
| 2816 |
h_Z_leadingJetDeltaPt[i]->Write();
|
| 2817 |
h_Z_leadingJetDeltaEta[i]->Write();
|
| 2818 |
h_Z_leadingJetDeltaPhi[i]->Write();
|
| 2819 |
h_Z_summedJetDeltaPt[i]->Write();
|
| 2820 |
h_Z_summedJetDeltaEta[i]->Write();
|
| 2821 |
h_Z_summedJetDeltaPhi[i]->Write();
|
| 2822 |
h_Z_recoilPt[i]->Write();
|
| 2823 |
h_Z_recoilEta[i]->Write();
|
| 2824 |
h_Z_recoilPhi[i]->Write();
|
| 2825 |
h_Z_metPt[i]->Write();
|
| 2826 |
h_Z_metEta[i]->Write();
|
| 2827 |
h_Z_metPhi[i]->Write();
|
| 2828 |
|
| 2829 |
}
|
| 2830 |
std::cout << "analysisClass::Loop() ends" <<std::endl;
|
| 2831 |
}
|
| 2832 |
|
| 2833 |
|
