void UEAnalysisMPI::mpiAnalysisMC(Float_t weight,Float_t etaRegion,Float_t ptThreshold, TClonesArray& ChargedJet)
{
std::vector<TLorentzVector*> JetMC;
JetMC.clear();
for(int j=0;j<ChargedJet.GetSize();++j){
TLorentzVector *v = (TLorentzVector*)ChargedJet.At(j);
if(fabs(v->Eta())<etaRegion){
JetMC.push_back(v);
}
}
std::vector<AssociatedObject> assoJetMC;
assoJetMC.clear();
while(JetMC.size()>1){
int oldSize = JetMC.size();
std::vector<TLorentzVector*>::iterator itH = JetMC.begin();
if((*itH)->Pt()>=ptThreshold){
for(std::vector<TLorentzVector*>::iterator it=JetMC.begin();it!=JetMC.end();it++){
float azimuthDistanceJet = fabs( (*itH)->Phi() - (*it)->Phi() );
if((*it)->Pt()/(*itH)->Pt()>=0.3){
if( (piG - rangePhi) < azimuthDistanceJet && azimuthDistanceJet < (piG + rangePhi)) {
AssociatedObject tmpPair((*itH),(*it));
assoJetMC.push_back(tmpPair);
JetMC.erase(it);
int newSize = oldSize -1;
oldSize = newSize;
JetMC.resize(newSize);
break;
}
}
}
}
JetMC.erase(itH);
int newSize = oldSize -1;
JetMC.resize(newSize);
}
if(assoJetMC.size()){
fNumbMPIMC->Fill(assoJetMC.size());
std::vector<AssociatedObject>::iterator at= assoJetMC.begin();
const TLorentzVector* leadingJet((*at).first);
const TLorentzVector* secondJet((*at).second);
pPtRatio_vs_PtJleadMC->Fill(leadingJet->Pt(),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_EtaJleadMC->Fill(fabs(leadingJet->Eta()),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_PhiJleadMC->Fill(leadingJet->Phi(),(secondJet->Pt()/leadingJet->Pt()));
fdEtaLeadingPairMC->Fill(leadingJet->Eta()-secondJet->Eta());
float dPhiJet = fabs(leadingJet->Phi()-secondJet->Phi());
if(dPhiJet> piG) dPhiJet = 2*piG -dPhiJet;
dPhiJet = (180*dPhiJet)/piG;
fdPhiLeadingPairMC->Fill(dPhiJet);
fptRatioLeadingPairMC->Fill(secondJet->Pt()/leadingJet->Pt());
}
}
int saModuleDimuonDYDarshana::GetNumberofTracklets(DSTReader *fvtx_trk_map, const DiMuon *dimuon)
{
if(!fvtx_trk_map){
cout<<"EXCEPTION: "<<PHWHERE<<endl;
return NULL;
}
int ntrklets = 0;
TClonesArray *array = fvtx_trk_map->get_FvtxCompactTrk();
for (int i = 0; i < array->GetSize(); i++) {
TFvtxCompactTrk *tracklet = dynamic_cast<TFvtxCompactTrk*> (array->At(i));
if(!tracklet){
//cout<<"No tracklet"<<__LINE__<<"size: "<<array->GetSize()<<endl;
break;
}
if(_use_cut_tracklet_chi2 && (tracklet->get_chi2_ndf() > _cut_tracklet_chi2)) continue;
if(!_use_2_hit_tracklet && tracklet->get_nhits() <= 2) continue;
SingleMuon *muon0 = singlemuoncontainer->get_SingleMuon(0);
SingleMuon *muon1 = singlemuoncontainer->get_SingleMuon(1);
float xx0 = tracklet->get_fvtx_vtx().getX()-(tracklet->get_fvtx_vtx().getZ()- dimuons->get_Evt_fvtxZ())*
tan(tracklet->get_fvtx_theta())*cos(tracklet->get_fvtx_phi());
float yy0 = tracklet->get_fvtx_vtx().getY()-(tracklet->get_fvtx_vtx().getZ()- dimuons->get_Evt_fvtxZ())*
tan(tracklet->get_fvtx_theta())*sin(tracklet->get_fvtx_phi());
float x0y0=sqrt((xx0 - dimuons->get_Evt_fvtxX())*(xx0 - dimuons->get_Evt_fvtxX()) +
(yy0 - dimuons->get_Evt_fvtxY())*(yy0 - dimuons->get_Evt_fvtxY()));
if (fabs(TMath::ATan2(sqrt(muon0->get_px_fvtxmutr()*muon0->get_px_fvtxmutr()+
muon0->get_py_fvtxmutr()*muon0->get_py_fvtxmutr()),muon0->get_pz_fvtxmutr())-
tracklet->get_fvtx_theta()) >0.001 && fabs(TMath::ATan2(sqrt(muon1->get_px_fvtxmutr()*
muon1->get_px_fvtxmutr()+muon1->get_py_fvtxmutr()*muon1->get_py_fvtxmutr()),
muon1->get_pz_fvtxmutr())-tracklet->get_fvtx_theta()) >0.001 && fabs(TMath::ATan2(muon0->get_py_fvtxmutr(),
muon0->get_px_fvtxmutr())-tracklet->get_fvtx_phi())>0.001 && fabs(TMath::ATan2(muon1->get_py_fvtxmutr(),
muon1->get_px_fvtxmutr())-tracklet->get_fvtx_phi())>0.001 && tracklet->get_fvtx_theta()+0!=0 &&
x0y0 < 1.5){
ntrklets++;
}
}
return ntrklets;
}
int main(int argc, char* argv[])
{
//Upload the file with the data
TFile* file = TFile::Open("/Users/Fer/Documents/traajo/samples/NeroNtuples_9.root"); // TFile::Open() instead of a constructor since it works over xrootd etc.
//Upload the tree with the event data
TTree *tree=(TTree*)file->Get("nero/events");
//Create the vector to store all the particle identifiers
std::vector<Int_t> * lepPdgId;
//Create a variable to store all the lepton event data
TClonesArray *leptondata = new TClonesArray("leptondata");
//Specify where all the lepton event data will be stores
tree->SetBranchAddress("lepP4", &leptondata);
//Specify where all the lepton identifiers will be stored
tree->SetBranchAddress("lepPdgId", &lepPdgId);
//Get how many events we have to loop through
int nentries = tree->GetEntries();
//Loop through all the events
for(int ientry = 0; ientry < nentries; ientry++)
{
//Reset the lepton data
leptondata->Clear();
//This line stores the proper data both in "leptondata" and in "lepPdgId"
tree->GetEntry(ientry);
//Only if "leptondata" is not empty continue, this is to avoid segmentation errors
if(leptondata->GetSize() == 0) continue;
//Loop through all the entries in the current event
for(int j=0; j<leptondata->GetEntriesFast()-1; j++)
{
//Only if the identifier of the particle is + or - 11 (electron or antielectron) store the data in electrondata
if(abs(lepPdgId->at(j))==11) continue;
//Store all the data of the electron in this variable
TLorentzVector *electrondata = (TLorentzVector *)leptondata->At(j);
//Get some specific property such as momentum, position or energy
cout << electrondata->E() << endl;
}
}
return 0;
}
int main(int argc, char* argv[])
{
//Essentials
//Upload the file with the data, make sure the adress of the file matches the one in your computer
TFile* file = TFile::Open("/Users/Fer/Documents/traajo/samples/NeroNtuples_9.root"); // TFile::Open() instead of a constructor since it works over xrootd etc. =D
//Upload the tree with the event data
TTree *tree=(TTree*)file->Get("nero/events");
/////////////////////////////////////////////////////
//Lepton criteria
//Create a variable to store all the lepton event data
TClonesArray *leptondata = new TClonesArray("leptondata");
//Create the vector to store all the particle identifiers
std::vector<Int_t> * lepPdgId= 0;
//Specify where all the lepton event data will be stored
tree->SetBranchAddress("lepP4", &leptondata);
//Specify where all the lepton identifiers will be stored
tree->SetBranchAddress("lepPdgId", &lepPdgId);
//Histogram to plot the distribution of lepton mass
TH1F *lepmass = new TH1F("lepmass", "Lepton mass", 50, 0, 150);
/////////////////////////////////////////////////////
//MET criteria
//Create a variable to store all the "met" data
TClonesArray *metdata = new TClonesArray("metdata");
//Specify where all the "met" data will be stored
tree->SetBranchAddress("metP4", &metdata);
//Histogram to plot the distribution of the transverse mass
TH1F *metmass = new TH1F("metmass", "Missing transverse mass", 50, 0, 150);
/////////////////////////////////////////////////////
//Eta criteria
//Create the variable for Eta
Double_t eta;
/////////////////////////////////////////////////////
//Jet criteria
//Create a variable to store all the jet event data
TClonesArray *jetdata = new TClonesArray("jetdata");
//Specify where all the jet event data will be stored
tree->SetBranchAddress("jetP4", &jetdata);
//Histogram to plot the distribution of jet mass
TH1F *jetmass = new TH1F("jetmass", "Jet mass", 50, 0, 150);
//Variable to store the amount of jets
Double_t size;
/////////////////////////////////////////////////////
//Histogram to plot the distribution of the whole mass
TH1F *wholemass = new TH1F("wholemass", "Whole mass", 50, 0, 150);
/////////////////////////////////////////////////////
//Histogram variables
//Create the canvas were the histograms will be ploted
TCanvas* c1 = new TCanvas("c1", "Masses", 600, 600);
//Divide that canvas to plot all histograms together
c1->Divide(2,2);
/////////////////////////////////////////////////////
//Variables for the for loop
//Get how many events we have to loop through
int nentries = tree->GetEntries();
//Create a variable to store the mass values
Double_t mass;
//Loop through all the events
for(int ientry = 0; ientry < nentries; ientry++)
{
//Variable of the whole data
TLorentzVector addable_lorentz_wholedata;
//Reset the lepton data
leptondata->Clear();
//Reset the met data
metdata->Clear();
//Reset the jet data
jetdata->Clear();
//This line stores the proper data in the variables qe specified
tree->GetEntry(ientry);
/////////////////////////////////////////////////////
//Implementation of lepton criteria
//If "leptondata" is empty it skips and the for loop continues, this is to avoid segmentation errors
if(leptondata->GetSize() != 1) continue;
//Only if the identifier of the particle is ±11 or ± 13 (electrons muons or their anti particles) we use the data
if((abs(lepPdgId->at(0))!=11)&&(abs(lepPdgId->at(0))!=13)) continue;
//Store all the data of the electron in this lorentz vector
TLorentzVector * lorentz_leptondata = (TLorentzVector *)leptondata->At(0);
//We create another lorentz vector that isn't a pointer for the same reasons that before
TLorentzVector addable_lorentz_leptondata = *lorentz_leptondata;
//Get the Eta value of that Lorentz vector
eta=addable_lorentz_leptondata.Eta();
//Get the transverse mass of that lorentz vector
mass=addable_lorentz_leptondata.Mt();
//Implementing slection criteria
if (mass<40 || abs(eta)>2.5) continue;
//Fill the histogram with the current data
lepmass->Fill(mass);
/////////////////////////////////////////////////////
//Implementation of met criteria
//Create a lorentz vector with the matdata of the current entry
TLorentzVector * lorentz_metdata = (TLorentzVector *) metdata->At(0);
//We cannot use math with pointers for some reason, so we create a lorentz vectors that isn't a pointers
TLorentzVector addable_lorentz_metdata = *lorentz_metdata;
//Get the invariant transverse mass of that lorentz vector
mass=addable_lorentz_metdata.Mt();
//Implementing slection criteria
if (mass<60) continue;
metmass->Fill(mass);
/////////////////////////////////////////////////////
//Implementation of jet criteria
//If "jetdata" is empty it skips and the for loop continues, this is to avoid segmentation errors
if(jetdata->GetSize() == 0) continue;
size=jetdata->GetSize();
if (size != 3) continue;
for (int i = 0; i < jetdata->GetSize()-1; ++i)
{
//Store all the data of the electron in this lorentz vector
TLorentzVector * lorentz_jetdata = (TLorentzVector *)jetdata->At(i);
//We create another lorentz vector that isn't a pointer for the same reasons that before
TLorentzVector addable_lorentz_jetdata = *lorentz_jetdata;
//Get the Eta value of that Lorentz vector
eta=addable_lorentz_jetdata.Eta();
//Get the transverse mass of that lorentz vector
mass=addable_lorentz_jetdata.Mt();
//Implementing slection criteria
if (mass<30 || abs(eta)>2.4) continue;
//Fill the histogram with the current data
jetmass->Fill(mass);
//We add the mass of each jet
addable_lorentz_wholedata= addable_lorentz_jetdata+addable_lorentz_wholedata;
}
//Finally we add the MET mass and the lepton mass
addable_lorentz_wholedata=addable_lorentz_metdata+addable_lorentz_leptondata;
//Get the transverse mass of that lorentz vector
mass=addable_lorentz_wholedata.Mt();
//Fill the histogram with the current data
wholemass->Fill(mass);
}
//Activate the first section of the canvas
c1->cd(1);
//Make the histogram
metmass->Draw("H");
//Put it in the canvas
c1->Update();
//Repeat
c1->cd(2);
lepmass->Draw("H");
c1->Update();
c1->cd(3);
jetmass->Draw("H");
c1->Update();
c1->cd(4);
wholemass->Draw("H");
c1->Update();
//Save the image
c1->SaveAs("chargedHiggs_masses.pdf");
c1->Close();
// cleanup
delete file; // automatically deletes "tree" too
delete lepPdgId;
delete leptondata;
delete metdata;
delete jetdata;
return 0;
}
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;
}
void fill(const JMETree& jme) {
eventinfo.runNum = jme.run;
eventinfo.evtNum = jme.evt;
eventinfo.lumiSec = jme.lumi;
eventinfo.nPU = jme.npus->size() ? (*jme.npus)[0] : 0;
eventinfo.nPUmean = jme.tnpus->size() ? (*jme.tnpus)[0] : 0;
eventinfo.rhoIso = 0;
eventinfo.rhoJet = jme.rho;
eventinfo.triggerBits = 0;
for(auto i = jme.paths->cbegin() ; i != jme.paths->cend() ; ++i) {
//cout << "testing " << *i << endl;
for(auto i2 = triggernames->cbegin(); i2 != triggernames->cend() ; ++i2) {
if(*i2 > *i) break;
//cout << "trying " << *i2 << endl;
if(i->compare(0,min(i->size(),i2->size()),*i2) == 0) {
//std::cout << "setting" << *i << ", " << *i2 << " " << i2-triggernames->cbegin() << endl;
eventinfo.triggerBits[i2-triggernames->cbegin()] = true;
}
}
//std::cout << *i << endl;
}
//eventinfo.triggerBits = jme.prescales->size();
eventinfo.pfMET = (*jme.met_p4)[0].Pt();// not stored atm, to be done later
eventinfo.pfMETphi = (*jme.met_p4)[0].Phi();
geneventinfo.id_1 = jme.pdf_id->first;
geneventinfo.id_2 = jme.pdf_id->second;
geneventinfo.x_1 = jme.pdf_x->first;
geneventinfo.x_2 = jme.pdf_x->second;
geneventinfo.weight = jme.weight;
//geneventinfo.pthat = jme.pthat; // is missing in the header - but anyway not needed (at the moment)
vertices->Clear();
jets->Clear();
addjets->Clear();
for(unsigned int j = 0 ; j < jme.position->size() ; ++j) {
assert(vertices->GetEntries() < vertices->GetSize());
const int index = vertices->GetEntries();
new((*vertices)[index]) baconhep::TVertex();
baconhep::TVertex *pVertex = (baconhep::TVertex*)(*vertices)[index];
//pVertex->nTracksFit =
pVertex->ndof = (*jme.ndof)[j];
pVertex->chi2 = (*jme.normalizedChi2)[j];
pVertex->x = (*jme.position)[j].X();
pVertex->y = (*jme.position)[j].Y();
pVertex->z = (*jme.position)[j].Z();
}
for(unsigned int j = 0 ; j < jme.p4->size() ; ++j) {
assert(jets->GetEntries() < jets->GetSize());
const int index = jets->GetEntries();
new((*jets)[index]) baconhep::TJet();
baconhep::TJet *pJet = (baconhep::TJet*)(*jets)[index];
pJet->pt = (*jme.p4)[j].pt();
pJet->eta = (*jme.p4)[j].eta();
pJet->phi = (*jme.p4)[j].phi();
pJet->mass = (*jme.p4)[j].mass();
pJet->ptRaw = (*jme.p4)[j].pt() * (*jme.jec_toraw)[j];
//pJet->csv = (*jme.pfCombinedSecondaryVertexV2BJetTags)[j]; // only stored in AK4PFCHS, to be done later
pJet->area = (*jme.jtarea)[j];
pJet->genpt = (*jme.gen_p4)[j].pt();
pJet->geneta = (*jme.gen_p4)[j].eta();
pJet->genphi = (*jme.gen_p4)[j].phi();
pJet->genm = (*jme.gen_p4)[j].mass();
pJet->betaStar = (*jme.betaStar)[j];
//std::cout << pJet->pt << std::endl;
}
tree->Fill();
}
///
///________________________________________________________________________________
///
Bool_t
UEJetAreaFinder::find( TClonesArray& Input, vector<UEJetWithArea>& _jets )
{
/// return if no four-vectors are provided
if ( Input.GetSize() == 0 ) return kFALSE;
/// prepare input
std::vector<fastjet::PseudoJet> fjInputs;
fjInputs.reserve ( Input.GetSize() );
int iJet( 0 );
for( int i(0); i < Input.GetSize(); ++i )
{
TLorentzVector *v = (TLorentzVector*)Input.At(i);
if ( TMath::Abs(v->Eta()) > etaRegionInput ) continue;
if ( v->Pt() < ptThreshold ) continue;
fjInputs.push_back (fastjet::PseudoJet (v->Px(), v->Py(), v->Pz(), v->E()) );
fjInputs.back().set_user_index(iJet);
++iJet;
}
/// return if no four-vectors in visible phase space
if ( fjInputs.size() == 0 ) return kFALSE;
/// print out info on current jet algorithm
// cout << endl;
// cout << mJetDefinition->description() << endl;
// cout << theAreaDefinition->description() << endl;
/// return if active area is not chosen to be calculated
if ( ! theAreaDefinition ) return kFALSE;
// cout << "fastjet::ClusterSequenceActiveArea* clusterSequence" << endl;
fastjet::ClusterSequenceArea* clusterSequence
= new fastjet::ClusterSequenceArea (fjInputs, *mJetDefinition, *theAreaDefinition );
// cout << "retrieve jets for selected mode" << endl;
/// retrieve jets for selected mode
double mJetPtMin( 1. );
std::vector<fastjet::PseudoJet> jets( clusterSequence->inclusive_jets (mJetPtMin) );
unsigned int nJets( jets.size() );
if ( nJets == 0 )
{
delete clusterSequence;
return kFALSE;
}
//Double_t ptByArea[ nJets ];
// int columnwidth( 10 );
//cout << "found " << jets.size() << " jets" << endl;
// cout.width( 5 );
// cout << "jet";
// cout.width( columnwidth );
// cout << "eta";
// cout.width( columnwidth );
// cout << "phi";
// cout.width( columnwidth );
// cout << "pT";
// cout.width( columnwidth );
// cout << "jetArea";
// cout.width( 15 );
// cout << "pT / jetArea";
// cout << endl;
_jets.reserve( nJets );
vector< fastjet::PseudoJet > sorted_jets ( sorted_by_pt( jets ));
for ( int i(0); i<nJets; ++i )
{
//ptByArea[i] = jets[i].perp()/clusterSequence->area(jets[i]);
// cout.width( 5 );
// cout << i;
// cout.width( columnwidth );
// cout << jets[i].eta();
// cout.width( columnwidth );
// cout << jets[i].phi();
// cout.width( columnwidth );
// cout << jets[i].perp();
// cout.width( columnwidth );
// cout << clusterSequence->area(jets[i]);
// cout.width( 15 );
// cout << ptByArea[i];
// cout << endl;
/// save
///
/// TLorentzVector
/// area
/// nconstituents
fastjet::PseudoJet jet( sorted_jets[i] );
vector< fastjet::PseudoJet > constituents( clusterSequence->constituents(jet) );
TLorentzVector* mom = new TLorentzVector( jet.px(), jet.py(), jet.pz(), jet.e() );
double area = clusterSequence->area(jet);
// double median = TMath::Median( nJets, ptByArea );
unsigned int nconst = constituents.size();
UEJetWithArea* theJet = new UEJetWithArea( *mom, area, nconst);
//_jets[i] = *theJet;
_jets.push_back( *theJet );
delete mom;
delete theJet;
}
delete clusterSequence;
return kTRUE;
}
void
UEJetAreaHistograms::fill( vector<UEJetWithArea>& theJets, TClonesArray& acceptedTriggers )
{
// cout << "UEJetAreaHistograms::fill( vector<UEJetWithArea>& theJets, TClonesArray& acceptedTriggers )" << endl;
///
/// Histo filler for reco-only analysis
/// HL trigger bits *are* available
///
///
/// 11 HLT bits :
/// 4 Min-Bias (Pixel, Hcal, Ecal, general), Zero-Bias, 6 Jet (30, 50, 80, 110, 180, 250)
///
unsigned int iHLTbit(0);
for ( ; iHLTbit<11; ++iHLTbit )
{
///
/// ask if trigger was accepted
///
bool hltAccept( false );
unsigned int nAcceptedTriggers( acceptedTriggers.GetSize() );
for ( unsigned int itrig(0); itrig<nAcceptedTriggers; ++itrig )
{
std::string filterName( acceptedTriggers.At(itrig)->GetName() );
if ( filterName == HLTBitNames[iHLTbit] ) hltAccept = true;
}
if ( ! hltAccept ) continue;
Double_t ptarray [ theJets.size() ];
Double_t areaarray[ theJets.size() ];
Double_t ptByArea [ theJets.size() ];
for ( unsigned int ijet(0); ijet < theJets.size(); ++ijet )
{
double pTLeadingJet ( theJets[0].GetMomentum()->Pt() );
double pTJet ( theJets[ijet].GetMomentum()->Pt() );
double etaJet ( theJets[ijet].GetMomentum()->Eta() );
double areaJet( theJets[ijet].GetArea() );
ptarray [ijet] = pTJet;
areaarray[ijet] = areaJet;
ptByArea [ijet] = pTJet / areaJet;
unsigned int nConstituents( theJets[ijet].GetNConstituents() );
h_pTAllJets [iHLTbit]->Fill( pTJet );
h_etaAllJets [iHLTbit]->Fill( etaJet );
h_areaAllJets [iHLTbit]->Fill( areaJet );
h_ptByAreaAllJets [iHLTbit]->Fill( ptByArea[ijet] );
h_nConstituentsAllJets[iHLTbit]->Fill( nConstituents );
h2d_pTAllJets_vs_pTjet [iHLTbit]->Fill( pTLeadingJet, pTJet );
h2d_areaAllJets_vs_pTjet [iHLTbit]->Fill( pTLeadingJet, areaJet );
h2d_ptByAreaAllJets_vs_pTjet [iHLTbit]->Fill( pTLeadingJet, ptByArea[ijet] );
h2d_nConstituentsAllJets_vs_pTjet[iHLTbit]->Fill( pTLeadingJet, nConstituents );
///
/// histograms for leading jet
///
if ( ijet == 0 )
{
h_pTJet [iHLTbit]->Fill( pTJet );
h_etaJet [iHLTbit]->Fill( etaJet );
h_areaJet [iHLTbit]->Fill( areaJet );
h_ptByAreaJet [iHLTbit]->Fill( ptByArea[ijet] );
h_nConstituentsJet[iHLTbit]->Fill( nConstituents );
h2d_areaJet_vs_pTjet [iHLTbit]->Fill( pTJet, areaJet );
h2d_ptByAreaJet_vs_pTjet [iHLTbit]->Fill( pTJet, ptByArea[ijet] );
h2d_nConstituentsJet_vs_pTjet[iHLTbit]->Fill( pTJet, nConstituents );
}
}
double medianPt ( TMath::Median( theJets.size(), areaarray ) );
double medianArea ( TMath::Median( theJets.size(), ptarray ) );
double medianPtPerArea( TMath::Median( theJets.size(), ptByArea ) );
h_medianPt [iHLTbit]->Fill( medianArea );
h_medianArea [iHLTbit]->Fill( medianPt );
h_medianPtByArea[iHLTbit]->Fill( medianPtPerArea );
h2d_medianPt_vs_pTjet [iHLTbit]->Fill( ptarray[0], medianPt );
h2d_medianArea_vs_pTjet [iHLTbit]->Fill( ptarray[0], medianArea );
h2d_medianPtByArea_vs_pTjet[iHLTbit]->Fill( ptarray[0], medianPtPerArea );
}
}
void UEAnalysisGAM::gammaAnalysisMC(Float_t weight,Float_t etaRegion,Float_t ptThreshold, TClonesArray& MCGamma, TClonesArray& ChargedJet)
{
vector<TLorentzVector*> JetMC;
vector<TLorentzVector*> GamMC;
GamMC.clear();
JetMC.clear();
for(int j=0;j<MCGamma.GetSize();++j){
TLorentzVector *g = (TLorentzVector*)MCGamma.At(j);
if(fabs(g->Eta())<etaRegion){
GamMC.push_back(g);
if(GamMC.size()==1) JetMC.push_back(g);
}
}
if(JetMC.size() != 0){
for(int j=0;j<ChargedJet.GetSize();++j){
TLorentzVector *w = (TLorentzVector*)ChargedJet.At(j);
if(fabs(w->Eta())<etaRegion){
JetMC.push_back(w);
}
}
if(JetMC.size()>=2){
float dPhiJet1 = fabs(JetMC[0]->Phi()-JetMC[1]->Phi());
if(dPhiJet1> piG) dPhiJet1 = 2*piG -dPhiJet1;
dPhiJet1 = (180*dPhiJet1)/piG;
fdPhiGamma1JetMC->Fill(dPhiJet1);
}
if(JetMC.size()>=3){
float dPhiJet2 = fabs(JetMC[0]->Phi()-JetMC[2]->Phi());
if(dPhiJet2> piG) dPhiJet2 = 2*piG -dPhiJet2;
dPhiJet2 = (180*dPhiJet2)/piG;
fdPhiGamma2JetMC->Fill(dPhiJet2);
}
if(JetMC.size()>=4){
float dPhiJet3 = fabs(JetMC[0]->Phi()-JetMC[3]->Phi());
if(dPhiJet3> piG) dPhiJet3 = 2*piG -dPhiJet3;
dPhiJet3 = (180*dPhiJet3)/piG;
fdPhiGamma3JetMC->Fill(dPhiJet3);
}
vector<AssociatedObject> assoJetMC;
assoJetMC.clear();
while(JetMC.size()>1){
int oldSize = JetMC.size();
vector<TLorentzVector*>::iterator itH = JetMC.begin();
if((*itH)->Pt()>=ptThreshold){
for(vector<TLorentzVector*>::iterator it=JetMC.begin();it!=JetMC.end();it++){
float azimuthDistanceJet = fabs( (*itH)->Phi() - (*it)->Phi() );
if((*it)->Pt()/(*itH)->Pt()>=0.3){
if( (piG - rangePhi) < azimuthDistanceJet && azimuthDistanceJet < (piG + rangePhi)){
AssociatedObject tmpPair((*itH),(*it));
assoJetMC.push_back(tmpPair);
JetMC.erase(it);
int newSize = oldSize -1;
oldSize = newSize;
JetMC.resize(newSize);
break;
}
}
}
}
JetMC.erase(itH);
int newSize = oldSize -1;
JetMC.resize(newSize);
}
if(assoJetMC.size()){
fNumbMPIMC->Fill(assoJetMC.size());
vector<AssociatedObject>::iterator at= assoJetMC.begin();
const TLorentzVector* leadingJet((*at).first);
const TLorentzVector* secondJet((*at).second);
pPtRatio_vs_PtJleadMC->Fill(leadingJet->Pt(),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_EtaJleadMC->Fill(fabs(leadingJet->Eta()),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_PhiJleadMC->Fill(leadingJet->Phi(),(secondJet->Pt()/leadingJet->Pt()));
fdEtaLeadingPairMC->Fill(leadingJet->Eta()-secondJet->Eta());
float dPhiJet = fabs(leadingJet->Phi()-secondJet->Phi());
if(dPhiJet> piG) dPhiJet = 2*piG -dPhiJet;
dPhiJet = (180*dPhiJet)/piG;
fdPhiLeadingPairMC->Fill(dPhiJet);
fptRatioLeadingPairMC->Fill(secondJet->Pt()/leadingJet->Pt());
}
fPhiLeadingGammaMC->Fill(GamMC[0]->Phi());
fPtLeadingGammaMC->Fill(GamMC[0]->Pt());
fEtaLeadingGammaMC->Fill(GamMC[0]->Eta());
}
}
