int process(TChain *trigOnlyChain, MAPJson *jsonMap, MAPTrigOnly mapTo, TString nameChain, TString file, int iFile, int nEntries,
TString dirIn, TString dirOut, TString usr_hlt, int iJson,
bool GetTrigOnly, bool debug) {
// TrigOnly MAP //
MAPTrigOnly::iterator iterMapTo;
pair<int,int> runevtTo;
int iEntryTo=-1;
// OUTPUT FILE //
if(debug) cout << "--- define output file : " ;
ostringstream ossi("");
ossi << iFile ;
//
TFile *outfile = new TFile(dirIn+"spikes_"+ossi.str()+".root","RECREATE");
//ofstream outcheckdata(dirIn+"logcheckdata_"+ossi.str()+".txt",ios::out);
ofstream outlog(dirOut+"/logs/log_"+ossi.str()+".txt",ios::out);
ofstream outcheckL1(dirOut+"/checkL1/checkL1_"+ossi.str()+".txt",ios::out);
//outlog << "TRY TRY TRY" << endl;
//outcheckL1 << "TRY TRY TRY" << endl;
//outcheckdata << "TRY TRY TRY" << endl;
if(debug) cout << "spikes_"+ossi.str()+".root" << endl;
ossi.str("");
// INPUT TREE //
if(debug) cout << "--- add data trees to myChain" << endl;
TChain * myChain = new TChain(nameChain);
myChain->Add(file);
// VARIABLES //
int nEvent, nRun, nLumi ; // data
int nEvent_To, nRun_To, nLumi_To; // trigOnly
// Vertices //
int vtx_N;
double _vtx_x[200], _vtx_y[200], _vtx_z[200];
double _vtx_normalizedChi2[200], _vtx_ndof[200], _vtx_nTracks[200], _vtx_d0[200];
// Trigger Paths //
int trig_hltInfo[250];
//int _trig_isEleHLTpath;
int trig_HLT_path[4]; // unbias, EG5, EG8, EG12
char trig_fired_names[5000];
vector<string> m_HLT_pathsV;
vector<string> m_HLT_triggered;
vector<int> m_HLT_pathsV_check;
// Spikes
int spike_N,spike_TTieta[5000], spike_TTiphi[5000], spike_Rieta[5000], spike_Riphi[5000], spike_severityLevel[5000],
spike_outOfTime[5000], spike_TT_sFGVB[5000], spike_TT_adc[5000], spike_TT_sFGVB_E[5000][5], spike_TT_adc_E[5000][5],
spike_TT_t[5000], spike_TT_tE[5000];
double spike_Et[5000], spike_eta[5000], spike_phi[5000], spike_theta[5000];
int spike_RCTL1iso[5000], spike_RCTL1noniso[5000], spike_RCTL1iso_To[5000], spike_RCTL1noniso_To[5000],
spike_RCTL1iso_M_To[5000], spike_RCTL1noniso_M_To[5000],
spike_maxEGtrig[5000], spike_maxEGtrig_To[5000], spike_maxEGtrig_M_To[5000];
int spike_out_TTieta, spike_out_TTiphi, spike_out_Rieta, spike_out_Riphi, spike_out_severityLevel,
spike_out_outOfTime, spike_out_TT_sFGVB, spike_out_TT_adc, spike_out_TT_sFGVB_E[5], spike_out_TT_adc_E[5],
spike_out_TT_t, spike_out_TT_tE;
double spike_out_Et, spike_out_eta, spike_out_phi, spike_out_theta;
int spike_out_RCTL1iso, spike_out_RCTL1noniso, spike_out_RCTL1iso_To, spike_out_RCTL1noniso_To,
spike_out_RCTL1iso_M_To, spike_out_RCTL1noniso_M_To,
spike_out_maxEGtrig, spike_out_maxEGtrig_To, spike_out_maxEGtrig_M_To;
// TP info
const int nTow = 4032;
int trig_tower_N,trig_tower_ieta[nTow],trig_tower_iphi[nTow],trig_tower_adc[nTow],trig_tower_sFGVB[nTow],trig_tower_FG[nTow];
int trig_tower_N_M,trig_tower_ieta_M[nTow],trig_tower_iphi_M[nTow],trig_tower_adc_M[nTow],trig_tower_sFGVB_M[nTow],
trig_tower_FG_M[nTow];
int trig_tower_N_E,trig_tower_ieta_E[nTow],trig_tower_iphi_E[nTow],trig_tower_adc_E[nTow][5],trig_tower_sFGVB_E[nTow][5],
trig_tower_FG_E[nTow][5];
// HCAL TP //
int trig_tower_hcal_N, trig_tower_hcal_ieta[4032], trig_tower_hcal_iphi[4032], trig_tower_hcal_FG[4032],trig_tower_hcal_et[4032];
// L1 Candidates //
int trig_L1emIso_N, trig_L1emNonIso_N;
int trig_L1emIso_N_To, trig_L1emNonIso_N_To, trig_L1emIso_N_M_To, trig_L1emNonIso_N_M_To;
// L1 candidates info //
int trig_L1emIso_ieta[4], trig_L1emIso_iphi[4], trig_L1emIso_rank[4];
int trig_L1emNonIso_ieta[4], trig_L1emNonIso_iphi[4], trig_L1emNonIso_rank[4];
int trig_L1emIso_ieta_To[4], trig_L1emIso_iphi_To[4], trig_L1emIso_rank_To[4];
int trig_L1emNonIso_ieta_To[4], trig_L1emNonIso_iphi_To[4], trig_L1emNonIso_rank_To[4];
int trig_L1emIso_ieta_M_To[4], trig_L1emIso_iphi_M_To[4], trig_L1emIso_rank_M_To[4];
int trig_L1emNonIso_ieta_M_To[4], trig_L1emNonIso_iphi_M_To[4], trig_L1emNonIso_rank_M_To[4];
// INITIALIZATION //
//
// Global
nEvent = 0;
nRun = 0;
nLumi = 0;
//
// Vertices
vtx_N = 0;
for(int iv=0;iv<200;iv++) {
_vtx_normalizedChi2[iv] = 0.;
_vtx_ndof[iv] = 0.;
_vtx_nTracks[iv] = 0.;
_vtx_d0[iv] = 0.;
_vtx_x[iv] = 0.;
_vtx_y[iv] = 0.;
_vtx_z[iv] = 0.;
}
//
// L1 candidates
trig_L1emIso_N = 0;
trig_L1emNonIso_N = 0;
trig_L1emIso_N_M_To = 0;
trig_L1emNonIso_N_M_To = 0;
for(int il1=0 ; il1<4 ; il1++) {
trig_L1emIso_ieta[il1] = 0;
trig_L1emIso_iphi[il1] = 0;
trig_L1emIso_rank[il1] = 0;
trig_L1emNonIso_ieta[il1] = 0;
trig_L1emNonIso_iphi[il1] = 0;
trig_L1emNonIso_rank[il1] = 0;
trig_L1emIso_ieta_To[il1] = 0;
trig_L1emIso_iphi_To[il1] = 0;
trig_L1emIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_To[il1] = 0;
trig_L1emNonIso_iphi_To[il1] = 0;
trig_L1emNonIso_rank_To[il1] = 0;
trig_L1emIso_ieta_M_To[il1] = 0;
trig_L1emIso_iphi_M_To[il1] = 0;
trig_L1emIso_rank_M_To[il1] = 0;
trig_L1emNonIso_ieta_M_To[il1] = 0;
trig_L1emNonIso_iphi_M_To[il1] = 0;
trig_L1emNonIso_rank_M_To[il1] = 0;
}
// Trigger towers
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = trig_tower_FG[iTow] = -999;
}
trig_tower_N_M = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_M[iTow] = trig_tower_iphi_M[iTow] = -999;
trig_tower_adc_M[iTow] = trig_tower_sFGVB_M[iTow] = trig_tower_FG_M[iTow] = -999;
}
trig_tower_N_E = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_E[iTow] = trig_tower_iphi_E[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_E[iTow][i] = trig_tower_sFGVB_E[iTow][i] = trig_tower_FG_E[iTow][i] = -999;
}
trig_tower_hcal_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_hcal_ieta[iTow] = trig_tower_hcal_iphi[iTow] = -999;
trig_tower_hcal_FG[iTow] = trig_tower_hcal_et[iTow] = -999;
}
// SPIKES //
spike_N = 0;
for(int isp=0 ; isp<5000 ; isp++) {
spike_outOfTime[isp] = -999;
spike_severityLevel[isp] = -999 ;
//spike_SwissCross[isp] = -999 ;
spike_Et[isp] = -999 ;
spike_phi[isp] = -999 ;
spike_eta[isp] = -999 ;
spike_theta[isp] = -999 ;
spike_TTiphi[isp] = -999 ;
spike_TTieta[isp] = -999 ;
spike_TT_t[isp] = -999 ;
spike_TT_tE[isp] = -999 ;
spike_TT_sFGVB[isp] = -999 ;
spike_TT_adc[isp] = -999 ;
spike_Riphi[isp] = -999 ;
spike_Rieta[isp] = -999 ;
for(int i=0;i<5;i++) {
spike_TT_sFGVB_E[isp][i] = -999 ;
spike_TT_adc_E[isp][i] = -999 ;
}
}
spike_out_outOfTime = -999;
spike_out_severityLevel = -999 ;
//spike_out_SwissCross = -999 ;
spike_out_Et = -999 ;
spike_out_phi = -999 ;
spike_out_eta = -999 ;
spike_out_theta = -999 ;
spike_out_TTiphi = -999 ;
spike_out_TTieta = -999 ;
spike_out_TT_t = -999 ;
spike_out_TT_tE = -999 ;
spike_out_TT_sFGVB = -999 ;
spike_out_TT_adc = -999 ;
spike_out_Riphi = -999 ;
spike_out_Rieta = -999 ;
for(int i=0;i<5;i++) {
spike_out_TT_sFGVB_E[i] = -999 ;
spike_out_TT_adc_E[i] = -999 ;
}
myChain->SetBranchAddress("nEvent",&nEvent);
myChain->SetBranchAddress("nRun",&nRun);
myChain->SetBranchAddress("nLumi",&nLumi);
// Vertices
myChain->SetBranchAddress("vtx_N",&vtx_N);
//myChain->SetBranchAddress("trig_HLT_path",&trig_HLT_path);
myChain->SetBranchAddress("trig_fired_names",&trig_fired_names);
myChain->SetBranchAddress("trig_hltInfo",&trig_hltInfo);
// L1 candidates
myChain->SetBranchAddress("trig_L1emIso_N", &trig_L1emIso_N);
myChain->SetBranchAddress("trig_L1emIso_ieta", &trig_L1emIso_ieta);
myChain->SetBranchAddress("trig_L1emIso_iphi", &trig_L1emIso_iphi);
myChain->SetBranchAddress("trig_L1emIso_rank", &trig_L1emIso_rank);
myChain->SetBranchAddress("trig_L1emNonIso_N", &trig_L1emNonIso_N);
myChain->SetBranchAddress("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta);
myChain->SetBranchAddress("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi);
myChain->SetBranchAddress("trig_L1emNonIso_rank", &trig_L1emNonIso_rank);
// Spikes
myChain->SetBranchAddress("spike_N",&spike_N);
myChain->SetBranchAddress("spike_TTieta",&spike_TTieta);
myChain->SetBranchAddress("spike_TTiphi",&spike_TTiphi);
myChain->SetBranchAddress("spike_Rieta",&spike_Rieta);
myChain->SetBranchAddress("spike_Riphi",&spike_Riphi);
myChain->SetBranchAddress("spike_severityLevel",&spike_severityLevel);
myChain->SetBranchAddress("spike_outOfTime",&spike_outOfTime);
myChain->SetBranchAddress("spike_Et",&spike_Et);
myChain->SetBranchAddress("spike_eta",&spike_eta);
myChain->SetBranchAddress("spike_phi",&spike_phi);
myChain->SetBranchAddress("spike_theta",&spike_theta);
// TrigOnly Chain //
trigOnlyChain->SetBranchAddress("nRun", &nRun_To);
trigOnlyChain->SetBranchAddress("nLumi", &nLumi_To);
trigOnlyChain->SetBranchAddress("nEvent", &nEvent_To);
trigOnlyChain->SetBranchAddress("trig_HLT_path",&trig_HLT_path);
trigOnlyChain->SetBranchAddress("trig_tower_N", &trig_tower_N);
trigOnlyChain->SetBranchAddress("trig_tower_ieta", &trig_tower_ieta);
trigOnlyChain->SetBranchAddress("trig_tower_iphi", &trig_tower_iphi);
trigOnlyChain->SetBranchAddress("trig_tower_adc", &trig_tower_adc);
trigOnlyChain->SetBranchAddress("trig_tower_sFGVB", &trig_tower_sFGVB);
//trigOnlyChain->SetBranchAddress("trig_tower_FG", &trig_tower_FG);
trigOnlyChain->SetBranchAddress("trig_tower_N_E", &trig_tower_N_E);
trigOnlyChain->SetBranchAddress("trig_tower_ieta_E", &trig_tower_ieta_E);
trigOnlyChain->SetBranchAddress("trig_tower_iphi_E", &trig_tower_iphi_E);
trigOnlyChain->SetBranchAddress("trig_tower_adc_E", &trig_tower_adc_E);
trigOnlyChain->SetBranchAddress("trig_tower_sFGVB_E", &trig_tower_sFGVB_E);
//trigOnlyChain->SetBranchAddress("trig_tower_FG_E", &trig_tower_FG_E);
// HCAL TP
trigOnlyChain->SetBranchAddress("trig_tower_hcal_N", &trig_tower_hcal_N);
trigOnlyChain->SetBranchAddress("trig_tower_hcal_ieta", &trig_tower_hcal_ieta);
trigOnlyChain->SetBranchAddress("trig_tower_hcal_iphi", &trig_tower_hcal_iphi);
trigOnlyChain->SetBranchAddress("trig_tower_hcal_et", &trig_tower_hcal_et);
trigOnlyChain->SetBranchAddress("trig_tower_hcal_FG", &trig_tower_hcal_FG);
// L1 candidates collections
trigOnlyChain->SetBranchAddress("trig_L1emIso_N", &trig_L1emIso_N_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_ieta", &trig_L1emIso_ieta_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_iphi", &trig_L1emIso_iphi_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_rank", &trig_L1emIso_rank_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_N", &trig_L1emNonIso_N_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_rank", &trig_L1emNonIso_rank_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_N_M", &trig_L1emIso_N_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_ieta_M", &trig_L1emIso_ieta_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_iphi_M", &trig_L1emIso_iphi_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emIso_rank_M", &trig_L1emIso_rank_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_N_M", &trig_L1emNonIso_N_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_ieta_M", &trig_L1emNonIso_ieta_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_iphi_M", &trig_L1emNonIso_iphi_M_To);
trigOnlyChain->SetBranchAddress("trig_L1emNonIso_rank_M", &trig_L1emNonIso_rank_M_To);
// OUTPUT TREE //
TTree * outtree = new TTree("Spikes","Spikes");
// General informations //
outtree->Branch("nRun",&nRun,"nRun/I");
outtree->Branch("nLumi",&nLumi,"nLumi/I");
outtree->Branch("nEvent",&nEvent,"nEvent/I");
// Vertices //
outtree->Branch("vtx_N",&vtx_N,"vtx_N/I");
outtree->Branch("trig_HLT_path",&trig_HLT_path,"trig_HLT_path[4]/I");
outtree->Branch("trig_fired_names",&trig_fired_names,"trig_fired_names[5000]/C");
outtree->Branch("trig_hltInfo",&trig_hltInfo,"trig_hltInfo[250]/I");
// Trigger towers //
outtree->Branch("trig_tower_N",&trig_tower_N,"trig_tower_N/I");
outtree->Branch("trig_tower_ieta",&trig_tower_ieta,"trig_tower_ieta[4032]/I");
outtree->Branch("trig_tower_iphi",&trig_tower_iphi,"trig_tower_iphi[4032]/I");
outtree->Branch("trig_tower_adc",&trig_tower_adc,"trig_tower_adc[4032]/I");
outtree->Branch("trig_tower_sFGVB",&trig_tower_sFGVB,"trig_tower_sFGVB[4032]/I");
outtree->Branch("trig_tower_FG",&trig_tower_FG,"trig_tower_FG[4032]/I");
//
outtree->Branch("trig_tower_N_E",&trig_tower_N_E,"trig_tower_N_E/I");
outtree->Branch("trig_tower_ieta_E",&trig_tower_ieta_E,"trig_tower_ieta_E[4032]/I");
outtree->Branch("trig_tower_iphi_E",&trig_tower_iphi_E,"trig_tower_iphi_E[4032]/I");
outtree->Branch("trig_tower_adc_E",&trig_tower_adc_E,"trig_tower_adc_E[4032][5]/I");
outtree->Branch("trig_tower_sFGVB_E",&trig_tower_sFGVB_E,"trig_tower_sFGVB_E[4032][5]/I");
outtree->Branch("trig_tower_FG_E",&trig_tower_FG_E,"trig_tower_FG_E[4032][5]/I");
// HCAL TP
outtree->Branch("trig_tower_hcal_N", &trig_tower_hcal_N, "trig_tower_hcal_N/I");
outtree->Branch("trig_tower_hcal_ieta", &trig_tower_hcal_ieta, "trig_tower_hcal_ieta[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_iphi", &trig_tower_hcal_iphi, "trig_tower_hcal_iphi[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_et", &trig_tower_hcal_et, "trig_tower_hcal_et[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_FG", &trig_tower_hcal_FG, "trig_tower_hcal_FG[trig_tower_N]/I");
// L1 candidates from Data
outtree->Branch("trig_L1emIso_N", &trig_L1emIso_N, "trig_L1emIso_N/I");
outtree->Branch("trig_L1emIso_ieta", &trig_L1emIso_ieta, "trig_L1emIso_ieta[4]/I");
outtree->Branch("trig_L1emIso_iphi", &trig_L1emIso_iphi, "trig_L1emIso_iphi[4]/I");
outtree->Branch("trig_L1emIso_rank", &trig_L1emIso_rank, "trig_L1emIso_rank[4]/I");
outtree->Branch("trig_L1emNonIso_N", &trig_L1emNonIso_N, "trig_L1emNonIso_N/I");
outtree->Branch("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta, "trig_L1emNonIso_ieta[4]/I");
outtree->Branch("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi, "trig_L1emNonIso_iphi[4]/I");
outtree->Branch("trig_L1emNonIso_rank", &trig_L1emNonIso_rank, "trig_L1emNonIso_rank[4]/I");
// L1 candidates from TrigOnly
outtree->Branch("trig_L1emIso_N_To", &trig_L1emIso_N_To, "trig_L1emIso_N_To/I");
outtree->Branch("trig_L1emIso_ieta_To", &trig_L1emIso_ieta_To, "trig_L1emIso_ieta_To[4]/I");
outtree->Branch("trig_L1emIso_iphi_To", &trig_L1emIso_iphi_To, "trig_L1emIso_iphi_To[4]/I");
outtree->Branch("trig_L1emIso_rank_To", &trig_L1emIso_rank_To, "trig_L1emIso_rank_To[4]/I");
//
outtree->Branch("trig_L1emNonIso_N_To", &trig_L1emNonIso_N_To, "trig_L1emNonIso_N_To/I");
outtree->Branch("trig_L1emNonIso_ieta_To", &trig_L1emNonIso_ieta_To, "trig_L1emNonIso_ieta_To[4]/I");
outtree->Branch("trig_L1emNonIso_iphi_To", &trig_L1emNonIso_iphi_To, "trig_L1emNonIso_iphi_To[4]/I");
outtree->Branch("trig_L1emNonIso_rank_To", &trig_L1emNonIso_rank_To, "trig_L1emNonIso_rank_To[4]/I");
outtree->Branch("trig_L1emIso_N_M_To", &trig_L1emIso_N_M_To, "trig_L1emIso_N_M_To/I");
outtree->Branch("trig_L1emIso_ieta_M_To", &trig_L1emIso_ieta_M_To, "trig_L1emIso_ieta_M_To[4]/I");
outtree->Branch("trig_L1emIso_iphi_M_To", &trig_L1emIso_iphi_M_To, "trig_L1emIso_iphi_M_To[4]/I");
outtree->Branch("trig_L1emIso_rank_M_To", &trig_L1emIso_rank_M_To, "trig_L1emIso_rank_M_To[4]/I");
//
outtree->Branch("trig_L1emNonIso_N_M_To", &trig_L1emNonIso_N_M_To, "trig_L1emNonIso_N_M_To/I");
outtree->Branch("trig_L1emNonIso_ieta_M_To", &trig_L1emNonIso_ieta_M_To, "trig_L1emNonIso_ieta_M_To[4]/I");
outtree->Branch("trig_L1emNonIso_iphi_M_To", &trig_L1emNonIso_iphi_M_To, "trig_L1emNonIso_iphi_M_To[4]/I");
outtree->Branch("trig_L1emNonIso_rank_M_To", &trig_L1emNonIso_rank_M_To, "trig_L1emNonIso_rank_M_To[4]/I");
outtree->Branch("spike_TTieta",&spike_out_TTieta,"spike_TTieta/I");
outtree->Branch("spike_TTiphi",&spike_out_TTiphi,"spike_TTiphi/I");
//
outtree->Branch("spike_TT_t",&spike_out_TT_t,"spike_TT_t/I");
outtree->Branch("spike_TT_sFGVB",&spike_out_TT_sFGVB,"spike_TT_sFGVB/I");
outtree->Branch("spike_TT_adc",&spike_out_TT_adc,"spike_TT_adc/I");
outtree->Branch("spike_TT_tE",&spike_out_TT_tE,"spike_TT_tE/I");
outtree->Branch("spike_TT_sFGVB_E",&spike_out_TT_sFGVB_E,"spike_TT_sFGVB[5]/I");
outtree->Branch("spike_TT_adc_E",&spike_out_TT_adc_E,"spike_TT_adc[5]/I");
//
outtree->Branch("spike_Rieta",&spike_out_Rieta,"spike_Rieta/I");
outtree->Branch("spike_Riphi",&spike_out_Riphi,"spike_Riphi/I");
outtree->Branch("spike_severityLevel",&spike_out_severityLevel,"spike_severityLevel/I");
outtree->Branch("spike_outOfTime",&spike_out_outOfTime,"spike_outOfTime/I");
outtree->Branch("spike_Et",&spike_out_Et,"spike_Et/D");
outtree->Branch("spike_eta",&spike_out_eta,"spike_eta/D");
outtree->Branch("spike_phi",&spike_out_phi,"spike_phi/D");
outtree->Branch("spike_theta",&spike_out_theta,"spike_theta/D");
//
outtree->Branch("spike_maxEGtrig",&spike_out_maxEGtrig,"spike_maxEGtrig/I");
outtree->Branch("spike_maxEGtrig_To",&spike_out_maxEGtrig_To,"spike_maxEGtrig_To/I");
outtree->Branch("spike_maxEGtrig_M_To",&spike_out_maxEGtrig_M_To,"spike_maxEGtrig_M_To/I");
//
outtree->Branch("spike_RCTL1iso",&spike_out_RCTL1iso,"spike_RCTL1iso/I");
outtree->Branch("spike_RCTL1noniso",&spike_out_RCTL1noniso,"spike_RCTL1noniso/I");
outtree->Branch("spike_RCTL1iso_To",&spike_out_RCTL1iso_To,"spike_RCTL1iso_To/I");
outtree->Branch("spike_RCTL1noniso_To",&spike_out_RCTL1noniso_To,"spike_RCTL1noniso_To/I");
outtree->Branch("spike_RCTL1iso_M_To",&spike_out_RCTL1iso_M_To,"spike_RCTL1iso_M_To/I");
outtree->Branch("spike_RCTL1noniso_M_To",&spike_out_RCTL1noniso_M_To,"spike_RCTL1noniso_M_To/I");
// Variables
bool isGoodRun, evt_trig_EG12;
TString filename;
// Map TT
MAPTT adcTT;
MAPTT::iterator iterTT;
pair<int,int> coords;
int TT_t, TT_tE;
int numEntries = myChain->GetEntries () ;
int nProcess = numEntries;
if(nEntries>=0 && nEntries<numEntries)
nProcess = nEntries;
int nCurrentRun = -999;
outlog << "will process " << nProcess << "/" << numEntries << "entries" << endl;
// Loop over entries //
for (int iEvent = 0 ; iEvent < nProcess ; iEvent++ ) {
// TP Initialization
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = -999;
}
trig_tower_N_M = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_M[iTow] = trig_tower_iphi_M[iTow] = -999;
trig_tower_adc_M[iTow] = trig_tower_sFGVB_M[iTow] = -999;
}
trig_tower_N_E = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_E[iTow] = trig_tower_iphi_E[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_E[iTow][i] = trig_tower_sFGVB_E[iTow][i] = -999;
}
// L1 candidates
trig_L1emIso_N = 0;
trig_L1emNonIso_N = 0;
trig_L1emIso_N_M_To = 0;
trig_L1emNonIso_N_M_To = 0;
trig_L1emIso_N_To = 0;
trig_L1emNonIso_N_To = 0;
for(int il1=0 ; il1<4 ; il1++) {
trig_L1emIso_ieta[il1] = 0;
trig_L1emIso_iphi[il1] = 0;
trig_L1emIso_rank[il1] = 0;
trig_L1emNonIso_ieta[il1] = 0;
trig_L1emNonIso_iphi[il1] = 0;
trig_L1emNonIso_rank[il1] = 0;
trig_L1emIso_ieta_To[il1] = 0;
trig_L1emIso_iphi_To[il1] = 0;
trig_L1emIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_To[il1] = 0;
trig_L1emNonIso_iphi_To[il1] = 0;
trig_L1emNonIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_M_To[il1] = 0;
trig_L1emNonIso_iphi_M_To[il1] = 0;
trig_L1emNonIso_rank_M_To[il1] = 0;
trig_L1emIso_ieta_M_To[il1] = 0;
trig_L1emIso_iphi_M_To[il1] = 0;
trig_L1emIso_rank_M_To[il1] = 0;
}
for(int isp=0 ; isp<5000 ; isp++) {
spike_outOfTime[isp] = -999;
spike_severityLevel[isp] = -999 ;
//spike_SwissCross[isp] = -999 ;
spike_Et[isp] = -999 ;
spike_phi[isp] = -999 ;
spike_eta[isp] = -999 ;
spike_theta[isp] = -999 ;
spike_TTiphi[isp] = -999 ;
spike_TTieta[isp] = -999 ;
spike_TT_t[isp] = -999 ;
spike_TT_tE[isp] = -999 ;
spike_TT_sFGVB[isp] = -999 ;
spike_TT_adc[isp] = -999 ;
spike_Riphi[isp] = -999 ;
spike_Rieta[isp] = -999 ;
for(int i=0;i<5;i++) {
spike_TT_sFGVB_E[isp][i] = -999 ;
spike_TT_adc_E[isp][i] = -999 ;
}
}
myChain->GetEntry (iEvent) ;
// show processed file
if(iEvent==0) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << filename << endl << endl;
}
else if( filename != myChain->GetFile()->GetName() ) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << myChain->GetFile()->GetName() << endl << endl;
}
// show current run/iCat processed
if(iEvent==0) {
nCurrentRun = nRun ;
outlog << "nRun=" << nRun << endl;
}
else if(nRun!=nCurrentRun) {
nCurrentRun=nRun ;
outlog << "nRun=" << nRun << endl;
}
if(debug) cout << "iJson = " << iJson << endl;
if( iJson>-1 && iJson<5) {
isGoodRun = AcceptEventByRunAndLumiSection(nRun, nLumi, jsonMap[iJson]);
if(!isGoodRun) {
outlog << "failed JSON" << endl;
continue;
}
}
// JSON selection ////////////////////////////////////////////
if(debug) cout << "iJson = " << iJson << endl;
if( iJson>-1 && iJson<5) {
isGoodRun = false;
isGoodRun = AcceptEventByRunAndLumiSection(nRun, nLumi, jsonMap[iJson]);
if(!isGoodRun) {
outlog << "failed JSON" << endl;
continue;
}
}
// HLT selection //
if(usr_hlt=="unbias")
if(trig_HLT_path[0]==0) continue;
// Map the trigger tower //////////////////////////////////////////////////////////////////////
adcTT.clear();
for(int t=0 ; t<trig_tower_N ; t++) {
coords = make_pair( trig_tower_ieta[t] , trig_tower_iphi[t] );
adcTT[coords].first = t;
}
for(int t=0 ; t<trig_tower_N_E ; t++) {
coords = make_pair( trig_tower_ieta_E[t] , trig_tower_iphi_E[t] );
iterTT = adcTT.find( coords );
if( iterTT != adcTT.end() ) {
adcTT[coords].second = t;
}
}
// Load trigOnly information ////////////////////////////////////////////////////////////////////
if( GetTrigOnly ) {
runevtTo = make_pair(nRun,nEvent);
iterMapTo = mapTo.find( runevtTo );
//
if( iterMapTo != mapTo.end() )
iEntryTo = mapTo[ runevtTo ];
else iEntryTo = -1;
//
outlog << "trigOnly info : nRun=" << nRun << " | nEvent=" << nEvent << " | iEntryTo=" << iEntryTo << endl;
//
if(iEntryTo>=0) {
trigOnlyChain->GetEntry( iEntryTo );
if(debug) cout << "----> got entry from trigOnlyChain" << endl;
}
else {
if(debug) cout << "----> entry not mapped" << endl;
continue;
}
}
// MATCHING SPIKE / L1-CANDIDATE //////////////////////////////////////////////////////////////////
evt_trig_EG12=false;
outcheckL1 << "ISO_N_data : " ;
for(int i=0 ; i<4 ; i++) {
outcheckL1 << "(" << trig_L1emIso_ieta[i] << ";" << trig_L1emIso_iphi[i] << ")=" << trig_L1emIso_rank[i] << " | ";
if(trig_L1emIso_rank[i] >= 12) evt_trig_EG12=true;
}
outcheckL1 << endl
<< "NONISO_N_data : ";
for(int i=0 ; i<4 ; i++) {
outcheckL1 << "(" << trig_L1emNonIso_ieta[i] << ";" << trig_L1emNonIso_iphi[i] << ")=" << trig_L1emNonIso_rank[i] << " | ";
if(trig_L1emNonIso_rank[i] >= 12) evt_trig_EG12=true;
}
if(!evt_trig_EG12) continue;
outcheckL1 << endl
<< "ISO_N : " ;
for(int i=0 ; i<4 ; i++)
outcheckL1 << "(" << trig_L1emIso_ieta_To[i] << ";" << trig_L1emIso_iphi_To[i] << ")=" << trig_L1emIso_rank_To[i] << " | ";
outcheckL1 << endl
<< "NONISO_N : ";
for(int i=0 ; i<4 ; i++)
outcheckL1 << "(" << trig_L1emNonIso_ieta_To[i] << ";" << trig_L1emNonIso_iphi_To[i] << ")=" << trig_L1emNonIso_rank_To[i]
<< " | ";
outcheckL1 << endl
<< "ISO_M : ";
for(int i=0 ; i<4 ; i++)
outcheckL1 << "(" << trig_L1emIso_ieta_M_To[i] << ";" << trig_L1emIso_iphi_M_To[i] << ")=" << trig_L1emIso_rank_M_To[i]
<< " | ";
outcheckL1 << endl
<< "NONISO_M : ";
for(int i=0 ; i<4 ; i++)
outcheckL1 << "(" << trig_L1emNonIso_ieta_M_To[i] << ";" << trig_L1emNonIso_iphi_M_To[i] << ")="
<< trig_L1emNonIso_rank_M_To[i] << " | ";
outcheckL1 << endl << endl;
///////////////////////////////////////
// LOOP OVER SPIKES ///////////////////
///////////////////////////////////////
for(int iS=0 ; iS<spike_N ; iS++) {
if(iS>=5000) break;
if(spike_Et[iS]<=0) continue;
// Find spikes'TT informations
coords = make_pair( spike_TTieta[iS] , spike_TTiphi[iS] );
iterTT = adcTT.find( coords );
if( iterTT != adcTT.end() ) {
TT_t = (iterTT->second).first ;
TT_tE = (iterTT->second).second ;
if(TT_t<0 || TT_t >= 4032) continue;
spike_TT_t[iS] = TT_t ;
spike_TT_sFGVB[iS] = trig_tower_sFGVB[ TT_t ];
spike_TT_adc[iS] = trig_tower_adc[ TT_t ];
if(TT_tE<0 || TT_tE >= 4032) continue;
spike_TT_tE[iS] = TT_tE ;
for(int iSam=0 ; iSam<5 ; iSam++) {
spike_TT_sFGVB_E[iS][iSam] = trig_tower_sFGVB_E[ TT_tE ][iSam];
spike_TT_adc_E[iS][iSam] = trig_tower_adc_E[ TT_tE ][iSam];
}
}
// Match spike to L1 candidate
spike_maxEGtrig[iS] = spike_maxEGtrig_To[iS] = spike_maxEGtrig_M_To[iS] = 0;
matchL1toSpike( trig_L1emIso_N, trig_L1emIso_ieta, trig_L1emIso_iphi, trig_L1emIso_rank,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1iso[iS], spike_maxEGtrig[iS], outcheckL1 );
matchL1toSpike( trig_L1emIso_N, trig_L1emIso_ieta, trig_L1emIso_iphi, trig_L1emIso_rank,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1noniso[iS], spike_maxEGtrig[iS], outcheckL1 );
matchL1toSpike( trig_L1emIso_N_To, trig_L1emIso_ieta_To, trig_L1emIso_iphi_To, trig_L1emIso_rank_To,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1iso_To[iS], spike_maxEGtrig_To[iS], outcheckL1 );
matchL1toSpike( trig_L1emIso_N_To, trig_L1emIso_ieta_To, trig_L1emIso_iphi_To, trig_L1emIso_rank_To,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1noniso_To[iS], spike_maxEGtrig_To[iS], outcheckL1 );
matchL1toSpike( trig_L1emIso_N_M_To, trig_L1emIso_ieta_M_To, trig_L1emIso_iphi_M_To, trig_L1emIso_rank_M_To,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1iso_M_To[iS], spike_maxEGtrig_M_To[iS], outcheckL1 );
matchL1toSpike( trig_L1emIso_N_M_To, trig_L1emIso_ieta_M_To, trig_L1emIso_iphi_M_To, trig_L1emIso_rank_M_To,
spike_Rieta[iS], spike_Riphi[iS], spike_RCTL1noniso_M_To[iS], spike_maxEGtrig_M_To[iS], outcheckL1 );
// Fill the tree //
spike_out_outOfTime = spike_outOfTime[iS] ;
spike_out_severityLevel = spike_severityLevel[iS] ;
spike_out_Et = spike_Et[iS] ;
spike_out_phi = spike_phi[iS] ;
spike_out_eta = spike_eta[iS] ;
spike_out_theta = spike_theta[iS] ;
spike_out_TTiphi = spike_TTiphi[iS] ;
spike_out_TTieta = spike_TTieta[iS] ;
spike_out_TT_t = spike_TT_t[iS] ;
spike_out_TT_tE = spike_TT_tE[iS] ;
spike_out_TT_sFGVB = spike_TT_sFGVB[iS] ;
spike_out_TT_adc = spike_TT_adc[iS] ;
spike_out_Riphi = spike_Riphi[iS] ;
spike_out_Rieta = spike_Rieta[iS] ;
spike_out_maxEGtrig = spike_maxEGtrig[iS];
spike_out_maxEGtrig_To = spike_maxEGtrig_To[iS];
spike_out_maxEGtrig_M_To = spike_maxEGtrig_M_To[iS];
spike_out_RCTL1iso = spike_RCTL1iso[iS];
spike_out_RCTL1noniso = spike_RCTL1noniso[iS];
spike_out_RCTL1iso_To = spike_RCTL1iso_To[iS];
spike_out_RCTL1noniso_To = spike_RCTL1noniso_To[iS];
spike_out_RCTL1iso_M_To = spike_RCTL1iso_M_To[iS];
spike_out_RCTL1noniso_M_To = spike_RCTL1noniso_M_To[iS];
for(int i=0;i<5;i++) {
spike_out_TT_sFGVB_E[i] = spike_TT_sFGVB_E[iS][i] ;
spike_out_TT_adc_E[i] = spike_TT_adc_E[iS][i] ;
}
outtree->Fill();
}
}
// Record tree
outlog << "recording tree..." << endl;
outtree->Write();
outlog << "recorded !" << endl;
outfile->Close();
outlog << "file closed." << endl;
return 1;
}
int process(TString nameChain, TString file, int iFile, int nEntries, TString dirOut,
ofstream& outlog, int iJson, TString RunPhase, bool debug) {
// OUTPUT FILE //
ostringstream ossi("");
ossi << iFile ;
// std::cout<<"ossi is what?? "<<ossi<<std::endl;
// std::cout<<"ossi is what?? "<<ossi<<std::endl;
// std::cout<<"ossi.str() is what?? "<<ossi.str()<<std::endl;
TString name=(TString)("elepairs_"+ossi.str()+".root");
TFile *outfile = new TFile(name,"RECREATE");
ossi.str("");
// INPUT TREE //
TChain * myChain = new TChain(nameChain);
myChain->Add(file);
int nEvent, nRun, nLumi ;
// Vertices //
int _vtx_N;
double _vtx_x[200], _vtx_y[200], _vtx_z[200];
double _vtx_normalizedChi2[200], _vtx_ndof[200], _vtx_nTracks[200], _vtx_d0[200];
// Trigger Paths //
int trig_hltInfo[250];
int _trig_isEleHLTpath;
int trig_HLT_path[4]; // unbias, EG5, EG8, EG12
char trig_fired_names[5000];
//
vector<string> m_HLT_pathsV;
vector<string> m_HLT_triggered;
vector<int> m_HLT_pathsV_check;
// m_HLT_pathsV.clear();
// m_HLT_pathsV_check.clear();
// for(int iP=0 ; iP<(int)HLT_paths_.size() ; iP++) {
// m_HLT_pathsV.push_back( HLT_paths_[iP]);
// m_HLT_pathsV_check.push_back(0);
// }
// Electrons
TClonesArray * electrons = new TClonesArray ("TLorentzVector");
int ele_N, sc_hybrid_N;
int ele_outOfTimeSeed[10],ele_severityLevelSeed[10];
double ele_he[10], ele_sigmaietaieta[10];
double ele_hcalDepth1TowerSumEt_dr03[10], ele_hcalDepth2TowerSumEt_dr03[10];
double ele_ecalRecHitSumEt_dr03[10], ele_tkSumPt_dr03[10];
double ele_sclEta[10], ele_sclEt[10];
//double ecalIsoRel03,hcalIsoRel03,trackIsoRel03;
double ele_deltaphiin[10], ele_deltaetain[10];
double ele_conv_dist[10], ele_conv_dcot[10];
double ele_fbrem[10];
int ele_expected_inner_hits[10];
//int ele_ambiguousGsfTracks[10];
int ele_isConversion[10];
int ele_echarge[10];
//
int ele_RCTeta[10], ele_RCTphi[10], ele_RCTL1iso[10], ele_RCTL1noniso[10], ele_RCTL1iso_M[10], ele_RCTL1noniso_M[10];
int ele_TTetaVect[10][50], ele_TTphiVect[10][50];
double ele_TTetVect[10][50];
int ele_RCTetaVect[10][10], ele_RCTphiVect[10][10], ele_RCTL1isoVect[10][10],
ele_RCTL1nonisoVect[10][10],ele_RCTL1isoVect_M[10][10], ele_RCTL1nonisoVect_M[10][10];
double ele_RCTetVect[10][10];
// TP info
const int nTow = 4032;
int trig_tower_N,trig_tower_ieta[nTow],trig_tower_iphi[nTow],trig_tower_adc[nTow],trig_tower_sFGVB[nTow];
int trig_tower_N_modif,trig_tower_ieta_modif[nTow],trig_tower_iphi_modif[nTow],trig_tower_adc_modif[nTow],trig_tower_sFGVB_modif[nTow];
int trig_tower_N_emul,trig_tower_ieta_emul[nTow],trig_tower_iphi_emul[nTow],trig_tower_adc_emul[nTow][5],trig_tower_sFGVB_emul[nTow][5];
// HCAL TP
int trig_tower_hcal_N, trig_tower_hcal_ieta[4032], trig_tower_hcal_iphi[4032], trig_tower_hcal_FG[4032],trig_tower_hcal_et[4032];
int trig_L1emIso_N, trig_L1emNonIso_N, trig_L1emIso_N_M, trig_L1emNonIso_N_M;
// L1 candidates info
int trig_L1emIso_ieta[4], trig_L1emIso_iphi[4], trig_L1emIso_rank[4];
int trig_L1emNonIso_ieta[4], trig_L1emNonIso_iphi[4], trig_L1emNonIso_rank[4];
int trig_L1emIso_ieta_M[4], trig_L1emIso_iphi_M[4], trig_L1emIso_rank_M[4];
int trig_L1emNonIso_ieta_M[4], trig_L1emNonIso_iphi_M[4], trig_L1emNonIso_rank_M[4];
// L1 prefiring
int trig_preL1emIso_N;
int trig_preL1emNonIso_N;
int trig_preL1emIso_ieta[4], trig_preL1emIso_iphi[4], trig_preL1emIso_rank[4];
int trig_preL1emNonIso_ieta[4], trig_preL1emNonIso_iphi[4],trig_preL1emNonIso_rank[4];
// L1 postfiring
int trig_postL1emIso_N;
int trig_postL1emNonIso_N;
int trig_postL1emIso_ieta[4], trig_postL1emIso_iphi[4], trig_postL1emIso_rank[4];
int trig_postL1emNonIso_ieta[4], trig_postL1emNonIso_iphi[4],trig_postL1emNonIso_rank[4];
// Masking
int trig_nMaskedRCT, trig_nMaskedCh;
int trig_iMaskedRCTeta[100], trig_iMaskedRCTphi[100], trig_iMaskedRCTcrate[100], trig_iMaskedTTeta[100], trig_iMaskedTTphi[100];
int trig_strip_mask_N;
int trig_strip_mask_TTieta[1000], trig_strip_mask_TTiphi[1000], trig_strip_mask_status[1000],
trig_strip_mask_StripID[1000], trig_strip_mask_PseudoStripID[1000], trig_strip_mask_TccID[1000], trig_strip_mask_CCU[1000],
trig_strip_mask_xtal_ix[1000][5], trig_strip_mask_xtal_iy[1000][5], trig_strip_mask_xtal_iz[1000][5];
int trig_xtal_mask_N; // [EB+EE]
int trig_xtal_mask_ieta[1000],trig_xtal_mask_iphi[1000], // for EE : xtal ieta->ix ; iphi -> iy
trig_xtal_mask_TTieta[1000],trig_xtal_mask_TTiphi[1000], // but for EE towers, still ieta, iphi...
trig_xtal_mask_Rieta[1000],trig_xtal_mask_Riphi[1000],
trig_xtal_mask_status[1000], trig_xtal_mask_EBEE[1000]; // EBEE = {0,1} => 0=EB ; 1=EE
//double trig_xtal_mask_eT[1000];
// INITIALIZATION //
//
// Global
nEvent = 0;
nRun = 0;
nLumi = 0;
//
// Vertices
_vtx_N = 0;
for(int iv=0;iv<200;iv++) {
_vtx_normalizedChi2[iv] = 0.;
_vtx_ndof[iv] = 0.;
_vtx_nTracks[iv] = 0.;
_vtx_d0[iv] = 0.;
_vtx_x[iv] = 0.;
_vtx_y[iv] = 0.;
_vtx_z[iv] = 0.;
}
//
// L1 candidates
trig_L1emIso_N = 0;
trig_L1emNonIso_N = 0;
trig_preL1emIso_N = 0;
trig_preL1emNonIso_N = 0;
trig_postL1emIso_N = 0;
trig_postL1emNonIso_N = 0;
//
for(int il1=0 ; il1<4 ; il1++) {
trig_L1emIso_ieta[il1] = 0;
trig_L1emIso_iphi[il1] = 0;
trig_L1emIso_rank[il1] = 0;
trig_L1emNonIso_ieta[il1] = 0;
trig_L1emNonIso_iphi[il1] = 0;
trig_L1emNonIso_rank[il1] = 0;
trig_preL1emIso_ieta[il1] = 0;
trig_preL1emIso_iphi[il1] = 0;
trig_preL1emIso_rank[il1] = 0;
trig_preL1emNonIso_ieta[il1] = 0;
trig_preL1emNonIso_iphi[il1] = 0;
trig_preL1emNonIso_rank[il1] = 0;
trig_postL1emIso_ieta[il1] = 0;
trig_postL1emIso_iphi[il1] = 0;
trig_postL1emIso_rank[il1] = 0;
trig_postL1emNonIso_ieta[il1] = 0;
trig_postL1emNonIso_iphi[il1] = 0;
trig_postL1emNonIso_rank[il1] = 0;
}
//
// Trigger towers
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = -999;
}
trig_tower_N_modif = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_modif[iTow] = trig_tower_iphi_modif[iTow] = -999;
trig_tower_adc_modif[iTow] = trig_tower_sFGVB_modif[iTow] = -999;
}
trig_tower_N_emul = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_emul[iTow] = trig_tower_iphi_emul[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_emul[iTow][i] = trig_tower_sFGVB_emul[iTow][i] = -999;
}
trig_tower_hcal_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_hcal_ieta[iTow] = trig_tower_hcal_iphi[iTow] = -999;
trig_tower_hcal_FG[iTow] = trig_tower_hcal_et[iTow] = -999;
}
//
// Masked Towers
trig_nMaskedRCT=0;
trig_nMaskedCh=0;
//
for (int ii=0;ii<100;ii++) {
trig_iMaskedRCTeta[ii] = -999;
trig_iMaskedRCTphi[ii] = -999;
trig_iMaskedRCTcrate[ii] = -999;
trig_iMaskedTTeta[ii] = -999;
trig_iMaskedTTphi[ii] = -999;
}
//
// Masked strip/xtals
trig_strip_mask_N = 0;
trig_xtal_mask_N = 0;
//
for(int i=0 ; i<1000 ; i++) {
trig_strip_mask_TTieta[i] = -999;
trig_strip_mask_TTiphi[i] = -999;
trig_strip_mask_status[i] = -999;
trig_strip_mask_StripID[i] = -999;
trig_strip_mask_PseudoStripID[i] = -999;
trig_strip_mask_TccID[i] = -999;
trig_strip_mask_CCU[i] = -999;
//
for(int j=0 ; j<5 ; j++) {
trig_strip_mask_xtal_ix[i][j] = -999;
trig_strip_mask_xtal_iy[i][j] = -999;
trig_strip_mask_xtal_iz[i][j] = -999;
}
trig_xtal_mask_ieta[i] = -999;
trig_xtal_mask_iphi[i] = -999;
trig_xtal_mask_TTieta[i] = -999;
trig_xtal_mask_TTiphi[i] = -999;
trig_xtal_mask_Rieta[i] = -999;
trig_xtal_mask_Riphi[i] = -999;
trig_xtal_mask_status[i] = -999;
trig_xtal_mask_EBEE[i] = -999;
}
// Disable useless branches
//myChain->SetBranchStatus("spike_*",0);
//myChain->SetBranchStatus("vtx_*",0);
//myChain->SetBranchStatus("skim_*",0);
//myChain->SetBranchStatus("trig_pre*",0);
//myChain->SetBranchStatus("trig_post*",0);
//myChain->SetBranchStatus("trig_HLT*",0);
//myChain->SetBranchStatus("BS*",0);
//myChain->SetBranchStatus("MC_*",0);
//myChain->SetBranchStatus("ele_MC*",0);
////myChain->SetBranchStatus("ele_eid*",0);
////myChain->SetBranchStatus("ele_Seed*",0);
//myChain->SetBranchStatus("ele_charge*",0);
//myChain->SetBranchStatus("met_*",0);
//myChain->SetBranchStatus("muons*",0);
//myChain->SetBranchStatus("jets*",0);
myChain->SetBranchStatus("sc*",0);
//myChain->SetBranchStatus("sc_hybrid_N",1);
//myChain->SetBranchStatus("",0);
// Global
myChain->SetBranchAddress("nEvent",&nEvent);
myChain->SetBranchAddress("nRun",&nRun);
myChain->SetBranchAddress("nLumi",&nLumi);
// Trigger
// myChain->SetBranchAddress ("trig_HLT_triggered", &m_HLT_triggered);
// myChain->SetBranchAddress ("trig_HLT_pathsV", &m_HLT_pathsV);
// myChain->SetBranchAddress ("trig_HLT_pathsV_check", &m_HLT_pathsV_check);
//
myChain->SetBranchAddress("trig_HLT_path",&trig_HLT_path);
// unbias, EG5, EG8, EG12
//
myChain->SetBranchAddress("trig_fired_names",&trig_fired_names);
myChain->SetBranchAddress("trig_hltInfo",&trig_hltInfo);
// SC
//myChain->SetBranchAddress("sc_hybrid_N", &sc_hybrid_N);
// Electrons
myChain->SetBranchAddress("ele_N", &ele_N);
myChain->SetBranchAddress("electrons",&electrons);
myChain->SetBranchAddress("ele_severityLevelSeed", &ele_severityLevelSeed);
myChain->SetBranchAddress("ele_he",&ele_he);
myChain->SetBranchAddress("ele_sigmaietaieta",&ele_sigmaietaieta);
myChain->SetBranchAddress("ele_hcalDepth1TowerSumEt_dr03", &ele_hcalDepth1TowerSumEt_dr03);
myChain->SetBranchAddress("ele_hcalDepth2TowerSumEt_dr03", &ele_hcalDepth2TowerSumEt_dr03);
myChain->SetBranchAddress("ele_ecalRecHitSumEt_dr03", &ele_ecalRecHitSumEt_dr03);
myChain->SetBranchAddress("ele_tkSumPt_dr03",&ele_tkSumPt_dr03);
myChain->SetBranchAddress("ele_sclEta",&ele_sclEta);
myChain->SetBranchAddress("ele_sclEt",&ele_sclEt);
myChain->SetBranchAddress("ele_expected_inner_hits",&ele_expected_inner_hits);
myChain->SetBranchAddress("ele_deltaphiin",&ele_deltaphiin);
myChain->SetBranchAddress("ele_deltaetain",&ele_deltaetain);
myChain->SetBranchAddress("ele_conv_dist",&ele_conv_dist);
myChain->SetBranchAddress("ele_conv_dcot",&ele_conv_dcot);
myChain->SetBranchAddress("ele_fbrem",&ele_fbrem);
//myChain->SetBranchAddress("ele_ambiguousGsfTracks", &ele_ambiguousGsfTracks);
myChain->SetBranchAddress("ele_isConversion",&ele_isConversion);
myChain->SetBranchAddress("ele_echarge",&ele_echarge);
// L1 electron informations
myChain->SetBranchAddress("ele_TTetaVect", &ele_TTetaVect);
myChain->SetBranchAddress("ele_TTphiVect", &ele_TTphiVect);
myChain->SetBranchAddress("ele_TTetVect", &ele_TTetVect);
//
myChain->SetBranchAddress("ele_RCTeta", &ele_RCTeta);
myChain->SetBranchAddress("ele_RCTphi", &ele_RCTphi);
myChain->SetBranchAddress("ele_RCTL1iso", &ele_RCTL1iso);
myChain->SetBranchAddress("ele_RCTL1noniso", &ele_RCTL1noniso);
myChain->SetBranchAddress("ele_RCTL1iso_M", &ele_RCTL1iso_M);
myChain->SetBranchAddress("ele_RCTL1noniso_M", &ele_RCTL1noniso_M);
myChain->SetBranchAddress("ele_RCTetaVect", &ele_RCTetaVect);
myChain->SetBranchAddress("ele_RCTphiVect", &ele_RCTphiVect);
myChain->SetBranchAddress("ele_RCTetVect", &ele_RCTetVect);
myChain->SetBranchAddress("ele_RCTL1isoVect", &ele_RCTL1isoVect);
myChain->SetBranchAddress("ele_RCTL1nonisoVect", &ele_RCTL1nonisoVect);
myChain->SetBranchAddress("ele_RCTL1isoVect_M", &ele_RCTL1isoVect_M);
myChain->SetBranchAddress("ele_RCTL1nonisoVect_M", &ele_RCTL1nonisoVect_M);
// L1 candidates
myChain->SetBranchAddress("trig_L1emIso_N", &trig_L1emIso_N);
myChain->SetBranchAddress("trig_L1emIso_ieta", &trig_L1emIso_ieta);
myChain->SetBranchAddress("trig_L1emIso_iphi", &trig_L1emIso_iphi);
myChain->SetBranchAddress("trig_L1emIso_rank", &trig_L1emIso_rank);
myChain->SetBranchAddress("trig_L1emNonIso_N", &trig_L1emNonIso_N);
myChain->SetBranchAddress("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta);
myChain->SetBranchAddress("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi);
myChain->SetBranchAddress("trig_L1emNonIso_rank", &trig_L1emNonIso_rank);
myChain->SetBranchAddress("trig_L1emIso_N_M", &trig_L1emIso_N_M);
myChain->SetBranchAddress("trig_L1emIso_ieta_M", &trig_L1emIso_ieta_M);
myChain->SetBranchAddress("trig_L1emIso_iphi_M", &trig_L1emIso_iphi_M);
myChain->SetBranchAddress("trig_L1emIso_rank_M", &trig_L1emIso_rank_M);
myChain->SetBranchAddress("trig_L1emNonIso_N_M", &trig_L1emNonIso_N_M);
myChain->SetBranchAddress("trig_L1emNonIso_ieta_M", &trig_L1emNonIso_ieta_M);
myChain->SetBranchAddress("trig_L1emNonIso_iphi_M", &trig_L1emNonIso_iphi_M);
myChain->SetBranchAddress("trig_L1emNonIso_rank_M", &trig_L1emNonIso_rank_M);
// Pre/post - firing L1 candidates
myChain->SetBranchAddress("trig_preL1emIso_N", &trig_preL1emIso_N);
myChain->SetBranchAddress("trig_preL1emIso_ieta", &trig_preL1emIso_ieta);
myChain->SetBranchAddress("trig_preL1emIso_iphi", &trig_preL1emIso_iphi);
myChain->SetBranchAddress("trig_preL1emIso_rank", &trig_preL1emIso_rank);
//
myChain->SetBranchAddress("trig_preL1emNonIso_N", &trig_preL1emNonIso_N);
myChain->SetBranchAddress("trig_preL1emNonIso_ieta", &trig_preL1emNonIso_ieta);
myChain->SetBranchAddress("trig_preL1emNonIso_iphi", &trig_preL1emNonIso_iphi);
myChain->SetBranchAddress("trig_preL1emNonIso_rank", &trig_preL1emNonIso_rank);
//
myChain->SetBranchAddress("trig_postL1emIso_N", &trig_postL1emIso_N);
myChain->SetBranchAddress("trig_postL1emIso_ieta", &trig_postL1emIso_ieta);
myChain->SetBranchAddress("trig_postL1emIso_iphi", &trig_postL1emIso_iphi);
myChain->SetBranchAddress("trig_postL1emIso_rank", &trig_postL1emIso_rank);
//
myChain->SetBranchAddress("trig_postL1emNonIso_N", &trig_postL1emNonIso_N);
myChain->SetBranchAddress("trig_postL1emNonIso_ieta", &trig_postL1emNonIso_ieta);
myChain->SetBranchAddress("trig_postL1emNonIso_iphi", &trig_postL1emNonIso_iphi);
myChain->SetBranchAddress("trig_postL1emNonIso_rank", &trig_postL1emNonIso_rank);
// Trigger Towers
// normal collection
myChain->SetBranchAddress("trig_tower_N", &trig_tower_N);
myChain->SetBranchAddress("trig_tower_ieta", &trig_tower_ieta);
myChain->SetBranchAddress("trig_tower_iphi", &trig_tower_iphi);
myChain->SetBranchAddress("trig_tower_adc", &trig_tower_adc);
myChain->SetBranchAddress("trig_tower_sFGVB", &trig_tower_sFGVB);
// modified collection
myChain->SetBranchAddress("trig_tower_N_modif", &trig_tower_N_modif);
myChain->SetBranchAddress("trig_tower_ieta_modif", &trig_tower_ieta_modif);
myChain->SetBranchAddress("trig_tower_iphi_modif", &trig_tower_iphi_modif);
myChain->SetBranchAddress("trig_tower_adc_modif", &trig_tower_adc_modif);
myChain->SetBranchAddress("trig_tower_sFGVB_modif", &trig_tower_sFGVB_modif);
myChain->SetBranchAddress("trig_tower_N_emul", &trig_tower_N_emul);
myChain->SetBranchAddress("trig_tower_ieta_emul", &trig_tower_ieta_emul);
myChain->SetBranchAddress("trig_tower_iphi_emul", &trig_tower_iphi_emul);
myChain->SetBranchAddress("trig_tower_adc_emul", &trig_tower_adc_emul);
myChain->SetBranchAddress("trig_tower_sFGVB_emul", &trig_tower_sFGVB_emul);
// HCAL TP
myChain->SetBranchAddress("trig_tower_hcal_N", &trig_tower_hcal_N);
myChain->SetBranchAddress("trig_tower_hcal_ieta", &trig_tower_hcal_ieta);
myChain->SetBranchAddress("trig_tower_hcal_iphi", &trig_tower_hcal_iphi);
myChain->SetBranchAddress("trig_tower_hcal_et", &trig_tower_hcal_et);
myChain->SetBranchAddress("trig_tower_hcal_FG", &trig_tower_hcal_FG);
// Strip masking
myChain->SetBranchAddress("trig_strip_mask_N", &trig_strip_mask_N);
myChain->SetBranchAddress("trig_strip_mask_TTieta", &trig_strip_mask_TTieta);
myChain->SetBranchAddress("trig_strip_mask_TTiphi", &trig_strip_mask_TTiphi);
myChain->SetBranchAddress("trig_strip_mask_StripID", &trig_strip_mask_StripID);
myChain->SetBranchAddress("trig_strip_mask_PseudoStripID", &trig_strip_mask_PseudoStripID);
myChain->SetBranchAddress("trig_strip_mask_TccID", &trig_strip_mask_TccID);
myChain->SetBranchAddress("trig_strip_mask_CCU", &trig_strip_mask_CCU);
myChain->SetBranchAddress("trig_strip_mask_xtal_ix", &trig_strip_mask_xtal_ix);
myChain->SetBranchAddress("trig_strip_mask_xtal_iy", &trig_strip_mask_xtal_iy);
myChain->SetBranchAddress("trig_strip_mask_xtal_iz", &trig_strip_mask_xtal_iz);
//
// Crystal masking
myChain->SetBranchAddress("trig_xtal_mask_N", &trig_xtal_mask_N);
myChain->SetBranchAddress("trig_xtal_mask_ieta", &trig_xtal_mask_ieta);
myChain->SetBranchAddress("trig_xtal_mask_iphi", &trig_xtal_mask_iphi);
myChain->SetBranchAddress("trig_xtal_mask_TTieta", &trig_xtal_mask_TTieta);
myChain->SetBranchAddress("trig_xtal_mask_TTiphi", &trig_xtal_mask_TTiphi);
myChain->SetBranchAddress("trig_xtal_mask_Rieta", &trig_xtal_mask_Rieta);
myChain->SetBranchAddress("trig_xtal_mask_Riphi", &trig_xtal_mask_Riphi);
myChain->SetBranchAddress("trig_xtal_mask_status", &trig_xtal_mask_status);
myChain->SetBranchAddress("trig_xtal_mask_EBEE", &trig_xtal_mask_EBEE);
// Masking
myChain->SetBranchAddress("trig_nMaskedRCT", &trig_nMaskedRCT);
myChain->SetBranchAddress("trig_iMaskedRCTeta", &trig_iMaskedRCTeta);
myChain->SetBranchAddress("trig_iMaskedRCTcrate", &trig_iMaskedRCTcrate);
myChain->SetBranchAddress("trig_iMaskedRCTphi", &trig_iMaskedRCTphi);
myChain->SetBranchAddress("trig_nMaskedCh", &trig_nMaskedCh);
myChain->SetBranchAddress("trig_iMaskedTTeta", &trig_iMaskedTTeta);
myChain->SetBranchAddress("trig_iMaskedTTphi", &trig_iMaskedTTphi);
if(debug) cout << "got the input tree, start to define output tree" << endl;
// OUTPUT TREE //
TTree * outtree = new TTree("ElePairs","ElePairs");
// General informations
outtree->Branch("nRun",&nRun,"nRun/I");
outtree->Branch("nLumi",&nLumi,"nLumi/I");
outtree->Branch("nEvent",&nEvent,"nEvent/I");
// Vertices
outtree->Branch("vtx_N",&_vtx_N,"vtx_N/I");
outtree->Branch("vtx_normalizedChi2",&_vtx_normalizedChi2,"vtx_normalizedChi2[200]/D");
outtree->Branch("vtx_ndof",&_vtx_ndof,"vtx_ndof[200]/D");
outtree->Branch("vtx_nTracks",&_vtx_nTracks,"vtx_nTracks[200]/D");
outtree->Branch("vtx_d0",&_vtx_d0,"vtx_d0[200]/D");
outtree->Branch("vtx_x",&_vtx_x,"vtx_x[200]/D");
outtree->Branch("vtx_y",&_vtx_y,"vtx_y[200]/D");
outtree->Branch("vtx_z",&_vtx_z,"vtx_z[200]/D");
// HLT informations
// outtree->Branch ("trig_HLT_triggered", &m_HLT_triggered, 256000,0);
// outtree->Branch ("trig_HLT_pathsV", &m_HLT_pathsV, 256000,0);
// outtree->Branch ("trig_HLT_pathsV_check", &m_HLT_pathsV_check, 256000,0);
//
outtree->Branch("trig_HLT_path",&trig_HLT_path,"trig_HLT_path[4]/I");
// unbias, EG5, EG8, EG12
//
outtree->Branch("trig_fired_names",&trig_fired_names,"trig_fired_names[5000]/C");
outtree->Branch("trig_hltInfo",&trig_hltInfo,"trig_hltInfo[250]/I");
// Trigger towers
outtree->Branch("trig_tower_N",&trig_tower_N,"trig_tower_N/I");
outtree->Branch("trig_tower_ieta",&trig_tower_ieta,"trig_tower_ieta[4032]/I");
outtree->Branch("trig_tower_iphi",&trig_tower_iphi,"trig_tower_iphi[4032]/I");
outtree->Branch("trig_tower_adc",&trig_tower_adc,"trig_tower_adc[4032]/I");
outtree->Branch("trig_tower_sFGVB",&trig_tower_sFGVB,"trig_tower_sFGVB[4032]/I");
//
outtree->Branch("trig_tower_N_modif",&trig_tower_N_modif,"trig_tower_N_modif/I");
outtree->Branch("trig_tower_ieta_modif",&trig_tower_ieta_modif,"trig_tower_ieta_modif[4032]/I");
outtree->Branch("trig_tower_iphi_modif",&trig_tower_iphi_modif,"trig_tower_iphi_modif[4032]/I");
outtree->Branch("trig_tower_adc_modif",&trig_tower_adc_modif,"trig_tower_adc_modif[4032]/I");
outtree->Branch("trig_tower_sFGVB_modif",&trig_tower_sFGVB_modif,"trig_tower_sFGVB_modif[4032]/I");
//
outtree->Branch("trig_tower_N_emul",&trig_tower_N_emul,"trig_tower_N_emul/I");
outtree->Branch("trig_tower_ieta_emul",&trig_tower_ieta_emul,"trig_tower_ieta_emul[4032]/I");
outtree->Branch("trig_tower_iphi_emul",&trig_tower_iphi_emul,"trig_tower_iphi_emul[4032]/I");
outtree->Branch("trig_tower_adc_emul",&trig_tower_adc_emul,"trig_tower_adc_emul[4032][5]/I");
outtree->Branch("trig_tower_sFGVB_emul",&trig_tower_sFGVB_emul,"trig_tower_sFGVB_emul[4032][5]/I");
// HCAL TP
outtree->Branch("trig_tower_hcal_N", &trig_tower_hcal_N, "trig_tower_hcal_N/I");
outtree->Branch("trig_tower_hcal_ieta", &trig_tower_hcal_ieta, "trig_tower_hcal_ieta[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_iphi", &trig_tower_hcal_iphi, "trig_tower_hcal_iphi[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_et", &trig_tower_hcal_et, "trig_tower_hcal_et[trig_tower_N]/I");
outtree->Branch("trig_tower_hcal_FG", &trig_tower_hcal_FG, "trig_tower_hcal_FG[trig_tower_N]/I");
// Strip masking
outtree->Branch("trig_strip_mask_N", &trig_strip_mask_N, "trig_strip_mask_N/I");
outtree->Branch("trig_strip_mask_TTieta", &trig_strip_mask_TTieta, "trig_strip_mask_TTieta[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_TTiphi", &trig_strip_mask_TTiphi, "trig_strip_mask_TTiphi[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_StripID", &trig_strip_mask_StripID, "trig_strip_mask_StripID[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_PseudoStripID", &trig_strip_mask_PseudoStripID, "trig_strip_mask_PseudoStripID[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_TccID", &trig_strip_mask_TccID, "trig_strip_mask_TccID[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_CCU", &trig_strip_mask_CCU, "trig_strip_mask_CCU[trig_strip_mask_N]/I");
outtree->Branch("trig_strip_mask_xtal_ix", &trig_strip_mask_xtal_ix, "trig_strip_mask_xtal_ix[trig_strip_mask_N][5]/I");
outtree->Branch("trig_strip_mask_xtal_iy", &trig_strip_mask_xtal_iy, "trig_strip_mask_xtal_iy[trig_strip_mask_N][5]/I");
outtree->Branch("trig_strip_mask_xtal_iz", &trig_strip_mask_xtal_iz, "trig_strip_mask_xtal_iz[trig_strip_mask_N][5]/I");
//
// Crystal masking
outtree->Branch("trig_xtal_mask_N", &trig_xtal_mask_N, "trig_xtal_mask_N/I");
outtree->Branch("trig_xtal_mask_ieta", &trig_xtal_mask_ieta, "trig_xtal_mask_ieta[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_iphi", &trig_xtal_mask_iphi, "trig_xtal_mask_iphi[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_TTieta", &trig_xtal_mask_TTieta, "trig_xtal_mask_TTieta[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_TTiphi", &trig_xtal_mask_TTiphi, "trig_xtal_mask_TTiphi[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_Rieta", &trig_xtal_mask_Rieta, "trig_xtal_mask_Rieta[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_Riphi", &trig_xtal_mask_Riphi, "trig_xtal_mask_Riphi[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_status", &trig_xtal_mask_status, "trig_xtal_mask_status[trig_xtal_mask_N]/I");
outtree->Branch("trig_xtal_mask_EBEE", &trig_xtal_mask_EBEE, "trig_xtal_mask_EBEE[trig_xtal_mask_N]/I");
// L1 candidates
outtree->Branch("trig_L1emIso_N", &trig_L1emIso_N, "trig_L1emIso_N/I");
outtree->Branch("trig_L1emIso_ieta", &trig_L1emIso_ieta, "trig_L1emIso_ieta[4]/I");
outtree->Branch("trig_L1emIso_iphi", &trig_L1emIso_iphi, "trig_L1emIso_iphi[4]/I");
outtree->Branch("trig_L1emIso_rank", &trig_L1emIso_rank, "trig_L1emIso_rank[4]/I");
//outtree->Branch("trig_L1emIso_eta", &trig_L1emIso_eta, "trig_L1emIso_eta[4]/D");
//outtree->Branch("trig_L1emIso_phi", &trig_L1emIso_phi, "trig_L1emIso_phi[4]/D");
// outtree->Branch("trig_L1emIso_energy",&trig_L1emIso_energy,"trig_L1emIso_energy[4]/D");
// outtree->Branch("trig_L1emIso_et", &trig_L1emIso_et, "trig_L1emIso_et[4]/D");
//
outtree->Branch("trig_L1emNonIso_N", &trig_L1emNonIso_N, "trig_L1emNonIso_N/I");
outtree->Branch("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta, "trig_L1emNonIso_ieta[4]/I");
outtree->Branch("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi, "trig_L1emNonIso_iphi[4]/I");
outtree->Branch("trig_L1emNonIso_rank", &trig_L1emNonIso_rank, "trig_L1emNonIso_rank[4]/I");
// outtree->Branch("trig_L1emNonIso_eta", &trig_L1emNonIso_eta, "trig_L1emNonIso_eta[4]/D");
// outtree->Branch("trig_L1emNonIso_phi", &trig_L1emNonIso_phi, "trig_L1emNonIso_phi[4]/D");
// outtree->Branch("trig_L1emNonIso_energy",&trig_L1emNonIso_energy,"trig_L1emNonIso_energy[4]/D");
// outtree->Branch("trig_L1emNonIso_et", &trig_L1emNonIso_et, "trig_L1emNonIso_et[4]/D");
//
outtree->Branch("trig_L1emIso_N_M", &trig_L1emIso_N_M, "trig_L1emIso_N_M/I");
outtree->Branch("trig_L1emIso_ieta_M", &trig_L1emIso_ieta_M, "trig_L1emIso_ieta_M[4]/I");
outtree->Branch("trig_L1emIso_iphi_M", &trig_L1emIso_iphi_M, "trig_L1emIso_iphi_M[4]/I");
outtree->Branch("trig_L1emIso_rank_M", &trig_L1emIso_rank_M, "trig_L1emIso_rank_M[4]/I");
// outtree->Branch("trig_L1emIso_eta_M", &trig_L1emIso_eta_M, "trig_L1emIso_eta_M[4]/D");
// outtree->Branch("trig_L1emIso_phi_M", &trig_L1emIso_phi_M, "trig_L1emIso_phi_M[4]/D");
// outtree->Branch("trig_L1emIso_energy_M",&trig_L1emIso_energy_M,"trig_L1emIso_energy_M[4]/D");
// outtree->Branch("trig_L1emIso_et_M", &trig_L1emIso_et_M, "trig_L1emIso_et_M[4]/D");
//
outtree->Branch("trig_L1emNonIso_N_M", &trig_L1emNonIso_N_M, "trig_L1emNonIso_N_M/I");
outtree->Branch("trig_L1emNonIso_ieta_M", &trig_L1emNonIso_ieta_M, "trig_L1emNonIso_ieta_M[4]/I");
outtree->Branch("trig_L1emNonIso_iphi_M", &trig_L1emNonIso_iphi_M, "trig_L1emNonIso_iphi_M[4]/I");
outtree->Branch("trig_L1emNonIso_rank_M", &trig_L1emNonIso_rank_M, "trig_L1emNonIso_rank_M[4]/I");
// outtree->Branch("trig_L1emNonIso_eta_M", &trig_L1emNonIso_eta_M, "trig_L1emNonIso_eta_M[4]/D");
// outtree->Branch("trig_L1emNonIso_phi_M", &trig_L1emNonIso_phi_M, "trig_L1emNonIso_phi_M[4]/D");
// outtree->Branch("trig_L1emNonIso_energy_M",&trig_L1emNonIso_energy_M,"trig_L1emNonIso_energy_M[4]/D");
// outtree->Branch("trig_L1emNonIso_et_M", &trig_L1emNonIso_et_M, "trig_L1emNonIso_et_M[4]/D");
// pre-post firing L1 candidates
outtree->Branch("trig_preL1emIso_N", &trig_preL1emIso_N, "trig_preL1emIso_N/I");
outtree->Branch("trig_preL1emIso_ieta", &trig_preL1emIso_ieta, "trig_preL1emIso_ieta[4]/I");
outtree->Branch("trig_preL1emIso_iphi", &trig_preL1emIso_iphi, "trig_preL1emIso_iphi[4]/I");
outtree->Branch("trig_preL1emIso_rank", &trig_preL1emIso_rank, "trig_preL1emIso_rank[4]/I");
//
outtree->Branch("trig_preL1emNonIso_N", &trig_preL1emNonIso_N, "trig_preL1emNonIso_N/I");
outtree->Branch("trig_preL1emNonIso_ieta", &trig_preL1emNonIso_ieta, "trig_preL1emNonIso_ieta[4]/I");
outtree->Branch("trig_preL1emNonIso_iphi", &trig_preL1emNonIso_iphi, "trig_preL1emNonIso_iphi[4]/I");
outtree->Branch("trig_preL1emNonIso_rank", &trig_preL1emNonIso_rank, "trig_preL1emNonIso_rank[4]/I");
//
outtree->Branch("trig_postL1emIso_N", &trig_postL1emIso_N, "trig_postL1emIso_N/I");
outtree->Branch("trig_postL1emIso_ieta", &trig_postL1emIso_ieta, "trig_postL1emIso_ieta[4]/I");
outtree->Branch("trig_postL1emIso_iphi", &trig_postL1emIso_iphi, "trig_postL1emIso_iphi[4]/I");
outtree->Branch("trig_postL1emIso_rank", &trig_postL1emIso_rank, "trig_postL1emIso_rank[4]/I");
//
outtree->Branch("trig_postL1emNonIso_N", &trig_postL1emNonIso_N, "trig_postL1emNonIso_N/I");
outtree->Branch("trig_postL1emNonIso_ieta", &trig_postL1emNonIso_ieta, "trig_postL1emNonIso_ieta[4]/I");
outtree->Branch("trig_postL1emNonIso_iphi", &trig_postL1emNonIso_iphi, "trig_postL1emNonIso_iphi[4]/I");
outtree->Branch("trig_postL1emNonIso_rank", &trig_postL1emNonIso_rank, "trig_postL1emNonIso_rank[4]/I");
//
outtree->Branch("trig_nMaskedRCT", &trig_nMaskedRCT, "trig_nMaskedRCT/I");
outtree->Branch("trig_iMaskedRCTeta", &trig_iMaskedRCTeta, "trig_iMaskedRCTeta[trig_nMaskedRCT]/I");
outtree->Branch("trig_iMaskedRCTcrate", &trig_iMaskedRCTcrate,"trig_iMaskedRCTcrate[trig_nMaskedRCT]/I");
outtree->Branch("trig_iMaskedRCTphi", &trig_iMaskedRCTphi, "trig_iMaskedRCTphi[trig_nMaskedRCT]/I");
outtree->Branch("trig_nMaskedCh", &trig_nMaskedCh, "trig_nMaskedCh/I");
outtree->Branch("trig_iMaskedTTeta", &trig_iMaskedTTeta, "trig_iMaskedTTeta[trig_nMaskedCh]/I");
outtree->Branch("trig_iMaskedTTphi", &trig_iMaskedTTphi, "trig_iMaskedTTphi[trig_nMaskedCh]/I");
// Pairs informations
double pair_M;
double pair_eta[2], pair_sclEta[2], pair_sclEt[2], pair_phi[2], pair_pT[2], pair_eT[2], pair_E[2];
int pair_cuts[2], pair_HLT_Ele27_cut[2], pair_fidu[2], pair_charge[2], pair_RCTeta[2], pair_RCTphi[2],
pair_L1iso[2], pair_L1noniso[2], pair_L1iso_M[2], pair_L1noniso_M[2];
int pair_RCTetaVect[2][10], pair_RCTphiVect[2][10],
pair_L1isoVect[2][10], pair_L1nonisoVect[2][10],pair_L1isoVect_M[2][10], pair_L1nonisoVect_M[2][10];
double pair_RCTetVect[2][10];
int pair_TTetaVect[2][50], pair_TTphiVect[2][50];
double pair_TTetVect[2][50];
//
outtree->Branch("pair_M",&pair_M,"pair_M/D");
//
outtree->Branch("pair_cuts",&pair_cuts,"pair_cuts[2]/I");
// 0 : noCut | 1 : VBTF 95 | 2 : VBTF 80 | 3 : VBTF 60
outtree->Branch("pair_HLT_Ele27_cut",&pair_HLT_Ele27_cut,"pair_HLT_Ele27_cut[2]/I");
outtree->Branch("pair_fidu",&pair_fidu,"pair_fidu[2]/I");
//
outtree->Branch("pair_eta",&pair_eta,"pair_eta[2]/D");
outtree->Branch("pair_sclEta",&pair_sclEta,"pair_sclEta[2]/D");
outtree->Branch("pair_phi",&pair_phi,"pair_phi[2]/D");
outtree->Branch("pair_RCTeta",&pair_RCTeta,"pair_RCTeta[2]/I");
outtree->Branch("pair_RCTphi",&pair_RCTphi,"pair_RCTphi[2]/I");
//
outtree->Branch("pair_charge",&pair_charge,"pair_charge[2]/I");
outtree->Branch("pair_pT",&pair_pT,"pair_pT[2]/D");
outtree->Branch("pair_eT",&pair_eT,"pair_eT[2]/D");
outtree->Branch("pair_sclEt",&pair_sclEt,"pair_sclEt[2]/D");
outtree->Branch("pair_E",&pair_E,"pair_E[2]/D");
outtree->Branch("pair_TTetaVect", &pair_TTetaVect,"pair_TTetaVect[2][50]/I");
outtree->Branch("pair_TTphiVect", &pair_TTphiVect,"pair_TTphiVect[2][50]/I");
outtree->Branch("pair_TTetVect", &pair_TTetVect,"pair_TTetVect[2][50]/D");
outtree->Branch("pair_L1iso",&pair_L1iso,"pair_L1iso[2]/I");
outtree->Branch("pair_L1noniso",&pair_L1noniso,"pair_L1noniso[2]/I");
outtree->Branch("pair_L1iso_M",&pair_L1iso_M,"pair_L1iso_M[2]/I");
outtree->Branch("pair_L1noniso_M",&pair_L1noniso_M,"pair_L1noniso_M[2]/I");
//
outtree->Branch("pair_RCTetVect",&pair_RCTetVect,"pair_RCTetVect[2][10]/D");
outtree->Branch("pair_RCTetaVect",&pair_RCTetaVect,"pair_RCTetaVect[2][10]/I");
outtree->Branch("pair_RCTphiVect",&pair_RCTphiVect,"pair_RCTphiVect[2][10]/I");
outtree->Branch("pair_L1isoVect",&pair_L1isoVect,"pair_L1isoVect[2][10]/I");
outtree->Branch("pair_L1nonisoVect",&pair_L1nonisoVect,"pair_L1nonisoVect[2][10]/I");
outtree->Branch("pair_L1isoVect_M",&pair_L1isoVect_M,"pair_L1isoVect_M[2][10]/I");
outtree->Branch("pair_L1nonisoVect_M",&pair_L1nonisoVect_M,"pair_L1nonisoVect_M[2][10]/I");
if(debug) cout << "output tree defined" << endl;
// USEFUL VARIABLES //
vector<int> pairIdx;
int cutEle[2], fidu[2];
bool cut_HLT_Ele27[2];
TLorentzVector * cand[2];
TLorentzVector total;
bool isGoodRun;
TString filename;
// // JSON FILE READER //
//
// string jsonDir = "/data_CMS/cms/ndaci/" ;
// const int nJson = 10;
// string jsonFile[nJson]; // 2010B, May10, Aug05, Prompt
// map<int, vector<pair<int, int> > > jsonMap[nJson] ;
//
// jsonFile[0] = jsonDir + "ndaci_2011A/JSON/goodrunlist_json.txt" ;
// jsonFile[1] = jsonDir + "ndaci_2011A/JSON/Cert_160404-163869_7TeV_May10ReReco_Collisions11_JSON_v3.txt" ;
// jsonFile[2] = jsonDir + "ndaci_2011A/JSON/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON_v3.txt" ;
// jsonFile[3] = jsonDir + "ndaci_2011A/JSON/Cert_160404-180252_7TeV_PromptReco_Collisions11_JSON.txt" ;
// jsonFile[4] = jsonDir + "ndaci_2011A/JSON/Cert_160404-180252_7TeV_ReRecoNov08_Collisions11_JSON.txt" ;
//
// // 2012
// jsonFile[5] = jsonDir + "ndaci_2012/JSON/Cert_190456-203002_8TeV_PromptReco_Collisions12_JSON.txt";
// jsonFile[6] = jsonDir + "ndaci_2012/JSON/Cert_190456-196531_8TeV_13Jul2012ReReco_Collisions12_JSON_v2.txt";
// jsonFile[7] = jsonDir + "ndaci_2012/JSON/Cert_190782-190949_8TeV_06Aug2012ReReco_Collisions12_JSON.txt";
// jsonFile[8] = jsonDir + "ndaci_2012/JSON/Cert_198022-198523_8TeV_24Aug2012ReReco_Collisions12_JSON.txt";
// jsonFile[9] = jsonDir + "ndaci_2012/JSON/Cert_190456-208357_8TeV_PromptReco_Collisions12_JSON.txt";
//
// for(int i=0 ; i<nJson ; i++)
// jsonMap[i] = readJSONFile(jsonFile[i]);
//
// if(debug) cout << "JSON defined" << endl;
if(debug) cout << "skipping JSON definition and JSON checks" << endl;
// -------------------------------------------------------------------------------
// LOOP OVER EVENTS
// -------------------------------------------------------------------------------
if(debug) cout << "gonna loop over events" << endl;
int numEntries = myChain->GetEntries () ;
int nProcess = numEntries;
if(nEntries>=0 && nEntries<numEntries)
nProcess = nEntries;
int nCurrentRun = -999;
outlog << "will process " << nProcess << "/" << numEntries << "entries" << endl;
for (int iEvent = 0 ; iEvent < nProcess ; iEvent++ )
{
// HLT information
for(int i=0 ; i<4 ; i++)
trig_HLT_path[i]=0;
for(int i=0 ; i<250 ; i++)
trig_hltInfo[i]=0;
// TP Initialization
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = -999;
}
trig_tower_N_modif = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_modif[iTow] = trig_tower_iphi_modif[iTow] = -999;
trig_tower_adc_modif[iTow] = trig_tower_sFGVB_modif[iTow] = -999;
}
trig_tower_N_emul = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_emul[iTow] = trig_tower_iphi_emul[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_emul[iTow][i] = trig_tower_sFGVB_emul[iTow][i] = -999;
}
myChain->GetEntry (iEvent) ;
// show processed file
if(iEvent==0) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << filename << endl << endl;
}
else if( filename != myChain->GetFile()->GetName() ) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << myChain->GetFile()->GetName() << endl << endl;
}
// show current run/iCat processed
if(iEvent==0) {
nCurrentRun = nRun ;
outlog << "nRun=" << nRun << endl;
}
else if(nRun!=nCurrentRun) {
nCurrentRun=nRun ;
outlog << "nRun=" << nRun << endl;
}
// // run selection (using both json files)
// //int iJson = detJson(nRun);
// //int iJson = 4;
// if(debug) cout << "iJson = " << iJson << endl;
// outlog << "iJson = " << iJson << endl;
// if( iJson>-1 && iJson<9) {
// isGoodRun = AcceptEventByRunAndLumiSection(nRun, nLumi, jsonMap[iJson]);
// if(!isGoodRun) {
// outlog << "failed JSON" << endl;
// continue;
// }
// }
// else {
// outlog << "no proper JSON file" << endl;
// //continue;
// }
// at least 2 electrons
if(ele_N<2) continue;
else outlog << "ele_N=" << ele_N << endl;
// LOOP OVER ELECTRONS //
if(debug) cout << "<-- ele_N=" << ele_N << endl
<< "--- electrons.size=" << electrons->GetSize() << endl;
for( int iEle1=0 ; iEle1<ele_N ; iEle1++ ) {
if(debug) cout << "--- get ele #" << iEle1 << endl;
cand[0] = (TLorentzVector*) (electrons->At (iEle1)) ;
if(debug) cout << "--- got it" << endl;
// severity selection
if( ele_severityLevelSeed[iEle1] >= 3 ) continue;
// check whether electrons of the pair pass HLT_Ele27 Id/Iso cuts
if(debug) cout << "--- checks VBTF cuts" << endl;
cut_HLT_Ele27[0] = VBTFcuts( "HLT_Ele27", RunPhase,
cand[0]->Pt(), cand[0]->Et(), ele_sclEta[iEle1], cand[0]->Eta(), ele_tkSumPt_dr03[iEle1], ele_ecalRecHitSumEt_dr03[iEle1],
ele_hcalDepth1TowerSumEt_dr03[iEle1], ele_hcalDepth2TowerSumEt_dr03[iEle1], ele_expected_inner_hits[iEle1],
ele_deltaphiin[iEle1], ele_deltaetain[iEle1], ele_he[iEle1], ele_sigmaietaieta[iEle1],
ele_conv_dist[iEle1], ele_conv_dcot[iEle1], ele_fbrem[iEle1], ele_isConversion[iEle1] ) ;
// check if ele is a good tag candidate : pass VBTF 95 and has pT>5 GeV
cutEle[0] = 0;
cutEle[0] = whichCuts( RunPhase, cand[0]->Pt(), cand[0]->Et(), ele_sclEta[iEle1], cand[0]->Eta(), ele_tkSumPt_dr03[iEle1], ele_ecalRecHitSumEt_dr03[iEle1],
ele_hcalDepth1TowerSumEt_dr03[iEle1], ele_hcalDepth2TowerSumEt_dr03[iEle1], ele_expected_inner_hits[iEle1],
ele_deltaphiin[iEle1], ele_deltaetain[iEle1], ele_he[iEle1], ele_sigmaietaieta[iEle1],
ele_conv_dist[iEle1], ele_conv_dcot[iEle1], ele_fbrem[iEle1], ele_isConversion[iEle1] ) ;
fidu[0] = 0;
if ( fabs(ele_sclEta[iEle1]) < 2.5 && ( fabs(ele_sclEta[iEle1]) > 1.566 || fabs(ele_sclEta[iEle1])<1.4442 ) )
fidu[0] = 1 ;
if( cutEle[0]>0 && cand[0]->Et()>=5. ) {
if(debug) cout << "--- ele #" << iEle1 << " is a good tag candidate" << endl;
// loop to find probe candidates
for( int iEle2=0 ; iEle2<ele_N ; iEle2++ ) {
if(debug) cout << "----- looks Ele #" << iEle2 << endl;
cand[1] = (TLorentzVector*) (electrons->At (iEle2)) ;
// severity
if( ele_severityLevelSeed[iEle2] >= 3 ) continue;
// check HLT_Ele27 cuts
cut_HLT_Ele27[1] = VBTFcuts( "HLT_Ele27", RunPhase,
cand[1]->Pt(), cand[1]->Et(), ele_sclEta[iEle1], cand[1]->Eta(), ele_tkSumPt_dr03[iEle1], ele_ecalRecHitSumEt_dr03[iEle1],
ele_hcalDepth1TowerSumEt_dr03[iEle1], ele_hcalDepth2TowerSumEt_dr03[iEle1], ele_expected_inner_hits[iEle1],
ele_deltaphiin[iEle1], ele_deltaetain[iEle1], ele_he[iEle1], ele_sigmaietaieta[iEle1],
ele_conv_dist[iEle1], ele_conv_dcot[iEle1], ele_fbrem[iEle1], ele_isConversion[iEle1] ) ;
// check cuts passed by probe candidate
cutEle[1] = whichCuts( RunPhase, cand[1]->Pt(), cand[0]->Et(), ele_sclEta[iEle2], cand[1]->Eta(), ele_tkSumPt_dr03[iEle2], ele_ecalRecHitSumEt_dr03[iEle2],
ele_hcalDepth1TowerSumEt_dr03[iEle2], ele_hcalDepth2TowerSumEt_dr03[iEle2], ele_expected_inner_hits[iEle2],
ele_deltaphiin[iEle2], ele_deltaetain[iEle2], ele_he[iEle2], ele_sigmaietaieta[iEle2],
ele_conv_dist[iEle2], ele_conv_dcot[iEle2], ele_fbrem[iEle2], ele_isConversion[iEle2] ) ;
fidu[1] = 0;
if ( fabs(ele_sclEta[iEle2]) < 2.5 && ( fabs(ele_sclEta[iEle2]) > 1.566 || fabs(ele_sclEta[iEle2])<1.4442 ) )
fidu[1] = 1 ;
if( cutEle[1]>0 && iEle2<=iEle1 ) continue; // prevents to create several times the same pair
if(debug) cout << "---> OK to form a pre-selected pair <--" << endl;
// get the pair informations
total = (*cand[0]) + (*cand[1]) ;
// keep only pairs with Mee > 30 GeV
if( total.M() < 30. ) continue;
pair_M = total.M() ;
pairIdx.clear();
pairIdx.push_back(iEle1);
pairIdx.push_back(iEle2);
for(int iP=0 ; iP<2 ; iP++) {
pair_cuts[iP] = cutEle[iP];
pair_fidu[iP] = fidu[iP];
pair_HLT_Ele27_cut[iP] = cut_HLT_Ele27[iP];
//
pair_eta[iP] = cand[iP]->Eta();
pair_sclEta[iP] = ele_sclEta[pairIdx[iP]];
pair_phi[iP] = cand[iP]->Phi();
pair_RCTeta[iP] = ele_RCTeta[pairIdx[iP]];
pair_RCTphi[iP] = ele_RCTphi[pairIdx[iP]];
//
pair_charge[iP] = ele_echarge[pairIdx[iP]];
pair_pT[iP] = cand[iP]->Pt();
pair_eT[iP] = cand[iP]->Et();
pair_sclEt[iP] = ele_sclEt[pairIdx[iP]];
pair_E[iP] = cand[iP]->E();
//
pair_L1iso[iP] = ele_RCTL1iso[pairIdx[iP]];
pair_L1noniso[iP] = ele_RCTL1noniso[pairIdx[iP]];
pair_L1iso_M[iP] = ele_RCTL1iso_M[pairIdx[iP]];
pair_L1noniso_M[iP] = ele_RCTL1noniso_M[pairIdx[iP]];
//
for(int iV=0 ; iV<10 ; iV++) {
pair_RCTetVect[iP][iV] = ele_RCTetVect[pairIdx[iP]][iV];
pair_RCTetaVect[iP][iV] = ele_RCTetaVect[pairIdx[iP]][iV];
pair_RCTphiVect[iP][iV] = ele_RCTphiVect[pairIdx[iP]][iV];
pair_L1isoVect[iP][iV] = ele_RCTL1isoVect[pairIdx[iP]][iV];
pair_L1nonisoVect[iP][iV] = ele_RCTL1nonisoVect[pairIdx[iP]][iV];
pair_L1isoVect_M[iP][iV] = ele_RCTL1isoVect_M[pairIdx[iP]][iV];
pair_L1nonisoVect_M[iP][iV] = ele_RCTL1nonisoVect_M[pairIdx[iP]][iV];
}
//
for(int iV=0 ; iV<50 ; iV++) {
pair_TTetaVect[iP][iV] = ele_TTetaVect[pairIdx[iP]][iV];
pair_TTphiVect[iP][iV] = ele_TTphiVect[pairIdx[iP]][iV];
pair_TTetVect[iP][iV] = ele_TTetVect[pairIdx[iP]][iV];
}
}
if(debug) cout << "outtree->Fill();" << endl;
outtree->Fill();
} // loop for probe
} // endif ele1 is good tag candidate
} // loop over electrons
}//loop over events
if(debug) cout << "End loop events" << endl;
outlog << "End loop events" << endl;
// Record tree
if(debug) cout << "recording tree..." << endl;
outlog << "recording tree..." << endl;
outtree->Write();
if(debug) cout << "recorded !" << endl;
outlog << "recorded !" << endl;
outfile->Close();
if(debug) cout << "file closed." << endl;
outlog << "file closed." << endl;
return 1;
}
int spikes_getContamFromMerged(int nEntries=-1,
TString dirOut="/home/llr/cms/ndaci/SKWork/macro/skEfficiency/Spikes/HighPuContamination/try2/",
TString dirIn="/data_CMS/cms/ndaci/ndaci_2011A/Commissioning/CommissioningEmulReco/NewKill/highPU/MergedToData/",
TString file="all_spikes.root",
TString usr_hlt="noHLT",
TString nameChain="Spikes",
float spikeCut=8.,
bool debug=false)
{
ofstream outlog(dirOut+"/log_getContam.txt",ios::out);
// INPUT TREE //
if(debug) cout << "--- add data trees to myChain" << endl;
TChain * myChain = new TChain(nameChain);
myChain->Add(dirIn+file);
// VARIABLES //
int nEvent, nRun, nLumi ; // data
//int nEvent_To, nRun_To, nLumi_To; // trigOnly
// Vertices //
int vtx_N;
double _vtx_x[200], _vtx_y[200], _vtx_z[200];
double _vtx_normalizedChi2[200], _vtx_ndof[200], _vtx_nTracks[200], _vtx_d0[200];
// Trigger Paths //
int trig_hltInfo[250];
//int _trig_isEleHLTpath;
int trig_HLT_path[4]; // unbias, EG5, EG8, EG12
char trig_fired_names[5000];
vector<string> m_HLT_pathsV;
vector<string> m_HLT_triggered;
vector<int> m_HLT_pathsV_check;
// Spikes
int spike_N,spike_TTieta[5000], spike_TTiphi[5000], spike_Rieta[5000], spike_Riphi[5000], spike_severityLevel[5000],
spike_outOfTime[5000];
double spike_Et[5000], spike_eta[5000], spike_phi[5000], spike_theta[5000];
int spike_RCTL1iso[5000], spike_RCTL1noniso[5000], spike_RCTL1iso_To[5000], spike_RCTL1noniso_To[5000],
spike_RCTL1iso_M_To[5000], spike_RCTL1noniso_M_To[5000],
spike_maxEGtrig[5000], spike_maxEGtrig_To[5000], spike_maxEGtrig_M_To[5000];
// TP info
const int nTow = 4032;
int trig_tower_N,trig_tower_ieta[nTow],trig_tower_iphi[nTow],trig_tower_adc[nTow],trig_tower_sFGVB[nTow],trig_tower_FG[nTow];
int trig_tower_N_M,trig_tower_ieta_M[nTow],trig_tower_iphi_M[nTow],trig_tower_adc_M[nTow],trig_tower_sFGVB_M[nTow],
trig_tower_FG_M[nTow];
int trig_tower_N_E,trig_tower_ieta_E[nTow],trig_tower_iphi_E[nTow],trig_tower_adc_E[nTow][5],trig_tower_sFGVB_E[nTow][5],
trig_tower_FG_E[nTow][5];
// HCAL TP //
int trig_tower_hcal_N, trig_tower_hcal_ieta[4032], trig_tower_hcal_iphi[4032], trig_tower_hcal_FG[4032],trig_tower_hcal_et[4032];
// L1 Candidates //
int trig_L1emIso_N, trig_L1emNonIso_N;
int trig_L1emIso_N_To, trig_L1emNonIso_N_To, trig_L1emIso_N_M_To, trig_L1emNonIso_N_M_To;
// L1 candidates info //
int trig_L1emIso_ieta[4], trig_L1emIso_iphi[4], trig_L1emIso_rank[4];
int trig_L1emNonIso_ieta[4], trig_L1emNonIso_iphi[4], trig_L1emNonIso_rank[4];
int trig_L1emIso_ieta_To[4], trig_L1emIso_iphi_To[4], trig_L1emIso_rank_To[4];
int trig_L1emNonIso_ieta_To[4], trig_L1emNonIso_iphi_To[4], trig_L1emNonIso_rank_To[4];
int trig_L1emIso_ieta_M_To[4], trig_L1emIso_iphi_M_To[4], trig_L1emIso_rank_M_To[4];
int trig_L1emNonIso_ieta_M_To[4], trig_L1emNonIso_iphi_M_To[4], trig_L1emNonIso_rank_M_To[4];
// INITIALIZATION //
//
// Global
nEvent = 0;
nRun = 0;
nLumi = 0;
//
// Vertices
vtx_N = 0;
for(int iv=0;iv<200;iv++) {
_vtx_normalizedChi2[iv] = 0.;
_vtx_ndof[iv] = 0.;
_vtx_nTracks[iv] = 0.;
_vtx_d0[iv] = 0.;
_vtx_x[iv] = 0.;
_vtx_y[iv] = 0.;
_vtx_z[iv] = 0.;
}
//
// L1 candidates
trig_L1emIso_N = 0;
trig_L1emNonIso_N = 0;
trig_L1emIso_N_M_To = 0;
trig_L1emNonIso_N_M_To = 0;
for(int il1=0 ; il1<4 ; il1++) {
trig_L1emIso_ieta[il1] = 0;
trig_L1emIso_iphi[il1] = 0;
trig_L1emIso_rank[il1] = 0;
trig_L1emNonIso_ieta[il1] = 0;
trig_L1emNonIso_iphi[il1] = 0;
trig_L1emNonIso_rank[il1] = 0;
trig_L1emIso_ieta_To[il1] = 0;
trig_L1emIso_iphi_To[il1] = 0;
trig_L1emIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_To[il1] = 0;
trig_L1emNonIso_iphi_To[il1] = 0;
trig_L1emNonIso_rank_To[il1] = 0;
trig_L1emIso_ieta_M_To[il1] = 0;
trig_L1emIso_iphi_M_To[il1] = 0;
trig_L1emIso_rank_M_To[il1] = 0;
trig_L1emNonIso_ieta_M_To[il1] = 0;
trig_L1emNonIso_iphi_M_To[il1] = 0;
trig_L1emNonIso_rank_M_To[il1] = 0;
}
// Trigger towers
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = trig_tower_FG[iTow] = -999;
}
trig_tower_N_M = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_M[iTow] = trig_tower_iphi_M[iTow] = -999;
trig_tower_adc_M[iTow] = trig_tower_sFGVB_M[iTow] = trig_tower_FG_M[iTow] = -999;
}
trig_tower_N_E = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_E[iTow] = trig_tower_iphi_E[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_E[iTow][i] = trig_tower_sFGVB_E[iTow][i] = trig_tower_FG_E[iTow][i] = -999;
}
trig_tower_hcal_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_hcal_ieta[iTow] = trig_tower_hcal_iphi[iTow] = -999;
trig_tower_hcal_FG[iTow] = trig_tower_hcal_et[iTow] = -999;
}
// SPIKES //
spike_N = 0;
for(int isp=0 ; isp<5000 ; isp++) {
spike_outOfTime[isp] = -999;
spike_severityLevel[isp] = -999 ;
//spike_SwissCross[isp] = -999 ;
spike_Et[isp] = -999 ;
spike_phi[isp] = -999 ;
spike_eta[isp] = -999 ;
spike_theta[isp] = -999 ;
spike_TTiphi[isp] = -999 ;
spike_TTieta[isp] = -999 ;
spike_Riphi[isp] = -999 ;
spike_Rieta[isp] = -999 ;
//
spike_RCTL1iso[isp] = -999 ;
spike_RCTL1noniso[isp] = -999 ;
spike_RCTL1iso_To[isp] = -999 ;
spike_RCTL1noniso_To[isp] = -999 ;
spike_RCTL1iso_M_To[isp] = -999 ;
spike_RCTL1noniso_M_To[isp] = -999 ;
//spike_time[isp] = -999 ;
}
myChain->SetBranchAddress("nEvent",&nEvent);
myChain->SetBranchAddress("nRun",&nRun);
myChain->SetBranchAddress("nLumi",&nLumi);
myChain->SetBranchAddress("vtx_N",&vtx_N);
myChain->SetBranchAddress("trig_HLT_path",&trig_HLT_path);
myChain->SetBranchAddress("trig_fired_names",&trig_fired_names);
myChain->SetBranchAddress("trig_hltInfo",&trig_hltInfo);
// L1 candidates
myChain->SetBranchAddress("trig_L1emIso_N", &trig_L1emIso_N);
myChain->SetBranchAddress("trig_L1emIso_ieta", &trig_L1emIso_ieta);
myChain->SetBranchAddress("trig_L1emIso_iphi", &trig_L1emIso_iphi);
myChain->SetBranchAddress("trig_L1emIso_rank", &trig_L1emIso_rank);
myChain->SetBranchAddress("trig_L1emNonIso_N", &trig_L1emNonIso_N);
myChain->SetBranchAddress("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta);
myChain->SetBranchAddress("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi);
myChain->SetBranchAddress("trig_L1emNonIso_rank", &trig_L1emNonIso_rank);
// Spikes
myChain->SetBranchAddress("spike_N",&spike_N);
myChain->SetBranchAddress("spike_TTieta",&spike_TTieta);
myChain->SetBranchAddress("spike_TTiphi",&spike_TTiphi);
myChain->SetBranchAddress("spike_Rieta",&spike_Rieta);
myChain->SetBranchAddress("spike_Riphi",&spike_Riphi);
myChain->SetBranchAddress("spike_severityLevel",&spike_severityLevel);
myChain->SetBranchAddress("spike_outOfTime",&spike_outOfTime);
myChain->SetBranchAddress("spike_Et",&spike_Et);
myChain->SetBranchAddress("spike_eta",&spike_eta);
myChain->SetBranchAddress("spike_phi",&spike_phi);
myChain->SetBranchAddress("spike_theta",&spike_theta);
//
myChain->SetBranchAddress("spike_maxEGtrig",&spike_maxEGtrig);
myChain->SetBranchAddress("spike_maxEGtrig_To",&spike_maxEGtrig_To);
myChain->SetBranchAddress("spike_maxEGtrig_M_To",&spike_maxEGtrig_M_To);
myChain->SetBranchAddress("trig_tower_N", &trig_tower_N);
myChain->SetBranchAddress("trig_tower_ieta", &trig_tower_ieta);
myChain->SetBranchAddress("trig_tower_iphi", &trig_tower_iphi);
myChain->SetBranchAddress("trig_tower_adc", &trig_tower_adc);
myChain->SetBranchAddress("trig_tower_sFGVB", &trig_tower_sFGVB);
myChain->SetBranchAddress("trig_tower_FG", &trig_tower_FG);
myChain->SetBranchAddress("trig_tower_N_E", &trig_tower_N_E);
myChain->SetBranchAddress("trig_tower_ieta_E", &trig_tower_ieta_E);
myChain->SetBranchAddress("trig_tower_iphi_E", &trig_tower_iphi_E);
myChain->SetBranchAddress("trig_tower_adc_E", &trig_tower_adc_E);
myChain->SetBranchAddress("trig_tower_sFGVB_E", &trig_tower_sFGVB_E);
myChain->SetBranchAddress("trig_tower_FG_E", &trig_tower_FG_E);
// HCAL TP
myChain->SetBranchAddress("trig_tower_hcal_N", &trig_tower_hcal_N);
myChain->SetBranchAddress("trig_tower_hcal_ieta", &trig_tower_hcal_ieta);
myChain->SetBranchAddress("trig_tower_hcal_iphi", &trig_tower_hcal_iphi);
myChain->SetBranchAddress("trig_tower_hcal_et", &trig_tower_hcal_et);
myChain->SetBranchAddress("trig_tower_hcal_FG", &trig_tower_hcal_FG);
myChain->SetBranchStatus("trig_tower*",0);
// L1 candidates collections
myChain->SetBranchAddress("trig_L1emIso_N", &trig_L1emIso_N);
myChain->SetBranchAddress("trig_L1emIso_ieta", &trig_L1emIso_ieta);
myChain->SetBranchAddress("trig_L1emIso_iphi", &trig_L1emIso_iphi);
myChain->SetBranchAddress("trig_L1emIso_rank", &trig_L1emIso_rank);
myChain->SetBranchAddress("trig_L1emNonIso_N", &trig_L1emNonIso_N);
myChain->SetBranchAddress("trig_L1emNonIso_ieta", &trig_L1emNonIso_ieta);
myChain->SetBranchAddress("trig_L1emNonIso_iphi", &trig_L1emNonIso_iphi);
myChain->SetBranchAddress("trig_L1emNonIso_rank", &trig_L1emNonIso_rank);
myChain->SetBranchAddress("trig_L1emIso_N_To", &trig_L1emIso_N_To);
myChain->SetBranchAddress("trig_L1emIso_ieta_To", &trig_L1emIso_ieta_To);
myChain->SetBranchAddress("trig_L1emIso_iphi_To", &trig_L1emIso_iphi_To);
myChain->SetBranchAddress("trig_L1emIso_rank_To", &trig_L1emIso_rank_To);
myChain->SetBranchAddress("trig_L1emNonIso_N_To", &trig_L1emNonIso_N_To);
myChain->SetBranchAddress("trig_L1emNonIso_ieta_To", &trig_L1emNonIso_ieta_To);
myChain->SetBranchAddress("trig_L1emNonIso_iphi_To", &trig_L1emNonIso_iphi_To);
myChain->SetBranchAddress("trig_L1emNonIso_rank_To", &trig_L1emNonIso_rank_To);
myChain->SetBranchAddress("trig_L1emIso_N_M_To", &trig_L1emIso_N_M_To);
myChain->SetBranchAddress("trig_L1emIso_ieta_M_To", &trig_L1emIso_ieta_M_To);
myChain->SetBranchAddress("trig_L1emIso_iphi_M_To", &trig_L1emIso_iphi_M_To);
myChain->SetBranchAddress("trig_L1emIso_rank_M_To", &trig_L1emIso_rank_M_To);
myChain->SetBranchAddress("trig_L1emNonIso_N_M_To", &trig_L1emNonIso_N_M_To);
myChain->SetBranchAddress("trig_L1emNonIso_ieta_M_To", &trig_L1emNonIso_ieta_M_To);
myChain->SetBranchAddress("trig_L1emNonIso_iphi_M_To", &trig_L1emNonIso_iphi_M_To);
myChain->SetBranchAddress("trig_L1emNonIso_rank_M_To", &trig_L1emNonIso_rank_M_To);
int numEntries = myChain->GetEntries () ;
int nProcess = numEntries;
if(nEntries>=0 && nEntries<numEntries)
nProcess = nEntries;
TString filename;
bool evt_trig_EG12, evt_trig, evt_trig_M;
int spike_trig, spike_trig_M;
// Numbers //
const int nM=2;
const int nEG=8;
int thresh[nEG] = {2,5,8,10,12,15,20,30} ;
TString trigname[nEG] = {"2","5","8","10","12","15","20","30"};
TString collname[nM]={"N","M"};
// HISTOGRAMS //
TH1F * h_spikes;
TH1F * h_triggering_spikes[nEG][nM];
TH1F * h_evts_trigBy_any[nEG][nM];
TH1F * h_evts_trigBy_spikes[nEG][nM];
const int nVtx = 40;
TString name_histo;
h_spikes = new TH1F("h_spikes","h_spikes",nVtx,0,nVtx); // abscisse = vtx_N
for(int iEG=0 ; iEG<nEG ; iEG++ ) {
for(int iM=0 ; iM<nM ; iM++ ) {
name_histo = "h_triggering_spikes_EG"+trigname[iEG]+"_"+collname[iM];
h_triggering_spikes[iEG][iM]=new TH1F(name_histo,name_histo,nVtx,0,nVtx);
name_histo = "h_evts_trigBy_any_EG"+trigname[iEG]+"_"+collname[iM];
h_evts_trigBy_any[iEG][iM]=new TH1F(name_histo,name_histo,nVtx,0,nVtx);
name_histo = "h_evts_trigBy_spikes_EG"+trigname[iEG]+"_"+collname[iM];
h_evts_trigBy_spikes[iEG][iM]=new TH1F(name_histo,name_histo,nVtx,0,nVtx);
}
}
// Loop over entries //
int nCurrentRun = -999;
outlog << "will process " << nProcess << "/" << numEntries << "entries" << endl;
//
for (int iEvent = 0 ; iEvent < nProcess ; iEvent++ ) {
// TP Initialization
trig_tower_N = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta[iTow] = trig_tower_iphi[iTow] = -999;
trig_tower_adc[iTow] = trig_tower_sFGVB[iTow] = -999;
}
trig_tower_N_M = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_M[iTow] = trig_tower_iphi_M[iTow] = -999;
trig_tower_adc_M[iTow] = trig_tower_sFGVB_M[iTow] = -999;
}
trig_tower_N_E = 0;
for(int iTow=0 ; iTow<nTow ; iTow++) {
trig_tower_ieta_E[iTow] = trig_tower_iphi_E[iTow] = -999;
for(int i=0 ; i<5 ; i++)
trig_tower_adc_E[iTow][i] = trig_tower_sFGVB_E[iTow][i] = -999;
}
// L1 candidates
trig_L1emIso_N = 0;
trig_L1emNonIso_N = 0;
trig_L1emIso_N_M_To = 0;
trig_L1emNonIso_N_M_To = 0;
trig_L1emIso_N_To = 0;
trig_L1emNonIso_N_To = 0;
for(int il1=0 ; il1<4 ; il1++) {
trig_L1emIso_ieta[il1] = 0;
trig_L1emIso_iphi[il1] = 0;
trig_L1emIso_rank[il1] = 0;
trig_L1emNonIso_ieta[il1] = 0;
trig_L1emNonIso_iphi[il1] = 0;
trig_L1emNonIso_rank[il1] = 0;
trig_L1emIso_ieta_To[il1] = 0;
trig_L1emIso_iphi_To[il1] = 0;
trig_L1emIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_To[il1] = 0;
trig_L1emNonIso_iphi_To[il1] = 0;
trig_L1emNonIso_rank_To[il1] = 0;
trig_L1emNonIso_ieta_M_To[il1] = 0;
trig_L1emNonIso_iphi_M_To[il1] = 0;
trig_L1emNonIso_rank_M_To[il1] = 0;
trig_L1emIso_ieta_M_To[il1] = 0;
trig_L1emIso_iphi_M_To[il1] = 0;
trig_L1emIso_rank_M_To[il1] = 0;
}
myChain->GetEntry (iEvent) ;
// show processed file
if(iEvent==0) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << filename << endl << endl;
}
else if( filename != myChain->GetFile()->GetName() ) {
filename = myChain->GetFile()->GetName() ;
outlog << "File : " << myChain->GetFile()->GetName() << endl << endl;
}
// show current run/iCat processed
if(iEvent==0) {
nCurrentRun = nRun ;
outlog << "nRun=" << nRun << endl;
}
else if(nRun!=nCurrentRun) {
nCurrentRun=nRun ;
outlog << "nRun=" << nRun << endl;
}
// HLT selection //
if(usr_hlt=="unbias")
if(trig_HLT_path[0]==0) continue;
// CHECK EG12 FIRED //
evt_trig_EG12=false;
for(int i=0 ; i<4 ; i++) {
if(trig_L1emIso_rank[i] >= 12) evt_trig_EG12=true;
if(trig_L1emNonIso_rank[i] >= 12) evt_trig_EG12=true;
}
if(!evt_trig_EG12) continue;
// EXTRACT CONTAMINATION //
//
spike_trig=spike_trig_M=0;
// Loop over Spikes
for(int iS=0 ; iS<spike_N ; iS++) {
h_spikes->Fill(vtx_N);
if( spike_Et[iS] < spikeCut ) continue;
if( spike_maxEGtrig[iS] != spike_maxEGtrig_To[iS] )
if(debug) cout << "Spike #" << iS << " discripancy between OnlineFromData and OnlineFromEmul !" << endl;
if( spike_maxEGtrig[iS]>spike_trig ) spike_trig = spike_maxEGtrig[iS];
if( spike_maxEGtrig_M_To[iS]>spike_trig_M ) spike_trig_M = spike_maxEGtrig_M_To[iS];
for(int iEG=0 ; iEG<nEG ; iEG++) {
if( spike_maxEGtrig[iS]>thresh[iEG] ) h_triggering_spikes[iEG][0]->Fill(vtx_N);
if( spike_maxEGtrig_M_To[iS]>thresh[iEG] ) h_triggering_spikes[iEG][1]->Fill(vtx_N);
}
}
//
// Object triggering event
for(int iEG=0 ; iEG<nEG ; iEG++) {
// EG trig by any object
evt_trig=evt_trig_M=false;
for(int i=0 ; i<4 ; i++) {
if(trig_L1emIso_rank_To[i] >= thresh[iEG]) evt_trig=true;
if(trig_L1emNonIso_rank_To[i] >= thresh[iEG]) evt_trig=true;
//
if(trig_L1emIso_rank_M_To[i] >= thresh[iEG]) evt_trig_M=true;
if(trig_L1emNonIso_rank_M_To[i] >= thresh[iEG]) evt_trig_M=true;
}
if(evt_trig)
h_evts_trigBy_any[iEG][0]->Fill(vtx_N);
if(evt_trig_M)
h_evts_trigBy_any[iEG][1]->Fill(vtx_N);
// EG trig by spike
if(spike_trig>=thresh[iEG])
h_evts_trigBy_spikes[iEG][0]->Fill(vtx_N);
if(spike_trig_M>=thresh[iEG])
h_evts_trigBy_spikes[iEG][1]->Fill(vtx_N);
}
}
TFile *outplot = new TFile(dirOut+"/spike_plots.root","RECREATE");
h_spikes->Write();
for(int iEG=0 ; iEG<nEG ; iEG++) {
for(int iM=0; iM<nM ; iM++) {
h_triggering_spikes[iEG][iM]->Write();
h_evts_trigBy_any[iEG][iM]->Write();
h_evts_trigBy_spikes[iEG][iM]->Write();
}
}
outplot->Close();
cout << "DONE, BABY" << endl;
return 0;
}
void anaGeneralJF_mc(
Int_t jetType=2, // 1 for genjet, 2 for recjet
Int_t particleType=2 // 0 for genp, 2 for trk
)
{
cout << "start " << endl;
gSystem->Load("libMathCore");
gSystem->Load("libPhysics");
TString version("v12");
Int_t treeFormat=-1,doJEC=-1;
TString fdataname,tag,algo;
TChain * tevt = 0, * tjet = 0, * tp=0;
// Inputs/Output
// data
treeFormat = 1; // 0 for jra, 1 for pfana
algo = "j1";
// === HI ===
//TChain * chain = new TChain("PFJetAnalyzer/t","");
//Bool_t useTrkQual = true;
TChain * chain = new TChain("t","");
chain->Add("/net/hisrv0001/home/mnguyen/scratch/InclusiveJetAnalyzer/310X/Pyquen_UnquenchedDiJet_Pt80_GEN-SIM-RECO_393_setX/HICorrJetTuples_PFTowers_hiGoodTightTracks/pthat80_HIEmbedded_EscaleRepass_set1.root");
chain->Add("/net/hisrv0001/home/mnguyen/scratch/InclusiveJetAnalyzer/310X/Pyquen_UnquenchedDiJet_Pt80_GEN-SIM-RECO_393_setX/HICorrJetTuples_PFTowers_hiGoodTightTracks/pthat80_HIEmbedded_EscaleRepass_set2.root");
chain->Add("/net/hisrv0001/home/mnguyen/scratch/InclusiveJetAnalyzer/310X/Pyquen_UnquenchedDiJet_Pt80_GEN-SIM-RECO_393_setX/HICorrJetTuples_PFTowers_hiGoodTightTracks/pthat80_HIEmbedded_EscaleRepass_set3.root");
chain->Add("/net/hisrv0001/home/mnguyen/scratch/InclusiveJetAnalyzer/310X/Pyquen_UnquenchedDiJet_Pt80_GEN-SIM-RECO_393_setX/HICorrJetTuples_PFTowers_hiGoodTightTracks/pthat80_HIEmbedded_EscaleRepass_set4.root");
tag = Form("trana%s_hydjuq80pfhgtv1repass_%s_j%dt%d_et90",version.Data(),algo.Data(),jetType,particleType);
cout << chain->GetFile()->GetName() << endl;
tevt = chain;
tjet = chain;
tp = chain;
cout << fdataname << " output: " << tag << endl;
cout << "Input: " << chain->GetName() << endl;
cout << " Jet: " << algo << endl;
cout << "Output: " << tag << endl;
// output
TFile * outf = new TFile(Form("ntout/%s.root",tag.Data()),"RECREATE");
// ana
GeneralJetFragAna jfana(algo);
jfana.evtTree_ = tevt;
jfana.jetTree_ = tjet;
jfana.doMC_ = true;
jfana.useTrkQual_ = false;
jfana.pTree_ = tp;
jfana.leadJetPtMin_=90;
jfana.jetEtaMax_ = 2;
jfana.pptMin_=-1;
jfana.treeFormat_=treeFormat; // 0 for jra, 1 for pftree
jfana.Init(jetType,particleType);
jfana.Loop();
// All done
outf->Write();
outf->Close();
}
// const char* cDataType = "AOD", // set the analysis type, AOD or ESD
//##################################################
AliAnalysisManager* EmcalJetCDF (
const char* cRunPeriod = "LHC11d", // set the run period
const char* cLocalFiles = "data.txt", // set the local list file
const Int_t arg_sel_chg = 3145763, // "mykEMC_noGA", // physics selection
const Int_t arg_sel_full = 3145763, // "mykEMC_noGA", // physics selection
const Int_t mgr_mode = 0, // local = 0, proof = 1, grid = 2, mixing = 3
const Int_t alien_mode = 0, // test = 0, offline = 1, submit = 2, merge = 3, full = 4
const char* cTaskName = "CDFJets", // sets name of task manager
unsigned int iNumFiles = 100, // numger of files to process from list file
unsigned int iNumEvents = 999999999, // number of events to be analyzed
bool bDoChargedJets = true, // enable charge jets
bool bDoFullJets = false // enable full jets
) {
//Load needed libs
TString ListLibs = ""; // string list of loaded libs
TString ListLibsExtra = ""; // string list of loaded extra libs
LoadLibs( ListLibs, ListLibsExtra );
AnalysisType ManagerMode = static_cast<AnalysisType>(mgr_mode);
PluginType PluginMode = static_cast<PluginType>(alien_mode);
namespace CDF = PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetCDF_NS; // shortcut to task namespace
unsigned int kGridFilesPerJob = iNumFiles; // Maximum number of files per job (gives size of AOD)
unsigned int kTTL = 64800 ; // Time To Live; 18h = 64800; 12h = 43200
bool bDoBackgroundSubtraction = true;
bool bDoEmbedding = false;
// Embeded Configuration options
// Embedding files list
const TString embeddedFilesList = "aodFilesEmbed.txt";
// If true, events that are not selected in the PbPb will not be used for embedding.
// This ensures that good embedded events are not wasted on bad PbPb events.
const bool internalEventSelection = true;
// Do jet matching
const bool useJetTagger = true;
TString sGridMode ("test");
if ( PluginMode == PluginType::offline ) { sGridMode = "offline"; }
if ( PluginMode == PluginType::submit ) { sGridMode = "submit"; }
if ( PluginMode == PluginType::merge ) { sGridMode = "merge"; }
if ( PluginMode == PluginType::full ) { sGridMode = "full"; }
const char* cGridMode = sGridMode.Data();
TString sAnalysisType ("local");
if ( ManagerMode == AnalysisType::proof ) { sAnalysisType = "proof"; }
if ( ManagerMode == AnalysisType::grid ) { sAnalysisType = "grid"; }
if ( ManagerMode == AnalysisType::mixing ) { sAnalysisType = "mix"; }
const char* cAnalysisType = sAnalysisType.Data();
cout << std::endl << ">>>>>>>> ManagerMode : " << ManagerMode << " ; String value : " << cAnalysisType << std::endl << ">>>>>>>> PluginMode : " << PluginMode << " ; String value : " << cGridMode << std::endl << std::endl;
//---------------------------------------------------------------------------------------------
TRegexp false_regex ("[f,F][a,A][l,L][s,S][e,E]");
TRegexp true_regex ("[t,T][r,R][u,U][e,E]");
TRegexp enable_regex ("[e,E][n,N][a,A][b,B][l,L][e,E]");
TRegexp disable_regex ("[d,D][i,I][s,S][a,A][b,B][l,L][e,E]");
bool bDoSample = false;
TString ENV_doSAMPLE = gSystem->Getenv("CDF_doSAMPLE");
if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("0") || ENV_doSAMPLE.Contains(false_regex) ) ) { bDoSample = kFALSE; }
if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("1") || ENV_doSAMPLE.Contains(true_regex) ) ) { bDoSample = kTRUE; }
bool bDoCDF = true;
TString ENV_doCDF = gSystem->Getenv("CDF_doCDF");
if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("0") || ENV_doCDF.Contains(false_regex) ) ) { bDoCDF = kFALSE; }
if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("1") || ENV_doCDF.Contains(true_regex) ) ) { bDoCDF = kTRUE; }
// ###### DEBUG ######
Int_t debug = 0 ; // kFatal = 0, kError, kWarning, kInfo, kDebug, kMaxType
UInt_t mgr_debug = 0 ; // AliAnalysisManager debug level
UInt_t kUseSysInfo = 0 ; // activate debugging
TString ENV_DEBUG = gSystem->Getenv("CDF_DEBUG");
if (!ENV_DEBUG.IsNull() && ENV_DEBUG.IsDigit() ) { debug = ENV_DEBUG.Atoi(); }
TString ENV_DEBUG_MGR = gSystem->Getenv("CDF_DEBUG_MGR");
if (!ENV_DEBUG_MGR.IsNull() && ENV_DEBUG_MGR.IsDigit() ) { mgr_debug = ENV_DEBUG_MGR.Atoi(); }
TString ENV_NSYSINFO = gSystem->Getenv("CDF_NSYSINFO");
if (!ENV_NSYSINFO.IsNull() && ENV_NSYSINFO.IsDigit() ) { kUseSysInfo = ENV_NSYSINFO.Atoi(); }
if ( debug == 0 ) { AliLog::SetGlobalLogLevel ( AliLog::kFatal ); }
if ( debug == 1 ) { AliLog::SetGlobalLogLevel ( AliLog::kError ); }
if ( debug == 2 ) { AliLog::SetGlobalLogLevel ( AliLog::kWarning ); }
if ( debug == 3 ) { AliLog::SetGlobalLogLevel ( AliLog::kInfo ); }
if ( debug >= 4 ) { AliLog::SetGlobalLogLevel ( AliLog::kDebug ); }
// Progress bar
Bool_t bUseProgBar = kFALSE; // N.B. !! if true will set fDebug to 0
TString ENV_USEPROGBAR = gSystem->Getenv("PROGRESSBAR");
if (!ENV_USEPROGBAR.IsNull() && ( ENV_USEPROGBAR.EqualTo("1") || ENV_USEPROGBAR.Contains(true_regex) ) ) { bUseProgBar = kTRUE; }
//##################################################
// AliEN plugin variables
//##################################################
const char* curdir = gSystem->BaseName(gSystem->pwd());
TString kJobTag (curdir);
TString execArgs (" -l -b -q -x");
TString exec =
// "aliroot";
"root.exe";
TString kPluginExecutableCommand = exec + execArgs;
TString kAliPhysicsVersion = "vAN-20190304-1";
// == grid plugin files rules
TString kGridExtraFiles = ""; // extra files that will be added to the input list in the JDL
TString kGridMergeExclude = "AliAOD.root AliAOD.Jets.root"; // Files that should not be merged
TString kGridOutputStorages = "disk=2"; // Make replicas on the storages
// FILES USED IN MACRO
TString kCommonOutputFileName = "AnalysisResults.root";
//--------------------
// PROOF SETTINGS
//--------------------
TString kAAF = "";
Int_t kProofReset = 0; (void)kProofReset;
Int_t kWorkers = 20; (void)kWorkers;
Int_t kCores = 8 ; (void)kCores;
// AliRoot mode among the list supported by the proof cluster.
// TString kAlirootMode = "ALIROOT"; // STEERBase,ESD,AOD,ANALYSIS,ANALYSISalice (default aliroot mode)
//############################################################
// const AliAnalysisTaskEmcal::EDataType_t kAod = AliAnalysisTaskEmcal::kAOD;
// const AliAnalysisTaskEmcal::EDataType_t kEsd = AliAnalysisTaskEmcal::kESD;
const AliJetContainer::EJetType_t fulljet = AliJetContainer::kFullJet;
const AliJetContainer::EJetType_t chgjet = AliJetContainer::kChargedJet;
const AliJetContainer::EJetAlgo_t antikt = AliJetContainer::antikt_algorithm;
const AliJetContainer::EJetAlgo_t kt = AliJetContainer::kt_algorithm;
const AliJetContainer::ERecoScheme_t recomb = AliJetContainer::pt_scheme;
// kTPC, kTPCfid, kEMCAL, kEMCALfid, kDCAL, kDCALfid, kDCALonly, kDCALonlyfid, kPHOS, kPHOSfid, kUser
const AliEmcalJet::JetAcceptanceType acc_chgjets = AliEmcalJet::kTPCfid;
const AliEmcalJet::JetAcceptanceType acc_fulljets = AliEmcalJet::kEMCALfid;
//############################################################
// data source name
TString kDataSource (cLocalFiles);
// label of dataset from InputData.C
TString kGridDataSet ("");
if ( ManagerMode == AnalysisType::grid ) { kGridDataSet = kDataSource;}
//############################################################
// SETUP OF TRIGGERS
const AliEmcalPhysicsSelection::EOfflineEmcalTypes mykEMCAL = AliEmcalPhysicsSelection::kEmcalOk;
const AliVEvent::EOfflineTriggerTypes mykEMC = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA);
const AliVEvent::EOfflineTriggerTypes mykEMC_noGA = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE);
const AliVEvent::EOfflineTriggerTypes mykMB = AliVEvent::kAnyINT;
const AliVEvent::EOfflineTriggerTypes mykMB_central = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral);
const AliVEvent::EOfflineTriggerTypes mykMB_semicentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kSemiCentral);
const AliVEvent::EOfflineTriggerTypes mykMB_mostcentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral | AliVEvent::kSemiCentral);
AliVEvent::EOfflineTriggerTypes kPhysSel = mykMB; //AliVEvent::kAnyINT; // physics selection
// AliVEvent::EOfflineTriggerTypes kSel_tasks = mykMB;
AliVEvent::EOfflineTriggerTypes kSel_chg = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_chg);
AliVEvent::EOfflineTriggerTypes kSel_full = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_full);
//############################################################
// Analysis manager
AliAnalysisManager* pMgr = new AliAnalysisManager(cTaskName);
pMgr->SetDebugLevel(mgr_debug);
if ( kUseSysInfo > 0 ) { pMgr->SetNSysInfo ( kUseSysInfo ); }
// actual runName in the form of LHCXXX....
TString sRunName;
Bool_t kIsAOD = kTRUE;
AliAnalysisTaskEmcal::EDataType_t iDataType = AliAnalysisTaskEmcal::kAOD; // assuming default is to process AOD
TString file;
AliAnalysisAlien* plugin = NULL;
if ( ManagerMode == AnalysisType::grid ) { // start grid analysis
// ( const char* gridMode, const char* tag, unsigned int nr_test_files, unsigned int TTL, const char* outdir, const char subworkdir, const char* extradirlvl);
plugin = CreateAlienHandler(cGridMode, kJobTag.Data(), kGridFilesPerJob, kTTL);
if ( !plugin ) { ::Error ( "runEMCalJetSampleTask.C - StartGridAnalysis", "plugin invalid" ); return NULL; }
pMgr->SetGridHandler(plugin);
// use this command to run the macro
plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
// AliPhysics version.
plugin->SetAliPhysicsVersion ( kAliPhysicsVersion.Data() ); // Here you can set the (Ali)PHYSICS version you want to use
gROOT->LoadMacro("InputData.C");
InputData(kGridDataSet);
sRunName = CDF::GetPeriod( plugin->GetGridDataDir() );
file = CDF::GetFileFromPath(plugin->GetDataPattern());
if (file.Contains("AliESD")) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; }
plugin->SetMergeExcludes(kGridMergeExclude.Data());
}
if ( ManagerMode == AnalysisType::local ) { // start local analysis
if ( kDataSource.IsNull() ) { Printf("You need to provide the list of local files!"); return NULL; }
TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles);
if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; }
Printf("Setting local analysis for %d files from list %s, max events = %d", iNumFiles, kDataSource.Data(), iNumEvents);
// get the path of first file
file = pChain->GetFile()->GetEndpointUrl()->GetUrl();
sRunName = CDF::GetPeriod(file.Data()); // get the run name : first token beggining with lhc
if ( CDF::GetFileFromPath(file).Contains("AliESD") ) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; }
}
TString sDataType ("AOD");
if (!kIsAOD) { sDataType = "ESD"; }
std::cout << ">>> Analysis data type : " << sDataType.Data() << std::endl;
// name of de period (for MC is the name of "achored to" production)
TString sRunPeriod (cRunPeriod);
sRunPeriod.ToLower();
bool isMC = false;
isMC = CDF::PeriodIsMC(sRunName.Data());
// EMCAL corrections task configuration file
TString EMCALcfg ("CDF_CorrectionsConf.yaml");
if (isMC) {EMCALcfg = "CDF_MC_CorrectionsConf.yaml";}
if ( !kGridExtraFiles.IsNull() ) {kGridExtraFiles += " ";}
kGridExtraFiles += EMCALcfg;
AliAnalysisTaskEmcal::BeamType iBeamType = AliAnalysisTaskEmcal::kpp;
Bool_t bIsRun2 = kFALSE;
if (sRunPeriod.Length() == 6 && (sRunPeriod.BeginsWith("lhc15") || sRunPeriod.BeginsWith("lhc16") || sRunPeriod.BeginsWith("lhc17") || sRunPeriod.BeginsWith("lhc18") ) ) { bIsRun2 = kTRUE; }
if (sRunPeriod == "lhc10h" || sRunPeriod == "lhc11h" || sRunPeriod == "lhc15o" || sRunPeriod == "lhc17n" ) { iBeamType = AliAnalysisTaskEmcal::kAA; }
if (sRunPeriod == "lhc12g" || sRunPeriod == "lhc13b" || sRunPeriod == "lhc13c" || sRunPeriod == "lhc13d" || sRunPeriod == "lhc13e" ||
sRunPeriod == "lhc13f" || sRunPeriod == "lhc16q" || sRunPeriod == "lhc16r" || sRunPeriod == "lhc16s" || sRunPeriod == "lhc16t" ) { iBeamType = AliAnalysisTaskEmcal::kpA; }
Double_t kGhostArea = 0.01;
if (iBeamType != AliAnalysisTaskEmcal::kpp) { kGhostArea = 0.005; }
AliTrackContainer::SetDefTrackCutsPeriod(sRunPeriod);
Printf("Default track cut period set to: %s", AliTrackContainer::GetDefTrackCutsPeriod().Data());
Bool_t bDoEmcalCorrections = kFALSE;
if (bDoFullJets) { bDoEmcalCorrections = kTRUE; }
// ### Containers and string definitions
TString name_tracks = "usedefault";
TString name_clusters = "usedefault";
TString name_cells = "usedefault";
// Set centrality estimator for centrality task
TString cent_est_chg = "V0M" ;
TString cent_est_full = "V0M" ;
TString mc_container ("");
if (isMC) { mc_container = "mcparticles"; }
/*
// General input object names
TString tracksName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kTrack);
TString clustersName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCluster);
TString emcalCellsName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCaloCells);
// Combined (PbPb + embedded det level)
TString emcalCellsCombined = emcalCellsName + "Combined";
TString clustersCombined = clustersName + "Combined";
*/
//##########################
// TASKS DEFINITIONS ###
//##########################
AliAODInputHandler* pAODHandler = NULL;
AliESDInputHandler* pESDHandler = NULL;
if (kIsAOD)
{ pAODHandler = AliAnalysisTaskEmcal::AddAODHandler(); }
else
{ pESDHandler = AliAnalysisTaskEmcal::AddESDHandler(); }
// CDBconnect task
AliTaskCDBconnect* taskCDB = AliTaskCDBconnect::AddTaskCDBconnect();
taskCDB->SetFallBackToRaw(kTRUE); // Needed for the moment as not all grid sites do support cvmfs OCDB for the moment
if (!taskCDB) { std::cout << "--------->>>> taskCDB :: could not connect!!!! CHECK CVMFS" << std::endl; return NULL;}
// Physics selection task
AliPhysicsSelectionTask* pPhysSelTask = NULL;
if (!kIsAOD) {
// signature : (Bool_t mCAnalysisFlag = kFALSE, Bool_t applyPileupCuts = kFALSE, UInt_t deprecatedFlag2 = 0, Bool_t useSpecialOutput=kFALSE)
pPhysSelTask = AliPhysicsSelectionTask::AddTaskPhysicsSelection();
}
// Centrality task
// The Run 2 condition is too restrictive, but until the switch to MultSelection is complete, it is the best we can do
AliCentralitySelectionTask* pCentralityTask = NULL;
if ( !kIsAOD && (iBeamType != AliAnalysisTaskEmcal::kpp && bIsRun2) ) {
//signature : (Bool_t fillHistos=kTRUE, Bool_t aod=kFALSE)
pCentralityTask = AliCentralitySelectionTask::AddTaskCentrality(kFALSE, kIsAOD);
pCentralityTask->SelectCollisionCandidates(AliVEvent::kAny);
}
// AliMultSelection
AliMultSelectionTask* pMultSelTask = NULL;
if (bIsRun2) {
// signature : ( Bool_t lCalibration = kFALSE, TString lExtraOptions = "", Int_t lNDebugEstimators = 1, const TString lMasterJobSessionFlag = "")
pMultSelTask = AliMultSelectionTask::AddTaskMultSelection();
pMultSelTask->SelectCollisionCandidates(AliVEvent::kAny);
}
// Embedding task
if (bDoEmbedding) {
// Debug options
//AliLog::SetClassDebugLevel("AliAnalysisTaskEmcalEmbeddingHelper", AliLog::kDebug+0);
// Setup embedding task
AliAnalysisTaskEmcalEmbeddingHelper * embeddingHelper = AliAnalysisTaskEmcalEmbeddingHelper::AddTaskEmcalEmbeddingHelper();
embeddingHelper->SelectCollisionCandidates(kPhysSel);
// The pt hard bin should be set via the filenames in this file
// If using a file pattern, it could be configured via embeddingHelper->SetPtHardBin(ptHardBin);
embeddingHelper->SetFileListFilename(embeddedFilesList.Data());
// Some example settings for LHC12a15e_fix (anchored to LHC11h)
embeddingHelper->SetNPtHardBins(11);
embeddingHelper->SetMCRejectOutliers();
// Setup internal event selection and additional configuration options
embeddingHelper->SetConfigurationPath("EmbeddingConfigurationExample.yaml");
// Initialize the task to complete the setup.
embeddingHelper->Initialize();
}
// EMCal corrections
AliEmcalCorrectionTask* correctionTask = NULL;
if (bDoEmcalCorrections) {
// Configuration of the Correction Task is handled via a YAML file, which is setup below
// signature : (TString suffix)
correctionTask = AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask();
// correctionTask = AliEmcalCorrectionTask::ConfigureEmcalCorrectionTaskOnLEGOTrain(suffix);
correctionTask->SelectCollisionCandidates(kPhysSel);
correctionTask->SetUseNewCentralityEstimation(bIsRun2);
correctionTask->SetForceBeamType(static_cast<AliEmcalCorrectionTask::BeamType>(iBeamType));
// Configure and initialize
correctionTask->SetUserConfigurationFilename( EMCALcfg.Data() );
//correctionTask->SetUserConfigurationFilename("alien:///alice/cern.ch/user/m/mfasel/EMCALCorrectionConfig/ConfigDataPWGJEhighClusterThresholds.yaml");
correctionTask->Initialize(true);
}
// TObjArray correctionTasks;
//
// // Create the Correction Tasks
// // "data" corresponds to the PbPb level
// // "embed" corresponds to the embedded detector level
// // "combined" corresponds to the hybrid (PbPb + embedded detector) level
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("data"));
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("embed"));
// // It is important that combined is last!
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("combined"));
//
// // Loop over all of the correction tasks to configure them
// AliEmcalCorrectionTask * tempCorrectionTask = 0;
// TIter next(&correctionTasks);
// while (( tempCorrectionTask = static_cast<AliEmcalCorrectionTask *>(next()))) {
// tempCorrectionTask->SelectCollisionCandidates(kPhysSel);
// // Configure centrality
// tempCorrectionTask->SetNCentBins(5);
// tempCorrectionTask->SetUseNewCentralityEstimation(bIsRun2);
// tempCorrectionTask->SetUserConfigurationFilename("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/EMCalCorrectionTaskEmbeddingExample.yaml");
//
// tempCorrectionTask->Initialize(true);
// }
// Background
TString sRhoChName;
TString sRhoFuName;
AliAnalysisTaskRho* pRhoTask = NULL;
if ( bDoBackgroundSubtraction && iBeamType != AliAnalysisTaskEmcal::kpp ) {
sRhoChName = "Rho";
sRhoFuName = "Rho_Scaled";
AliEmcalJetTask* pKtChJetTask = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", kt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 0., kFALSE, kFALSE);
pKtChJetTask->SelectCollisionCandidates(kPhysSel);
//signature :
// const char* nTracks = "usedefault", const char* nClusters = "usedefault", const char* nRho = "Rho", Double_t jetradius = 0.2, UInt_t acceptance = AliEmcalJet::kTPCfid,
// AliJetContainer::EJetType_t jetType = AliJetContainer::kChargedJet, const Bool_t histo = kFALSE, AliJetContainer::ERecoScheme_t rscheme = AliJetContainer::pt_scheme, const char* suffix = ""
pRhoTask = AliAnalysisTaskRho::AddTaskRhoNew(name_tracks.Data(), name_clusters.Data(), sRhoChName, 0.4);
pRhoTask->SetExcludeLeadJets(2);
pRhoTask->SelectCollisionCandidates(kPhysSel);
pRhoTask->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
if (bDoFullJets) {
TString sFuncPath = "alien:///alice/cern.ch/user/s/saiola/LHC11h_ScaleFactorFunctions.root";
TString sFuncName = "LHC11h_HadCorr20_ClustersV2";
pRhoTask->LoadRhoFunction(sFuncPath, sFuncName);
}
}
// Find Charged jets
AliEmcalJetTask* pChJet02Task = NULL;
AliEmcalJetTask* pChJet04Task = NULL;
AliEmcalJetTask* pChJet02Task_MC = NULL;
AliEmcalJetTask* pChJet04Task_MC = NULL;
if (bDoChargedJets) {
pChJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet02Task->SelectCollisionCandidates(kSel_chg);
pChJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet04Task->SelectCollisionCandidates(kSel_chg);
if (isMC) {
pChJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet02Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pChJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks02Task_MC = pChJet02Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks02Task_MC->SetIsEmbedding(kTRUE);
}
pChJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet04Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pChJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks04Task_MC = pChJet04Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks04Task_MC->SetIsEmbedding(kTRUE);
}
} // isMC
} // bDoChargedJets
// Find Full jets
AliEmcalJetTask* pFuJet02Task = NULL;
AliEmcalJetTask* pFuJet04Task = NULL;
AliEmcalJetTask* pFuJet02Task_MC = NULL;
AliEmcalJetTask* pFuJet04Task_MC = NULL;
if (bDoFullJets) {
pFuJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet02Task->SelectCollisionCandidates(kSel_full);
pFuJet02Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
pFuJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet04Task->SelectCollisionCandidates(kSel_full);
pFuJet04Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (isMC) {
pFuJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet02Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pFuJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks02Task_MC = pFuJet02Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks02Task_MC->SetIsEmbedding(kTRUE);
}
pFuJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet04Task_MC->SelectCollisionCandidates(kSel_chg);
pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
if (bDoEmbedding) {
pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks04Task_MC = pFuJet04Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks04Task_MC->SetIsEmbedding(kTRUE);
}
} // isMC
} // bDoFullJets
////////////////////////
// ANALYSIS TASKS //
////////////////////////
// Sample task - charge jets
AliAnalysisTaskEmcalJetSample* sampleTaskchg = NULL;
if (bDoSample && bDoChargedJets) {
sampleTaskchg = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), "", "", "SMPCHG");
sampleTaskchg->SetHistoBins(600, 0, 300);
sampleTaskchg->SelectCollisionCandidates(kSel_chg);
sampleTaskchg->SetDebugLevel(debug);
AliParticleContainer* sampleTaskchg_partCont = sampleTaskchg->GetParticleContainer(0);
sampleTaskchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { sampleTaskchg_partCont->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
sampleTaskchg->SetUseNewCentralityEstimation(bIsRun2);
sampleTaskchg->SetNCentBins(5);
}
}
// Sample task - full jets
AliAnalysisTaskEmcalJetSample* sampleTaskfull = NULL;
if (bDoSample && bDoFullJets) {
sampleTaskfull = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), name_clusters.Data(), name_cells.Data(), "SMPFULL");
sampleTaskfull->SetHistoBins(600, 0, 300);
sampleTaskfull->SelectCollisionCandidates(kSel_full);
sampleTaskfull->SetDebugLevel(debug);
AliParticleContainer* sampleTaskfull_partCont = sampleTaskfull->GetParticleContainer(0);
sampleTaskfull_partCont->SetParticlePtCut(0.15);
AliClusterContainer* sampleTaskfull_clusCont = sampleTaskfull->GetClusterContainer(0);
sampleTaskfull_clusCont->SetClusECut(0.);
sampleTaskfull_clusCont->SetClusPtCut(0.);
sampleTaskfull_clusCont->SetClusNonLinCorrEnergyCut(0.);
sampleTaskfull_clusCont->SetClusHadCorrEnergyCut(0.30);
sampleTaskfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (bDoEmbedding) {
sampleTaskfull_partCont->SetIsEmbedding(kTRUE);
sampleTaskfull_clusCont->SetIsEmbedding(kTRUE);
}
if ( pMultSelTask ) {
sampleTaskfull->SetUseNewCentralityEstimation(bIsRun2);
sampleTaskfull->SetNCentBins(5);
}
}
//### CDF task - charged jets
AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg = NULL;
AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg_MC = NULL;
if (bDoCDF && bDoChargedJets) {
anaTaskCDFchg = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), "", "", "", "CDFchg" );
anaTaskCDFchg->SetHistoBins(600, 0, 300);
anaTaskCDFchg->SelectCollisionCandidates(kSel_chg);
anaTaskCDFchg->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFchg_partCont = anaTaskCDFchg->GetParticleContainer(0);
anaTaskCDFchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { anaTaskCDFchg_partCont->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
anaTaskCDFchg->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFchg->SetNCentBins(5);
anaTaskCDFchg->SetCentralityEstimator(cent_est_chg.Data());
}
//#################################################
if (isMC){
anaTaskCDFchg_MC = CDF::AddTaskEmcalJetCDF ( mc_container.Data(), "", "", "", "CDFchgMC" );
anaTaskCDFchg_MC->SetHistoBins(600, 0, 300);
anaTaskCDFchg_MC->SelectCollisionCandidates(kSel_chg);
anaTaskCDFchg_MC->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFchg_partCont_MC = anaTaskCDFchg_MC->GetMCParticleContainer(0);
anaTaskCDFchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { anaTaskCDFchg_partCont_MC->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
anaTaskCDFchg_MC->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFchg_MC->SetNCentBins(5);
anaTaskCDFchg_MC->SetCentralityEstimator(cent_est_chg.Data());
}
}
}
//### CDF task - full jets
AliAnalysisTaskEmcalJetCDF* anaTaskCDFfull = NULL;
if (bDoCDF && bDoFullJets) {
anaTaskCDFfull = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), name_clusters.Data(), name_cells.Data(), mc_container.Data(), "CDFfull" );
anaTaskCDFfull->SetHistoBins(600, 0, 300);
anaTaskCDFfull->SelectCollisionCandidates(kSel_full);
anaTaskCDFfull->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFfull_partCont = anaTaskCDFfull->GetParticleContainer(0);
anaTaskCDFfull_partCont->SetParticlePtCut(0.15);
AliClusterContainer* anaTaskCDFfull_clusCont = anaTaskCDFfull->GetClusterContainer(0);
anaTaskCDFfull_clusCont->SetClusECut(0.);
anaTaskCDFfull_clusCont->SetClusPtCut(0.);
anaTaskCDFfull_clusCont->SetClusNonLinCorrEnergyCut(0.);
anaTaskCDFfull_clusCont->SetClusHadCorrEnergyCut(0.30);
anaTaskCDFfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (bDoEmbedding) {
anaTaskCDFfull_partCont->SetIsEmbedding(kTRUE);
anaTaskCDFfull_clusCont->SetIsEmbedding(kTRUE);
}
if ( pMultSelTask ) {
anaTaskCDFfull->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFfull->SetNCentBins(5);
anaTaskCDFfull->SetCentralityEstimator(cent_est_full.Data());
}
}
//########################
// ANALYSIS TASKS - CONTAINERS SETUP
//########################
// AliEmcalJetTask* pChJet02Task_MC = NULL;
// AliEmcalJetTask* pChJet04Task_MC = NULL;
// add jet containers to CDF task for charged jets
if (bDoChargedJets && bDoCDF) {
AliJetContainer* jetcont_chg = NULL;
for ( Float_t fi = 0 ; fi<=100 ; fi+=10) {
// CHG JETS 0.2
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
// CHG JETS 0.4
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
if (isMC) {
// CHG JETS MC 0.2
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
// CHG JETS MC 0.4
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
}
}
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
if (isMC) {
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
}
jetcont_chg = NULL;
}
// add jet containers to CDF task for full jets
if (bDoFullJets && bDoCDF) {
AliJetContainer* jetcont_full = NULL;
for ( Float_t fi = 0 ; fi<=100 ; fi+=10) {
// FULL JETS 0.2
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2);
// FULL JETS 0.4
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2);
if (isMC) {
// CHG JETS MC 0.2
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0);
// CHG JETS MC 0.4
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0);
}
}
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2);
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2);
if (isMC) {
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0);
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0);
}
jetcont_full = NULL;
}
// add jet containers to sample task for charged jets
if (bDoChargedJets && bDoSample) {
AliJetContainer* jetCont02chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
AliJetContainer* jetCont04chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
if (iBeamType != AliAnalysisTaskEmcal::kpp) {
jetCont02chg_sample->SetRhoName(sRhoChName);
jetCont02chg_sample->SetPercAreaCut(0.6);
jetCont04chg_sample->SetRhoName(sRhoChName);
jetCont04chg_sample->SetPercAreaCut(0.6);
}
}
// add jet containers to sample task for full jets
if (bDoFullJets && bDoSample) {
AliJetContainer* jetCont02full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
AliJetContainer* jetCont04full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
if (iBeamType != AliAnalysisTaskEmcal::kpp) {
jetCont02full_sample->SetRhoName(sRhoFuName);
jetCont02full_sample->SetPercAreaCut(0.6);
jetCont04full_sample->SetRhoName(sRhoFuName);
jetCont04full_sample->SetPercAreaCut(0.6);
}
}
TObjArray* tasks_list = pMgr->GetTasks(); TIter task_iter (tasks_list); AliAnalysisTaskSE* task = NULL;
while (( task = dynamic_cast<AliAnalysisTaskSE*>(task_iter.Next()) )) {
if (task->InheritsFrom("AliAnalysisTaskEmcal")) {
Printf("Setting beam type %d for task %s", iBeamType, static_cast<AliAnalysisTaskEmcal*>(task)->GetName());
static_cast<AliAnalysisTaskEmcal*>(task)->SetForceBeamType(iBeamType);
}
}
// Let's start #########################################################################################################
if ( !pMgr->InitAnalysis() ) { std::cout << ">>>>>>>>>>>>>> AliAnalysisManager Initialising FAILED!!! " << std::endl; return NULL; }
std::cout << "##-->> Initialising Analysis :: Status :" << std::endl;
pMgr->PrintStatus();
pMgr->SetUseProgressBar(bUseProgBar, 100);
// task profiling
if ( kUseSysInfo > 0 ) {
for ( int i = 0; i < pMgr->GetTopTasks()->GetEntries(); i++ ) { pMgr->ProfileTask (i); }
}
CDF::SaveManager("train.root");
if ( ManagerMode == AnalysisType::local ) { // start local analysis
// enable class level debugging for these classes
if ( debug > 2 ) {
// pMgr->AddClassDebug("AliJetContainer", 100);
// pMgr->AddClassDebug("AliEmcalJetTask", 100);
if (bDoCDF) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetCDF", 100); }
if (bDoSample) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetSample", 100); }
}
TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles);
if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; }
// start analysis
Printf("Starting LOCAL Analysis...");
pMgr->StartAnalysis( cAnalysisType, pChain, iNumEvents );
}
if ( ManagerMode == AnalysisType::grid ) { // start grid analysis
// start analysis
Printf("Starting GRID Analysis...");
ListLibs += kGridExtraFiles;
if ( ListLibs.Length() ) { plugin->SetAdditionalLibs ( ListLibs.Data() ); }
if ( ListLibsExtra.Length() ) { plugin->SetAdditionalRootLibs ( ListLibsExtra.Data() ); }
if ( PluginMode == PluginType::test )
{ plugin->StartAnalysis(iNumEvents); }
else {
pMgr->SetDebugLevel(0);
plugin->StartAnalysis();
}
}
cout << "END of EmcalJetCDF.C" << std::endl;
return pMgr;
}
void mergeForest(TString fname = "/data/jisun/temp/*.root",
TString outfile="/data/jisun/pp_2015_HeavyFlavor_AOD_tkpt1_D0pt1_eta2p5_D3d1_Prob0p05_1202.root",
bool failOnError = true)
{
// First, find on of the files within 'fname' and use it to make a
// list of trees. Unfortunately we have to know in advance at least
// one of the tree names. hiEvtAnalyzer/HiTree is a safe choice for
// HiForests. We also assume that every TTree is inside a
// TDirectoryFile which is in the top level of the root file.
TChain *dummyChain = new TChain("hltanalysis/HltTree");
dummyChain->Add(fname);
TFile *testFile = dummyChain->GetFile();
TList *topKeyList = testFile->GetListOfKeys();
std::vector<TString> trees;
std::vector<TString> dir;
for(int i = 0; i < topKeyList->GetEntries(); ++i)
{
TDirectoryFile *dFile = (TDirectoryFile*)testFile->Get(topKeyList->At(i)->GetName());
if(strcmp(dFile->ClassName(), "TDirectoryFile") != 0) continue;
TList *bottomKeyList = dFile->GetListOfKeys();
for(int j = 0; j < bottomKeyList->GetEntries(); ++j)
{
TString treeName = dFile->GetName();
treeName += "/";
treeName += bottomKeyList->At(j)->GetName();
TTree* tree = (TTree*)testFile->Get(treeName);
if(strcmp(tree->ClassName(), "TTree") != 0 && strcmp(tree->ClassName(), "TNtuple") != 0) continue;
trees.push_back(treeName);
dir.push_back(dFile->GetName());
}
}
testFile->Close();
delete dummyChain;
// Now use the list of tree names to make a new root file, filling
// it with the trees from 'fname'.
const int Ntrees = trees.size();
TChain* ch[Ntrees];
Long64_t nentries = 0;
for(int i = 0; i < Ntrees; ++i){
ch[i] = new TChain(trees[i]);
ch[i]->Add(fname);
std::cout << "Tree loaded : " << trees[i] << std::endl;
std::cout << "Entries : " << ch[i]->GetEntries() << std::endl;
// If the number of entries in this tree is different from other
// trees there is a problem. Quit and inform the user without
// producing output.
if(failOnError)
{
if(strcmp(trees[i],"HiForest/HiForestVersion") == 0) continue;
if(i == 0) nentries = ch[i]->GetEntries();
else if (nentries != ch[i]->GetEntries())
{
std::cout << "ERROR: number of entries in this tree does not match." << std::endl;
std::cout << "First inconsistent file: " <<ch[i]->GetFile()->GetName()<<std::endl;
std::cout << "Exiting. Please check input." << std::endl;
return;
}
}
else
{
std::cout << "WARN: error checking disabled" << std::endl;
}
}
TFile* file = new TFile(outfile, "RECREATE");
for(int i = 0; i < Ntrees; ++i)
{
file->cd();
std::cout << trees[i] << std::endl;
if (i==0)
{
file->mkdir(dir[i])->cd();
}
else
{
if ( dir[i] != dir[i-1] )
file->mkdir(dir[i])->cd();
else
file->cd(dir[i]);
}
ch[i]->Merge(file,0,"keep");
delete ch[i];
}
//file->Write();
file->Close();
std::cout << "Done. Output: " << outfile << std::endl;
}