btEntry *btRangeNext(btSIter *siter, bool asc) { //printf("btRangeNext\n");
//printf("btRangeNext: siter: %p\n", (void *)siter);
//if (siter) printf("btRangeNext: empty: %d\n", siter->empty);
if (!siter || siter->empty) return NULL;
bt_n *x = NULL;
int i = -1;
uchar *stream = btNext(siter, &x, &i, asc);
if (!streamToBTEntry(stream, siter, x, i)) return NULL;
if (C_IS_I(siter->ktype) || C_IS_L(siter->ktype) || C_IS_G(siter->ktype)) {
long l = C_IS_I(siter->ktype) ? (ulong)(siter->key.i) : siter->key.l;
if (l == siter->x.high) siter->x.finished = 1; /* exact match */
if (!asc) {
//printf("btRangeNext: DESC: l: %lu dr: %u\n",
// l, getDR(siter->x.btr, x, i));
l += getDR(siter->x.btr, x, i);
}
bool over = asc ? (l > siter->x.high) : (l < siter->x.high);
if (over && siter->nim) {
siter->missed = 1;
}
//printf("btRangeNext: over: %d l: %lu high: %lu\n",
// over, l, siter->x.high);
return over ? NULL : &(siter->be);
} else if (C_IS_X(siter->ktype)) {
uint128 xx = siter->key.x;
if (xx == siter->x.highx) siter->x.finished = 1; /* exact match */
if (!asc) {
xx += getDR(siter->x.btr, x, i);
}
bool over = asc ? (xx > siter->x.highx) : (xx < siter->x.highx);
return over ? NULL : &(siter->be);
} else if (C_IS_Y(siter->ktype)) {
uint160 yy = siter->key.y;
int ret = u160Cmp(&yy, &siter->x.highy);
if (!ret) siter->x.finished = 1; /* exact match */
if (!asc) { //TODO is ENDIANness of memcpy() correct
uint32 low;
char *spot = ((char *)&yy) + 12;
memcpy(&low, spot, 4);
low += getDR(siter->x.btr, x, i);
memcpy(spot, &low, 4);
}
bool over = asc ? (ret > 0) : (ret < 0);
return over ? NULL : &(siter->be);
} else if (C_IS_F(siter->ktype)) {
float f = siter->key.f;
if (f == siter->x.highf) siter->x.finished = 1; /* exact match */
return asc ? ((f <= siter->x.highf) ? & (siter->be) : NULL) :
((f >= siter->x.highf) ? & (siter->be) : NULL);
} else { // C_IS_S()
int r = strncmp(siter->key.s, siter->x.highs, siter->key.len);
if (r == 0) siter->x.finished = 1; /* exact match */
return asc ? ((r <= 0) ? & (siter->be) : NULL) :
((r >= 0) ? & (siter->be) : NULL);
}
}
static void iter_leaf_dirty_scion(btIterator *iter) {
//printf("iter_leaf_dirty_scion: ik: %d n: %d\n",
// iter->bln->ik, iter->bln->self->n);
bt *btr = iter->btr;
fol_t *fl = (fol_t *)iter->data;
long cnt = 0;
while (iter->bln->ik < iter->bln->self->n) { // DRs added individually
cnt += (isGhostRow(btr, iter->bln->self, iter->bln->ik) ? 0 : 1) +
getDR (btr, iter->bln->self, iter->bln->ik);// 1forRow + DR
long fcnt = fl->cnt + cnt; //DEBUG_ITER_LEAF_DIRTY_SCION
if (fcnt == fl->ofst) {
fl->over = 0;
iter->bln->ik++;
return;
}
if (fcnt > fl->ofst) {
fl->over = fcnt - fl->ofst;
return;
}
iter->bln->ik++;
}
fl->cnt += cnt;
fl->diff = fl->ofst - fl->cnt;
iter->bln->in = iter->bln->self->n;
toparentrecurse(iter);
}
void
introuble2_ASL(ASL *asl, const char *who, real a, real b, int jv)
{
static const char fmt[] = "can't evaluate %s(%g,%g).\n";
#ifndef ASL_OLD_DERIV_CHECK /*{*/
DerrRecord *R;
if (jv > 1 && !(want_deriv & 2)) {
if ((R = getDR(asl))) {
R->errprint = derrprint2;
R->a = a;
R->u.b = b;
R->jv = jv;
R->fmt = fmt;
R->who = who;
}
return;
}
#endif /*}*/
jmp_check(err_jmp, jv);
report_where(asl);
Errprint(fmt, who, a, b);
jmp_check(err_jmp1, jv);
exit(1);
}
static bool XthIterFind(btSIter *siter, ai_obj *alow, ai_obj *ahigh,
long ofst, bool asc, bt *btr) {
btk_t btk;
bool med;
uint32 ksize;
btIterator *iter = &siter->x;
char *bkey = createBTKey(asc ? alow : ahigh,
&med, &ksize, btr, &btk); // DEST 031
if (!bkey) return 0;
bt_n *x = NULL;
int i = -1;
bool d = btr->dirty;
uchar *stream = setIter(btr, bkey, siter, asc ? alow : ahigh, &x, &i, asc);
destroyBTKey(bkey, med); // DESTROYED 031
if (!streamToBTEntry(stream, siter, x, i)) return 0;
fol_t fl;
bzero(&fl, sizeof(fol_t));
fl.ofst = ofst;
fl.over = -1;
// NEXT_LINE: Switch to SCION ITERATORS
iter->iLeaf = asc ? (d ? iter_leaf_dirty_scion : iter_leaf_scion) :
(d ? iter_leaf_dirty_scion_rev : iter_leaf_scion_rev);
iter->iNode = asc ? iter_node_scion : iter_node_scion_rev;
iter->data = &fl;
while (1) {
void *be = btNext(siter, NULL, NULL, asc);
if (!be) break;
if (fl.over != -1) { //printf("ik: %d ovr: %d\n",iter->bln->ik,fl.over);
if (asc) {
if (!d) iter->bln->ik += fl.over; // Dirty Iterators are exact
if (iter->bln->ik == iter->bln->self->n) {
iter->bln->ik--;
toparentrecurse(iter);
}
} else {
if (!d) iter->bln->ik -= fl.over; // Dirty Iterators are exact
if (iter->bln->ik < 0) {
iter->bln->in = iter->bln->ik = 0;
toparentrecurserev(iter);
}
}
break;
}
}
INIT_ITER_BEENTRY(siter, btr, siter->x.bln->self, siter->x.bln->ik)
siter->nim = siter->missed = 0; //DEBUG_XTH_ITER_FIND_POST_LOOP
if (d && fl.over > 0 && getDR(btr, siter->x.bln->self, siter->x.bln->ik)) {
siter->missed = 1;
} //DEBUG_XTH_ITER_FIND_END
iter->iLeaf = asc ? iter_leaf : iter_leaf_rev; // Back to NORMAL ITERATORS
iter->iNode = asc ? iter_node : iter_node_rev;
return 1;
}
static void iter_node_scion(btIterator *iter) {
bt *btr = iter->btr;
fol_t *fl = (fol_t *)iter->data;
uchar kid_in = (iter->bln->in == iter->bln->self->n) ? iter->bln->in :
iter->bln->in + 1;
bt_n *kid = NODES(btr, iter->bln->self)[kid_in];
bool scioned = (fl->diff > kid->scion); //DEBUG_ITER_NODE_SCION
if (scioned) {
fl->cnt += kid->scion + 1; // +1 for NODE itself
if (btr->dirty) fl->cnt += getDR(btr, iter->bln->self, iter->bln->ik);
fl->diff = fl->ofst - fl->cnt;
if (fl->diff < 0) {
fl->over = 0;
return;
}
if ((iter->bln->ik + 1) < iter->bln->self->n) iter->bln->ik++;
if ((iter->bln->in + 1) < iter->bln->self->n) iter->bln->in++;
else toparentrecurse(iter);
if (!fl->diff) {
fl->over = 0;
return;
}
} else {
fl->cnt++;
if (btr->dirty) fl->cnt += getDR(btr, iter->bln->self, iter->bln->ik);
fl->diff = fl->ofst - fl->cnt;
if (fl->diff < 0) {
fl->over = 0;
return;
}
if ((iter->bln->ik + 1) < iter->bln->self->n) iter->bln->ik++;
iter->bln->in++;
GET_NEW_CHILD(iter)
tochildrecurse(iter, NODES(btr, iter->bln->self)[iter->bln->in]);
if (!fl->diff) {
fl->over = 0;
return;
}
}
}
void
fintrouble_ASL(ASL *asl, func_info *fi, const char *s, TMInfo *T)
{
TMInfo *T1, *T1prev;
int jv;
static const char fmt[] = "Error in function %s:\n\t%s\n";
jv = 1;
switch(*s) {
case '\'':
jv = 2;
goto inc_s;
case '"':
jv = 3;
inc_s:
++s;
}
#ifndef ASL_OLD_DERIV_CHECK /*{*/
if (jv > 1 && !(want_deriv & 2)) {
DerivErrInfo *D;
DerrRecord *R;
size_t L;
if ((R = getDR(asl))) {
D = asl->i.Derrs;
L = strlen(s) + 1;
if (L > D->mblast - D->mbnext)
D = new_DerrMblock(&asl->i, L);
memcpy(D->mbnext, s, L);
R->u.s = D->mbnext;
D->mbnext += L;
R->errprint = derrprintf;
R->jv = jv;
R->fmt = fmt;
R->who = fi->name;
}
return;
}
#endif /*}*/
report_where(asl);
fprintf(Stderr, fmt, fi->name, s);
fflush(Stderr);
for(T1 = T->u.prev; T1; T1 = T1prev) {
T1prev = T1->u.prev;
free(T1);
}
jmp_check(err_jmp, jv);
jmp_check(err_jmp1,jv);
exit(1);
}
static void iter_node_scion_rev(btIterator *iter) {
bt *btr = iter->btr;
fol_t *fl = (fol_t *)iter->data;
bt_n *kid = NODES(iter->btr, iter->bln->self)[iter->bln->in];
bool scioned = (fl->diff > kid->scion); //DEBUG_ITER_NODE_SCION_REV
if (scioned) {
fl->cnt += kid->scion + 1; // +1 for NODE itself
if (btr->dirty) fl->cnt += getDR(btr, iter->bln->self, iter->bln->ik);
fl->diff = fl->ofst - fl->cnt;
if (fl->diff < 0) {
fl->over = 0;
return;
}
if (iter->bln->ik) iter->bln->ik--;
if (iter->bln->in) iter->bln->in--;
else toparentrecurserev(iter);
if (!fl->diff) {
fl->over = 0;
return;
}
} else {
fl->cnt++;
if (btr->dirty) fl->cnt += getDR(btr, iter->bln->self, iter->bln->ik);
fl->diff = fl->ofst - fl->cnt;
if (fl->diff < 0) {
fl->over = 0;
return;
}
GET_NEW_CHILD(iter)
tochildrecurserev(iter,
NODES(iter->btr, iter->bln->self)[iter->bln->in]);
if (!fl->diff) {
fl->over = 0;
return;
}
} //printf("END iter_node_scion_rev: key: "); DUMP_CURR_KEY
}
static bool streamToBTEntry(uchar *stream, btSIter *siter, bt_n *x, int i) {
if (!stream) return 0;
if (i < 0) i = 0;
convertStream2Key(stream, siter->be.key, siter->x.btr);
siter->be.val = parseStream(stream, siter->x.btr);
bool gost = IS_GHOST(siter->x.btr, siter->be.val);
if (gost) {
siter->missed = 1; // GHOST key
siter->nim = 0;
}
siter->be.dr = x ? getDR(siter->x.btr, x, i) : 0;
siter->be.stream = stream;
siter->be.x = x;
siter->be.i = i; //NOTE: used by bt_validate_dirty
//DUMP_STREAM_TO_BT_ENTRY
return 1;
}
static void *btNext(btSIter *siter, bt_n **rx, int *ri, bool asc) {
btIterator *iter = &(siter->x); //DEBUG_BT_NEXT_1
if (iter->finished) {
if (siter->scan) siter->missed = siter->nim;
return NULL;
}
if (asc) siter->missed = siter->nim; //Curr MISSED = LastLoop's NextIsMissed
bt_n *x = iter->bln->self;
if (rx) *rx = x;
int i = iter->bln->ik;
if (ri) *ri = i;
void *curr = KEYS(iter->btr, x, i);
siter->nim = getDR(iter->btr, x, i) ? 1 : 0; //DEBUG_BT_NEXT_2
if (iter->bln->self->leaf) (*iter->iLeaf)(iter);
else (*iter->iNode)(iter);
return curr;
}
static void iter_leaf_dirty_scion_rev(btIterator *iter) {
//printf("iter_leaf_dirty_scion_rev: ik: %d n: %d\n",
// iter->bln->ik, iter->bln->self->n);
bt *btr = iter->btr;
fol_t *fl = (fol_t *)iter->data;
long cnt = 0;
while (iter->bln->ik >= 0) { // DRs must be added individually
cnt += getDR(btr, iter->bln->self, iter->bln->ik);
long fcnt = fl->cnt + cnt; //DEBUG_ITER_LEAF_DIRTY_SCION_REV
if (fcnt >= fl->ofst) {
fl->over = fcnt - fl->ofst;
return;
}
if (!isGhostRow(btr, iter->bln->self, iter->bln->ik)) cnt++; // KEY also
iter->bln->ik--;
}
fl->cnt += cnt;
fl->diff = fl->ofst - fl->cnt;
iter->bln->ik = iter->bln->in = 0; /* move to start of block */
toparentrecurserev(iter);
}
//Cut variation = fragDirPhoCut, fragPhoCut, dirPhoCut, decayPhoCut, hotspotCut, spikeCut, hoeCut(pp/pbpb), sigEtaEtaCut(pp/pbpb), sumIsoCut(pp/pbpb)
void phoEfficiency_v2(const TString inputFile, string den_st="", string num_st="hotspotCut_spikeCut_hoeCut_sigEtaEtaCut_sumIsoCut", const TString coll="pbpb", int cent_i=0, int cent_f=200, const char* ver="v2")
{
SetHistTitleStyle();
TH1::SetDefaultSumw2();
double pur_num_pp[] = {91.0,89.0,88.0,84.0};
gStyle->SetLabelSize(0.03,"Y");
gStyle->SetTitleYSize(0.05);
gStyle->SetTitleXSize(0.05);
TChain *treePho;
if(coll=="pbpb") treePho = new TChain("ggHiNtuplizer/EventTree");
else if(coll=="pp") treePho = new TChain("ggHiNtuplizerGED/EventTree");
TChain *treeEvt = new TChain("hiEvtAnalyzer/HiTree");
std::vector<std::string> inputFiles = InputConfigurationParser::ParseFiles(inputFile.Data());
std::cout<<"input ROOT files : num = "<<inputFiles.size()<< std::endl;
for(std::vector<std::string>::iterator it = inputFiles.begin() ; it != inputFiles.end(); ++it) {
treePho->Add((*it).c_str());
treeEvt->Add((*it).c_str());
cout <<"input ROOT file : " << (*it).c_str() << endl;
}
TString outputFile;
if(coll=="pbpb") outputFile = Form("hist_efficiency_pbpb_cent%d-%d_%s_Den_%s_Num_%s.root",(int)cent_i/2,(int)cent_f/2,ver,den_st.data(),num_st.data());
else if(coll=="pp") outputFile = Form("hist_efficiency_pp_%s_Den_%s_Num_%s.root",ver,den_st.data(),num_st.data());
cout << "output ROOT file : " << outputFile << endl;
ggHiNtuplizer pho;
pho.setupTreeForReading(treePho);
ULong64_t event=0;
unsigned run=0;
unsigned lumi=0;
int hiBin=0;
treeEvt->SetBranchAddress("evt",&event);
treeEvt->SetBranchAddress("run",&run);
treeEvt->SetBranchAddress("lumi",&lumi);
treeEvt->SetBranchAddress("hiBin",&hiBin);
// if map=0,no cut on den&num// map=1, cut on both den and num// map=2, cut on only num but not on den//
map<string,int> cut_map;
stringToMap(den_st,cut_map,1);
stringToMap(num_st,cut_map,2);
cout << "############ MAP KEYS ############## " << endl;
//cout << "0 for non of them, 1 for both of them, 2 for only numberator" << endl;
for(map<string,int>::iterator it = cut_map.begin() ; it != cut_map.end() ; ++it)
{
cout << it->first <<" " << it->second << endl;
}
cout << "#################################### " << endl;
//reconstructed photons in generated photons (reco pt & reco eta)
TH2D* h2D_Num = new TH2D("h2D_Num", ";|#eta|;p_{T} (GeV)", nEtaBin, etaBins, nPtBin, ptBins);
TH2D* h2D_Den = (TH2D*) h2D_Num->Clone("h2D_Den");
TH2D* h2D_Eff = (TH2D*) h2D_Num->Clone("h2D_Eff");
TH2D* h2D_Num_recons = new TH2D("h2D_Num_recons", ";|#eta|;p_{T} (GeV)", nEtaBin, etaBins, nPtBin, ptBins);
TH2D* h2D_Den_recons = (TH2D*) h2D_Num->Clone("h2D_Den_recons");
TH2D* h2D_Eff_recons = (TH2D*) h2D_Num->Clone("h2D_Eff_recons");
TH2D* h2D_Eff_total;
if(den_st=="") h2D_Eff_total = (TH2D*) h2D_Num->Clone("h2D_Eff_total");
Long64_t nentries = treePho->GetEntries();
for(int ientries = 0; ientries < nentries; ++ientries)
{
if (ientries % 10000 == 0) {
std::cout << "current entry = " <<ientries<<" out of "<<nentries<<" : "<<std::setprecision(2)<<(double)ientries/nentries*100<<" %"<<std::endl;
}
treePho->GetEntry(ientries);
treeEvt->GetEntry(ientries);
if(coll=="pbpb" && !(hiBin>=cent_i && hiBin<cent_f)) continue;
for (int igen = 0; igen < pho.nMC; ++igen){
if (pho.mcStatus->at(igen) != 1 || (pho.mcPID->at(igen)) != 22 ) continue;
if (pho.mcPt->at(igen)<30) continue;
if (pho.mcCalIsoDR04->at(igen)>5) continue;
//////////////// FLAGS FOR DENOMERATOR and NUMERATOR ////////////
bool denFlag = 1;
bool numFlag = 1;
//cout << "passed gen continues " << endl;
if (cut_map.find("dirPhoCut") != cut_map.end()) {
bool isPass = (pho.mcMomPID->at(igen) == 22);
//cout << "momID = " << pho.mcMomPID->at(igen) <<", dirPhoCut isPass = "******"dirPhoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("dirPhoCut") ==2) && (!isPass) ) numFlag=0;
}
if (cut_map.find("fragPhoCut") != cut_map.end()) {
bool isPass = (pho.mcMomPID->at(igen) == 22);
//cout << "momID = " << pho.mcMomPID->at(igen) <<", fragPhoCut isPass = "******"fragPhoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("fragPhoCut") ==2) && (!isPass) ) numFlag=0;
}
if (cut_map.find("fragDirPhoCut") != cut_map.end()) {
bool isPass = (pho.mcMomPID->at(igen) == 22);
//cout << "momID = " << pho.mcMomPID->at(igen) <<", fragDirPhoCut isPass = "******"fragDirPhoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("fragDirPhoCut") ==2) && (!isPass) ) numFlag=0;
}
if (cut_map.find("decayPhoCut") != cut_map.end()) {
bool isPass = (pho.mcMomPID->at(igen) == 22);
//cout << "momID = " << pho.mcMomPID->at(igen) <<", decayPhoCut isPass = "******"decayPhoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("decayPhoCut") ==2) && (!isPass) ) numFlag=0;
}
///// MATCHING PART /////
Float_t currentDiffPt(1000);
Float_t currentRecoPt(-1);
int matchedIndex = -1;
for(int ipho = 0; ipho < pho.nPho; ++ipho){
//cout << "pho.phoEt = " << pho.phoEt->at(ipho) << endl;
float tempDR = getDR(pho.phoEta->at(ipho), pho.phoPhi->at(ipho), pho.mcEta->at(igen), pho.mcPhi->at(igen));
float tempDiffPt = abs( pho.mcPt->at(igen) - pho.phoEt->at(ipho) );
if( (tempDR < delta) && (tempDiffPt < currentDiffPt) ) {
currentDiffPt = tempDiffPt;
currentRecoPt = pho.phoEt->at(ipho);
matchedIndex = ipho;
}
}
///////////////// RECONSTRUCTION EFFICIENCY ///////////////
h2D_Den_recons->Fill( abs(pho.mcEta->at(igen)), pho.mcEt->at(igen) );
if(matchedIndex==-1) continue;
h2D_Num_recons->Fill( abs(pho.mcEta->at(igen)), pho.mcEt->at(igen) );
///////////////////////////////////////////////////////////
#if 1
if(TMath::Abs(pho.phoEta->at(matchedIndex))>3) continue;
if(pho.phoEt->at(matchedIndex)<25) continue;
///////////////// START CONDITONS //////////////
if (cut_map.find("spikeCut") != cut_map.end()) {
bool isFail = ( (pho.phoEta->at(matchedIndex)<1.44) &&
(pho.phoSigmaIEtaIEta->at(matchedIndex) < 0.002 ||
pho.pho_swissCrx->at(matchedIndex) > 0.9 ||
TMath::Abs(pho.pho_seedTime->at(matchedIndex)) > 3) );
//cout << "is spike(fail) ? = " << isFail << endl;
if( (cut_map.at("spikeCut") ==1) && (isFail) ) continue;
else if((cut_map.at("spikeCut") ==2) && (isFail) ) numFlag=0;
}
if (cut_map.find("hotspotCut") != cut_map.end()) {
bool isFail =
( (pho.phoE3x3->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) > 2./3.-0.03 && pho.phoE3x3->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) < 2./3.+0.03) &&
(pho.phoE1x5->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) > 1./3.-0.03 && pho.phoE1x5->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) < 1./3.+0.03) &&
(pho.phoE2x5->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) > 2./3.-0.03 && pho.phoE2x5->at(matchedIndex)/pho.phoE5x5->at(matchedIndex) < 2./3.+0.03) );
if( (cut_map.at("hotspotCut") ==1) && (isFail) ) continue;
else if((cut_map.at("hotspotCut") ==2) && (isFail) ) numFlag=0;
}
if (cut_map.find("hoeCut") != cut_map.end()) {
if(coll=="pbpb"){
bool isPass = (pho.phoHoverE->at(matchedIndex)<0.1);
if( (cut_map.at("hoeCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("hoeCut") ==2) && (!isPass) ) numFlag=0;
} else if(coll=="pp"){
bool isPass = (pho.phoHoverE->at(matchedIndex)<0.05);
if( (cut_map.at("hoeCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("hoeCut") ==2) && (!isPass) ) numFlag=0;
}
}
if (cut_map.find("sigEtaEtaCut") != cut_map.end()) {
if(coll=="pbpb"){
bool isPass = (pho.phoSigmaIEtaIEta_2012->at(matchedIndex)<0.0101);
if( (cut_map.at("sigEtaEtaCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("sigEtaEtaCut") ==2) && (!isPass) ) numFlag=0;
} else if(coll=="pp"){
bool isPass =(
(abs(pho.phoEta->at(matchedIndex))<=1.44 && pho.phoSigmaIEtaIEta_2012->at(matchedIndex)<0.0102) ||
(abs(pho.phoEta->at(matchedIndex))>1.44 && pho.phoSigmaIEtaIEta_2012->at(matchedIndex)<0.0268)
);
if( (cut_map.at("sigEtaEtaCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("sigEtaEtaCut") ==2) && (!isPass) ) numFlag=0;
}
}
if (cut_map.find("sumIsoCut") != cut_map.end()) {
if(coll=="pbpb"){
float sumIso = pho.pho_ecalClusterIsoR4->at(matchedIndex) + pho.pho_hcalRechitIsoR4->at(matchedIndex) + pho.pho_trackIsoR4PtCut20->at(matchedIndex);
bool isPass = (sumIso<1);
if( (cut_map.at("sumIsoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("sumIsoCut") ==2) && (!isPass) ) numFlag=0;
} else if(coll=="pp"){
bool barrelIso = ((pho.pfcIso4->at(matchedIndex)<=1.37) && (pho.pfnIso4->at(matchedIndex)<=1.06+0.014*pho.phoEt->at(matchedIndex)+0.000019*pho.phoEt->at(matchedIndex)*pho.phoEt->at(matchedIndex)) && pho.pfpIso4->at(matchedIndex)<=(0.28+0.0053*pho.phoEt->at(matchedIndex)));
bool endcapIso = ((pho.pfcIso4->at(matchedIndex)<=1.10) && (pho.pfnIso4->at(matchedIndex)<=2.69+0.0139*pho.phoEt->at(matchedIndex)+0.000025*pho.phoEt->at(matchedIndex)*pho.phoEt->at(matchedIndex)) && pho.pfpIso4->at(matchedIndex)<=(0.39+0.0034*pho.phoEt->at(matchedIndex)));
bool isPass = ( ( (abs(pho.phoEta->at(matchedIndex))<=1.44) && barrelIso ) ||
( (abs(pho.phoEta->at(matchedIndex))>1.44) && endcapIso ) );
if( (cut_map.at("sumIsoCut") ==1) && (!isPass) ) continue;
else if((cut_map.at("sumIsoCut") ==2) && (!isPass) ) numFlag=0;
// default photon isolation for PP is "Loose".
// cut_phoHOverE_EB = 0.05; // Barrel
// cut_phoSigmaIEtaIEta_EB = 0.0102;
// cut_pfcIso4_EB = 3.32;
// cut_pfnIso4_c0_EB = 1.92;
// cut_pfnIso4_c1_EB = 0.014;
// cut_pfnIso4_c2_EB = 0.000019;
// cut_pfpIso4_c0_EB = 0.81;
// cut_pfpIso4_c1_EB = 0.0053;
// cut_phoHOverE_EE = 0.05; // Endcap
// cut_phoSigmaIEtaIEta_EE = 0.0274;
// cut_pfcIso4_EE = 1.97;
// cut_pfnIso4_c0_EE = 11.86;
// cut_pfnIso4_c1_EE = 0.0139;
// cut_pfnIso4_c2_EE = 0.000025;
// cut_pfpIso4_c0_EE = 0.83;
// cut_pfpIso4_c1_EE = 0.0034;
}
}
///////////////// END OF CONDITON //////////////
//cout << "denFlag = " << denFlag << ", numFlag = " << numFlag << endl;
h2D_Den->Fill( abs(pho.mcEta->at(igen)), pho.mcEt->at(igen) );
if(numFlag) h2D_Num->Fill( abs(pho.mcEta->at(igen)), pho.mcEt->at(igen) );
#endif
}//gen loop
}//event loop
///////////////// GET EFFICIENCY /////////////////
h2D_Eff->Divide(h2D_Num,h2D_Den,1.,1.,"B");
h2D_Eff_recons->Divide(h2D_Num_recons,h2D_Den_recons,1.,1.,"B");
TH1D* h1D_pt_recons= (TH1D*) h2D_Eff_recons->ProjectionY("h1D_Eff_pt_recons",0,1);
TH1D* h1D_pt = (TH1D*) h2D_Eff->ProjectionY("h1D_Eff_pt",0,1);
TH1D* h1D_pt_recons_pretty = changeToPrettyBin(h1D_pt_recons);
TH1D* h1D_pt_pretty = changeToPrettyBin(h1D_pt);
h1D_pt_recons_pretty->SetTitle(";p_{T} (GeV);Reconstruction Efficiency");
h1D_pt_recons_pretty->SetMarkerStyle(20);
h1D_pt_recons_pretty->SetAxisRange(0.50,1.0001,"Y");
h1D_pt_pretty->SetTitle(";p_{T} (GeV);RecoCut Efficiency");
h1D_pt_pretty->SetMarkerStyle(20);
h1D_pt_pretty->SetAxisRange(0.50,1.0001,"Y");
TH1D* h1D_pt_total;
TH1D* h1D_pt_total_pretty;
if(den_st=="") {
h2D_Eff_total->Divide(h2D_Num,h2D_Den_recons,1.,1.,"B");
h1D_pt_total = (TH1D*) h2D_Eff_total->ProjectionY("h1D_Eff_pt_total",0,1);
h1D_pt_total_pretty = changeToPrettyBin(h1D_pt_total);
h1D_pt_total_pretty->SetTitle(";p_{T} (GeV);Total Efficiency");
h1D_pt_total_pretty->SetMarkerStyle(20);
h1D_pt_total_pretty->SetAxisRange(0.50,1.0001,"Y");
}
// drawText(cap,0.2,0.2);
// TEfficiency* hEff = new TEfficiency(h1D_Num_pt,h1D_Den_pt);
// TCanvas* c = new TCanvas("c1", "", 700,700);
// TGraphAsymmErrors* g_Eff_pt = new TGraphAsymmErrors(h1D_Num_pt, h1D_Den_pt);
// g_Eff_pt->SetMarkerStyle(20);
// g_Eff_pt->Draw("p");
// //drawText(cap,0.2,0.2);
// jumSun(ptBins[0],1,ptBins[nPtBin],1);
// c->SaveAs(Form("figures/g_Eff_pt_reco_%s_nohotspot.pdf",cap));
saveHistogramsToPicture(h1D_pt_recons_pretty, "pdf",Form("efficiency_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2));
saveHistogramsToPicture(h1D_pt_pretty, "pdf",Form("efficiency_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2));
saveHistogramsToPicture(h2D_Eff, "pdf",Form("efficiency_pt_eta_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2),"figures",0);
saveHistogramsToPicture(h2D_Eff_recons, "pdf",Form("reconstruction_efficiency_pt_eta_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2),"figures",0);
if(den_st=="") saveHistogramsToPicture(h2D_Eff_total, "pdf",Form("total_efficiency_pt_eta_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2),"figures",0);
if(den_st=="") saveHistogramsToPicture(h1D_pt_total_pretty, "pdf",Form("efficiency_Den_%s_Num_%s_%s_cent%d_%d",den_st.data(),num_st.data(),coll.Data(),(int)cent_i/2,(int)cent_f/2));
TFile* outf = new TFile(Form("output/%s",outputFile.Data()), "RECREATE");
outf->cd();
h2D_Num->Write();
h2D_Den->Write();
h2D_Eff->Write();
h2D_Num_recons->Write();
h2D_Den_recons->Write();
h2D_Eff_recons->Write();
h1D_pt_recons->Write();
h1D_pt->Write();
if(den_st==""){
h2D_Eff_total->Write();
h1D_pt_total->Write();
}
outf->Close();
}
static bool btScionFind(btSIter *siter, bt_n *x, ulong ofst, bt *btr, bool asc,
cswc_t *w, long lim) {
int i = asc ? 0 : x->n; //DEBUG_SCION_PRE_LOOP1
int fin = asc ? x->n + 1 : -1;//LOOPS:(i=0,i<=x->n,i++)&(i=x->n,i>=0,i--)
while (i != fin) {
if (x->leaf) break;
uint32_t scion = NODES(btr, x)[i]->scion; //DEBUG_SCION_LOOP_1
if (scion >= ofst) {
bool i_end_n = (i == siter->x.bln->self->n);
siter->x.bln->in = i;
siter->x.bln->ik = (i_end_n) ? i - 1 : i; //DEBUG_SCION_LOOP_1_KID
if (scion == ofst) {
if (!asc) {
siter->x.bln->in = siter->x.bln->ik = i - 1;
}
return 1;
}
siter->x.bln->child = get_new_iter_child(&siter->x);
to_child(&siter->x, NODES(btr, x)[i]);
bt_n *kid = NODES(btr, x)[i]; //DEBUG_SCION_LOOP_1_GOT_KID
if (!kid->leaf) {
btScionFind(siter, kid, ofst, btr, asc, w, lim);
return 1;
} else x = kid;
break;
} else ofst -= (scion + 1); // +1 for NODE itself
i = asc ? i + 1 : i - 1; // loop increment
}
// Now Find the rest of the OFFSET (respecting DRs)
uint32 n = siter->x.bln->self->n;
i = asc ? 0 : n - 1;
fin = asc ? MIN(ofst, n) : MAX(-1, (n - ofst));
int last = asc ? n - 1 : 0;
ulong cnt = 0;
//TODO findminnode() is too inefficient -> needs to be a part of btr
bt_n *minx = findminnode(btr, btr->root);
int btdl = btr->dirty_left;
int dr = 0; //DEBUG_SCION_PRE_LOOP2
while (i != fin) {
dr = getDR(btr, x, i);
cnt += dr;
if (!i && x == minx) cnt += btdl; //DEBUG_SCION_LOOP2
if (cnt >= ofst) break;
cnt++;
i = asc ? i + 1 : i - 1; // loop increment
} //DEBUG_SCION_OFFSET_TOO_BIG
if (i == fin && i == last) {
if (cnt >= x->scion) return 0;
}
else if (cnt < ofst) return 0; //OFST 2big
siter->x.bln->ik = i;
INIT_ITER_BEENTRY(siter, btr, x, siter->x.bln->ik);
if (asc) {
if ((ofst + dr) != cnt) siter->missed = 1;
}
else {
if (!i && x == minx) {
if (ofst != (cnt - btdl)) siter->missed = 1;
}
else {
if (ofst != cnt) siter->missed = 1;
}
} //DEBUG_SCION_POST_LOOP2
return 1;
}
int makeWJetAnaSkim(std::string fList = "", sampleType sType = kHIDATA, Int_t num = 0)
{
//Define MC or Data
Bool_t montecarlo = isMonteCarlo(sType);
Bool_t hi = isHI(sType);
std::cout << sType << std::endl;
std::cout << montecarlo << std::endl;
std::string buffer;
std::vector<std::string> listOfFiles;
int nLines = 0;
ifstream inFile(fList.data());
std::cout << fList << std::endl;
std::cout << inFile.is_open() << std::endl;
if(!inFile.is_open()){
std::cout << "Error opening file. Exiting." <<std::endl;
return 1;
}
else{
while(true){
inFile >> buffer;
if(inFile.eof()) break;
listOfFiles.push_back(buffer);
nLines++;
}
}
std::cout << "FileList Loaded" << std::endl;
std::cout << "FileJob: " << listOfFiles[num] << std::endl;
TFile* iniSkim_p = new TFile(listOfFiles[num].data(), "READ");
GetWJetIniSkim(iniSkim_p, sType);
std::cout << "IniSkim Loaded" << std::endl;
std::string outName = listOfFiles[num];
const std::string cutString = "/";
const std::string iniString = "Ini";
std::size_t strIndex = 0;
std::cout << "Cull string" << std::endl;
while(true){
strIndex = outName.find(cutString);
if(strIndex == std::string::npos) break;
outName.replace(0, strIndex + 1, "");
}
std::cout << "Replace string" << std::endl;
strIndex = outName.find(iniString);
if(!(strIndex == std::string::npos)){
outName.replace(strIndex, iniString.length(), "Ana");
}
std::cout << "Output name: " << outName.c_str() << std::endl;
TFile *outFile = new TFile(outName.c_str(), "RECREATE");
InitWJetAnaSkim(sType);
Long64_t nentries = jetTreeIni_p->GetEntries();
std::cout << nentries << std::endl;
Float_t prevLeptPt = 0;
Float_t prevLeptVsPt = 0;
Float_t prevLeptPhi = 0;
Float_t prevLeptEta = 0;
for(Long64_t jentry = 0; jentry < nentries; jentry++){
trackTreeIni_p->GetEntry(jentry);
pfCandTreeIni_p->GetEntry(jentry);
jetTreeIni_p->GetEntry(jentry);
if(montecarlo) genTreeIni_p->GetEntry(jentry);
if(jentry%1000 == 0) std::cout << jentry << std::endl;
InitAnaVar();
run_ = runIni_;
evt_ = evtIni_;
lumi_ = lumiIni_;
if(montecarlo) pthat_ = pthatIni_;
if(hi){
hiBin_ = hiBinIni_;
hiEvtPlane_ = hiEvtPlaneIni_;
psin_ = psinIni_;
}
for(Int_t iter = 0; iter < nPF_; iter++){
pfEvtPtSum_[0] += pfPt_[iter]*TMath::Cos(pfPhi_[iter]);
pfEvtPtSum_[1] += pfPt_[iter]*TMath::Sin(pfPhi_[iter]);
if(hi){
pfEvtVsPtSum_[0] += pfVsPt_[iter]*TMath::Cos(pfPhi_[iter]);
pfEvtVsPtSum_[1] += pfVsPt_[iter]*TMath::Sin(pfPhi_[iter]);
}
if(pfPt_[iter] > leptPtCut && TMath::Abs(pfEta_[iter]) < leptEtaCut){
if(TMath::Abs(pfId_[iter]) == 3 && pfPt_[iter] > muonPt_){
muonPt_ = pfPt_[iter];
if(hi) muonVsPt_ = pfVsPt_[iter];
muonPhi_ = pfPhi_[iter];
muonEta_ = pfEta_[iter];
}
if(TMath::Abs(pfId_[iter]) == 2 && pfPt_[iter] > electronPt_ && (TMath::Abs(pfEta_[iter]) < 0.80 || TMath::Abs(pfEta_[iter]) > 1.4)){
electronPt_ = pfPt_[iter];
if(hi) electronVsPt_ = pfVsPt_[iter];
electronPhi_ = pfPhi_[iter];
electronEta_ = pfEta_[iter];
}
}
}
if(electronPt_ > muonPt_){
leptPt_ = electronPt_;
if(hi) leptVsPt_ = electronVsPt_;
leptPhi_ = electronPhi_;
leptEta_ = electronEta_;
}
else if(muonPt_ > electronPt_){
leptPt_ = muonPt_;
if(hi) leptVsPt_ = muonVsPt_;
leptPhi_ = muonPhi_;
leptEta_ = muonEta_;
}
for(Int_t iter = 0; iter < nPF_; iter++){
if(TMath::Abs(pfId_[iter]) != 2 && TMath::Abs(pfId_[iter]) != 3 && pfPt_[iter] > check1Pt_){
if(getDR(leptEta_, leptPhi_, pfEta_[iter], pfPhi_[iter]) > 0.5){
check1Pt_ = pfPt_[iter];
if(hi) check1VsPt_ = pfVsPt_[iter];
check1Phi_ = pfPhi_[iter];
check1Eta_ = pfEta_[iter];
}
}
}
check2Pt_ = prevLeptPt;
if(hi) check2VsPt_ = prevLeptVsPt;
check2Phi_ = prevLeptPhi;
check2Eta_ = prevLeptEta;
prevLeptPt = leptPt_;
if(hi) prevLeptVsPt = leptVsPt_;
prevLeptPhi = leptPhi_;
prevLeptEta = leptEta_;
for(Int_t iter = 0; iter < nTrk_; iter++){
trkEvtPtSum_[0] += trkPt_[iter]*TMath::Cos(trkPhi_[iter]);
trkEvtPtSum_[1] += trkPt_[iter]*TMath::Sin(trkPhi_[iter]);
if(trkPt_[iter] > trkPtCut){
trkCutEvtPtSum_[0] += trkPt_[iter]*TMath::Cos(trkPhi_[iter]);
trkCutEvtPtSum_[1] += trkPt_[iter]*TMath::Sin(trkPhi_[iter]);
}
}
if(leptPt_ > 0){
pfEvtPtMag_ = TMath::Sqrt(pfEvtPtSum_[0]*pfEvtPtSum_[0] + pfEvtPtSum_[1]*pfEvtPtSum_[1]);
pfEvtPhi_ = TMath::ATan2(pfEvtPtSum_[1], pfEvtPtSum_[0]);
pfNeuPhi_ = TMath::ATan2(-pfEvtPtSum_[1], -pfEvtPtSum_[0]);
pfMt_ = TMath::Sqrt(2*leptPt_*pfEvtPtMag_*(1 - TMath::Cos(getDPHI(leptPhi_, pfNeuPhi_))));
pfWPtSum_[0] = leptPt_*TMath::Cos(leptPhi_) - pfEvtPtSum_[0];
pfWPtSum_[1] = leptPt_*TMath::Sin(leptPhi_) - pfEvtPtSum_[1];
pfWPtMag_ = TMath::Sqrt(pfWPtSum_[0]*pfWPtSum_[0] + pfWPtSum_[1]*pfWPtSum_[1]);
pfWPhi_ = TMath::ATan2(pfWPtSum_[1], pfWPtSum_[0]);
if(hi){
pfEvtVsPtMag_ = TMath::Sqrt(pfEvtVsPtSum_[0]*pfEvtVsPtSum_[0] + pfEvtVsPtSum_[1]*pfEvtVsPtSum_[1]);
pfEvtVsPhi_ = TMath::ATan2(pfEvtVsPtSum_[1], pfEvtVsPtSum_[0]);
pfVsNeuPhi_ = TMath::ATan2(-pfEvtVsPtSum_[1], -pfEvtVsPtSum_[0]);
pfVsMt_ = TMath::Sqrt(2*leptPt_*pfEvtVsPtMag_*(1 - TMath::Cos(getDPHI(leptPhi_, pfVsNeuPhi_))));
pfVsWPtSum_[0] = leptPt_*TMath::Cos(leptPhi_) - pfEvtVsPtSum_[0];
pfVsWPtSum_[1] = leptPt_*TMath::Sin(leptPhi_) - pfEvtVsPtSum_[1];
pfVsWPtMag_ = TMath::Sqrt(pfVsWPtSum_[0]*pfVsWPtSum_[0] + pfVsWPtSum_[1]*pfVsWPtSum_[1]);
pfVsWPhi_ = TMath::ATan2(pfVsWPtSum_[1], pfVsWPtSum_[0]);
}
trkEvtPtMag_ = TMath::Sqrt(trkEvtPtSum_[0]*trkEvtPtSum_[0] + trkEvtPtSum_[1]*trkEvtPtSum_[1]);
trkEvtPhi_ = TMath::ATan2(trkEvtPtSum_[1], trkEvtPtSum_[0]);
trkNeuPhi_ = TMath::ATan2(-trkEvtPtSum_[1], -trkEvtPtSum_[0]);
trkMt_ = TMath::Sqrt(2*leptPt_*trkEvtPtMag_*(1 - TMath::Cos(getDPHI(leptPhi_, trkNeuPhi_))));
trkWPtSum_[0] = leptPt_*TMath::Cos(leptPhi_) - trkEvtPtSum_[0];
trkWPtSum_[1] = leptPt_*TMath::Sin(leptPhi_) - trkEvtPtSum_[1];
trkWPtMag_ = TMath::Sqrt(trkWPtSum_[0]*trkWPtSum_[0] + trkWPtSum_[1]*trkWPtSum_[1]);
trkWPhi_ = TMath::ATan2(trkWPtSum_[1], trkWPtSum_[0]);
trkCutEvtPtMag_ = TMath::Sqrt(trkCutEvtPtSum_[0]*trkCutEvtPtSum_[0] + trkCutEvtPtSum_[1]*trkCutEvtPtSum_[1]);
trkCutEvtPhi_ = TMath::ATan2(trkCutEvtPtSum_[1], trkCutEvtPtSum_[0]);
trkCutNeuPhi_ = TMath::ATan2(-trkCutEvtPtSum_[1], -trkCutEvtPtSum_[0]);
trkCutMt_ = TMath::Sqrt(2*leptPt_*trkCutEvtPtMag_*(1 - TMath::Cos(getDPHI(leptPhi_, trkCutNeuPhi_))));
trkCutWPtSum_[0] = leptPt_*TMath::Cos(leptPhi_) - trkCutEvtPtSum_[0];
trkCutWPtSum_[1] = leptPt_*TMath::Sin(leptPhi_) - trkCutEvtPtSum_[1];
trkCutWPtMag_ = TMath::Sqrt(trkCutWPtSum_[0]*trkCutWPtSum_[0] + trkCutWPtSum_[1]*trkCutWPtSum_[1]);
trkCutWPhi_ = TMath::ATan2(trkCutWPtSum_[1], trkCutWPtSum_[0]);
}
if(check1Pt_ > 0){
pfCheck1Mt_ = TMath::Sqrt(2*check1Pt_*pfEvtPtMag_*(1 - TMath::Cos(getDPHI(check1Phi_, pfNeuPhi_))));
if(hi) pfVsCheck1Mt_ = TMath::Sqrt(2*check1Pt_*pfEvtVsPtMag_*(1 - TMath::Cos(getDPHI(check1Phi_, pfVsNeuPhi_))));
trkCheck1Mt_ = TMath::Sqrt(2*check1Pt_*trkEvtPtMag_*(1 - TMath::Cos(getDPHI(check1Phi_, trkNeuPhi_))));
trkCutCheck1Mt_ = TMath::Sqrt(2*check1Pt_*trkCutEvtPtMag_*(1 - TMath::Cos(getDPHI(check1Phi_, trkCutNeuPhi_))));
}
if(check2Pt_ > 0){
pfCheck2Mt_ = TMath::Sqrt(2*check2Pt_*pfEvtPtMag_*(1 - TMath::Cos(getDPHI(check2Phi_, pfNeuPhi_))));
if(hi) pfVsCheck2Mt_ = TMath::Sqrt(2*check2Pt_*pfEvtVsPtMag_*(1 - TMath::Cos(getDPHI(check2Phi_, pfVsNeuPhi_))));
trkCheck2Mt_ = TMath::Sqrt(2*check2Pt_*trkEvtPtMag_*(1 - TMath::Cos(getDPHI(check2Phi_, trkNeuPhi_))));
trkCutCheck2Mt_ = TMath::Sqrt(2*check2Pt_*trkCutEvtPtMag_*(1 - TMath::Cos(getDPHI(check2Phi_, trkCutNeuPhi_))));
}
Float_t dummyArr[2];
getJtVar(nVs3Calo_, Vs3CaloPt_, Vs3CaloPhi_, Vs3CaloEta_, Vs3CaloRefPt_, Vs3CaloRefPhi_, Vs3CaloRefEta_, 0, montecarlo, false);
getJtVar(nVs4Calo_, Vs4CaloPt_, Vs4CaloPhi_, Vs4CaloEta_, Vs4CaloRefPt_, Vs4CaloRefPhi_, Vs4CaloRefEta_, 1, montecarlo, false);
getJtVar(nVs5Calo_, Vs5CaloPt_, Vs5CaloPhi_, Vs5CaloEta_, Vs5CaloRefPt_, Vs5CaloRefPhi_, Vs5CaloRefEta_, 2, montecarlo, false);
getJtVar(nT3_, T3Pt_, T3Phi_, T3Eta_, dummyArr, dummyArr, dummyArr, 3, montecarlo, true);
getJtVar(nT4_, T4Pt_, T4Phi_, T4Eta_, dummyArr, dummyArr, dummyArr, 4, montecarlo, true);
getJtVar(nT5_, T5Pt_, T5Phi_, T5Eta_, dummyArr, dummyArr, dummyArr, 5, montecarlo, true);
trackTreeAna_p->Fill();
pfCandTreeAna_p->Fill();
jetTreeAna_p->Fill();
if(montecarlo) genTreeAna_p->Fill();
}
outFile->cd();
trackTreeAna_p->Write("", TObject::kOverwrite);
pfCandTreeAna_p->Write("", TObject::kOverwrite);
jetTreeAna_p->Write("", TObject::kOverwrite);
if(montecarlo) genTreeAna_p->Write("", TObject::kOverwrite);
CleanupWJetAnaSkim();
outFile->Close();
delete outFile;
iniSkim_p->Close();
delete iniSkim_p;
printf("Done.\n");
return(0);
}
