void analyzer()
{
TString processName = "ZJets";
TFile* f = TFile::Open(Form("hist_%s.root", processName.Data()), "recreate");
// Create chain of root trees
TChain chain("DelphesMA5tune");
//kisti
//chain.Add("/cms/home/tjkim/fcnc/sample/ZToLL50-0Jet_sm-no_masses/events_*.root");
//hep
chain.Add("/Users/tjkim/Work/fcnc/samples/ZToLL50-0Jet_sm-no_masses/events_*.root");
// Create object of class ExRootTreeReader
ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
Long64_t numberOfEntries = treeReader->GetEntries();
// Get pointers to branches used in this analysis
TClonesArray *branchMuon = treeReader->UseBranch("DelphesMA5tuneMuon");
// Book histograms
TH1 *histDiMuonMass = new TH1F("dimuon_mass","Di-Muon Invariant Mass (GeV)",100, 50, 150);
// Loop over all events
for(Int_t entry = 0; entry < numberOfEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
int nmuon = 0;
for( int i = 0; i < branchMuon->GetEntries(); i++)
{
Muon *muon = (Muon*) branchMuon->At(i);
if( muon->PT <= 20 || abs(muon->Eta) >= 2.4 ) continue;
nmuon = nmuon + 1 ;
}
if( nmuon >= 2){
Muon *mu1 = (Muon*) branchMuon->At(0);
Muon *mu2 = (Muon*) branchMuon->At(1);
// Plot di-muon invariant mass
histDiMuonMass->Fill(((mu1->P4()) + (mu2->P4())).M());
}
}
// Show resulting histograms
histDiMuonMass->Write();
f->Close();
}
void AnalyseEvents(ExRootTreeReader *treeReader, MyPlots *plots)
{
TClonesArray *branchJet = treeReader->UseBranch("Jet");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");
Long64_t allEntries = treeReader->GetEntries();
cout << "** Chain contains " << allEntries << " events" << endl;
Jet *jet[2];
MissingET *met;
Electron *electron;
Long64_t entry;
Int_t i;
// Loop over all events
for(entry = 0; entry < allEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
// Analyse two leading jets
if(branchJet->GetEntriesFast() >= 2)
{
jet[0] = (Jet*) branchJet->At(0);
jet[1] = (Jet*) branchJet->At(1);
plots->fJetPT[0]->Fill(jet[0]->PT);
plots->fJetPT[1]->Fill(jet[1]->PT);
}
// Analyse missing ET
if(branchMissingET->GetEntriesFast() > 0)
{
met = (MissingET*) branchMissingET->At(0);
plots->fMissingET->Fill(met->MET);
}
// Loop over all electrons in event
for(i = 0; i < branchElectron->GetEntriesFast(); ++i)
{
electron = (Electron*) branchElectron->At(i);
plots->fElectronPT->Fill(electron->PT);
}
}
}
void
PrintAlignment()
{
AliCDBManager* cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
AliCDBEntry* align = cdb->Get("FMD/Align/Data");
if (!align) {
Error("PrintAlignment","didn't alignment data from CDB");
return;
}
TClonesArray* array = dynamic_cast<TClonesArray*>(align->GetObject());
if (!array) {
Warning("PrintAlignement", "Invalid align data from CDB");
return;
}
Int_t nAlign = array->GetEntries();
for (Int_t i = 0; i < nAlign; i++) {
AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
Double_t ang[3];
Double_t trans[3];
a->GetAngles(ang);
a->GetTranslation(trans);
std::cout << a->GetVolPath() << "\n"
<< " translation: "
<< "(" << std::setw(12) << trans[0]
<< "," << std::setw(12) << trans[1]
<< "," << std::setw(12) << trans[2] << ")\n"
<< " rotation: "
<< "(" << std::setw(12) << ang[0]
<< "," << std::setw(12) << ang[1]
<< "," << std::setw(12) << ang[2] << ")" << std::endl;
// a->Print();
}
}
Int_t printDigits()
{
AliRunLoader *rl = AliRunLoader::Open("galice.root");
AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");
prl->LoadDigits("READ");
//prl->LoadDigits();
Int_t nDigits = 0;
Int_t nSimEvents = rl->GetNumberOfEvents();
for (Int_t ev = 0; ev < nSimEvents; ev++)
{
rl->GetEvent(ev);
Int_t nPhosDigits = prl->Digits()->GetEntries();
//Int_t nDigsFound = 0;
std::cout << "Number of digits found: " << nPhosDigits << std::endl;
TClonesArray *phosDigits = prl->Digits();
for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
{
//const AliPHOSDigit *digit = prl->Digit(iDig);
AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(iDig);
nDigits++;
//if(digit->GetTime() > 1.4e-08 && digit->GetTime() < 1.6e-08)
std::cout <<"#: " << iDig << " ID: " << digit->GetId() << " " << "Energy: " << digit->GetEnergy() << " Time: " << digit->GetTime() << " N_prim: " << digit->GetNprimary() << " " << digit->GetTimeR() << std::endl;
}
}
return 0;
}
void decayAndFill(int const kf, TLorentzVector* b, double const weight, TClonesArray& daughters)
{
pydecay->Decay(kf, b);
pydecay->ImportParticles(&daughters);
TLorentzVector p1Mom;
TLorentzVector p2Mom;
TVector3 v00;
int nTrk = daughters.GetEntriesFast();
for (int iTrk = 0; iTrk < nTrk; ++iTrk)
{
TParticle* ptl0 = (TParticle*)daughters.At(iTrk);
switch (ptl0->GetPdgCode())
{
//Will only have pions
case 211:
ptl0->Momentum(p1Mom);
v00.SetXYZ(ptl0->Vx() * 1000., ptl0->Vy() * 1000., ptl0->Vz() * 1000.); // converted to μm
break;
case -211:
ptl0->Momentum(p2Mom);
break;
default:
break;
}
}
daughters.Clear();
fill(kf, b, weight, p1Mom, p2Mom, v00);
}
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());
}
}
void LHCOWriter::AnalyseEvent()
{
Event *element;
element = static_cast<Event*>(fBranchEvent->At(0));
fprintf(fOutputFile, "%4d %13lld %8d\n", 0, element->Number, 0);
++fIntParam[0];
}
//_____________________________________________________________________________
void THaVDC::CorrectTimeOfFlight(TClonesArray& tracks)
{
const static Double_t v = 3.0e-8; // for now, assume that everything travels at c
// get scintillator planes
THaScintillator* s1 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s1") );
THaScintillator* s2 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s2") );
if( (s1 == NULL) || (s2 == NULL) )
return;
// adjusts caluculated times so that the time of flight to S1
// is the same as a track going through the middle of the VDC
// (i.e. x_det = 0) at a 45 deg angle (theta_t and phi_t = 0)
// assumes that at least the coarse tracking has been performed
Int_t n_exist = tracks.GetLast()+1;
//cerr<<"num tracks: "<<n_exist<<endl;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* track = static_cast<THaTrack*>( tracks.At(t) );
// calculate the correction, since it's on a per track basis
Double_t s1_dist, vdc_dist, dist, tdelta;
if(!s1->CalcPathLen(track, s1_dist))
s1_dist = 0.0;
if(!CalcPathLen(track, vdc_dist))
vdc_dist = 0.0;
// since the z=0 of the transport coords is inclined with respect
// to the VDC plane, the VDC correction depends on the location of
// the track
if( track->GetX() < 0 )
dist = s1_dist + vdc_dist;
else
dist = s1_dist - vdc_dist;
tdelta = ( fCentralDist - dist) / v;
//cout<<"time correction: "<<tdelta<<endl;
// apply the correction
Int_t n_clust = track->GetNclusters();
for( Int_t i = 0; i < n_clust; i++ ) {
THaVDCUVTrack* the_uvtrack =
static_cast<THaVDCUVTrack*>( track->GetCluster(i) );
if( !the_uvtrack )
continue;
//FIXME: clusters guaranteed to be nonzero?
the_uvtrack->GetUCluster()->SetTimeCorrection(tdelta);
the_uvtrack->GetVCluster()->SetTimeCorrection(tdelta);
}
}
}
//______________________________________________________________________________
void alice_esd_read()
{
// Read tracks and associated clusters from current event.
AliESDRun *esdrun = (AliESDRun*) esd->fESDObjects->FindObject("AliESDRun");
TClonesArray *tracks = (TClonesArray*) esd->fESDObjects->FindObject("Tracks");
// This needs further investigation. Clusters not shown.
// AliESDfriend *frnd = (AliESDfriend*) esd->fESDObjects->FindObject("AliESDfriend");
// printf("Friend %p, n_tracks:%d\n", frnd, frnd->fTracks.GetEntries());
if (track_list == 0) {
track_list = new TEveTrackList("ESD Tracks");
track_list->SetMainColor(6);
//track_list->SetLineWidth(2);
track_list->SetMarkerColor(kYellow);
track_list->SetMarkerStyle(4);
track_list->SetMarkerSize(0.5);
gEve->AddElement(track_list);
}
TEveTrackPropagator* trkProp = track_list->GetPropagator();
trkProp->SetMagField( 0.1 * esdrun->fMagneticField ); // kGaus to Tesla
gProgress->Reset();
gProgress->SetMax(tracks->GetEntriesFast());
for (Int_t n=0; n<tracks->GetEntriesFast(); ++n)
{
AliESDtrack* at = (AliESDtrack*) tracks->At(n);
// If ITS refit failed, take track parameters at inner TPC radius.
AliExternalTrackParam* tp = at;
if (! trackIsOn(at, kITSrefit)) {
tp = at->fIp;
}
TEveTrack* track = esd_make_track(trkProp, n, at, tp);
track->SetAttLineAttMarker(track_list);
track_list->AddElement(track);
// This needs further investigation. Clusters not shown.
// if (frnd)
// {
// AliESDfriendTrack* ft = (AliESDfriendTrack*) frnd->fTracks->At(n);
// printf("%d friend = %p\n", ft);
// }
gProgress->Increment(1);
}
track_list->MakeTracks();
}
//_____________________________________________________________________________
Int_t THaVDC::FindVertices( TClonesArray& tracks )
{
// Calculate the target location and momentum at the target.
// Assumes that CoarseTrack() and FineTrack() have both been called.
Int_t n_exist = tracks.GetLast()+1;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* theTrack = static_cast<THaTrack*>( tracks.At(t) );
CalcTargetCoords(theTrack, kRotatingTransport);
}
return 0;
}
void testTDime(Int_t nev = 100) {
gSystem->Load("libEVGEN");
gSystem->Load("libTDime");
gSystem->Load("libdime");
TDime* dime = new TDime();
dime->SetEnergyCMS(7000.0);
dime->SetYRange(-2.0, 2.0); // Set rapidity range of mesons
dime->SetMinPt(0.1); // Minimum pT of mesons
dime->Initialize();
// (pi+pi-) histograms
TH1* hM = new TH1D("hM", "DIME #pi^{+}#pi^{-};M_{#pi^{+}#pi^{-}} #[]{GeV/#it{c}^{2}}", 100, 0.0, 5.0);
TClonesArray* particles = new TClonesArray("TParticle", 6);
TParticle* part = NULL;
TLorentzVector v[2];
TLorentzVector vSum;
// Event loop
for (Int_t i = 0; i < nev; ++i) {
dime->GenerateEvent();
Int_t np = dime->ImportParticles(particles, "All");
printf("\n DIME Event %d: Imported %3d particles \n", i, np);
Int_t nPrimary = 0;
// Loop over pion (j = 4,5) tracks
for (Int_t j = 4; j < 6; ++j) {
part = (TParticle*) particles->At(j); // Choose the particle
part->Print();
part->Momentum(v[nPrimary]); // Copy content to v
nPrimary++;
}
//particles.Clear();
// 4-vector sum
vSum = v[0] + v[1];
// Fill pi+pi- histograms
hM->Fill(vSum.M());
}
// Save plots as pdf
hM->Draw(); c1->SaveAs("massTDime.pdf");
}
void LHCOWriter::AnalyseMissingET()
{
MissingET *element;
element = static_cast<MissingET*>(fBranchMissingET->At(0));
Reset();
fIntParam[1] = 6;
fDblParam[1] = element->Phi;
fDblParam[2] = element->MET;
Write();
}
//_____________________________________________________________________________
Int_t THaReacPointFoil::Process( const THaEvData& )
{
// Calculate the vertex coordinates.
if( !IsOK() ) return -1;
Int_t ntracks = fSpectro->GetNTracks();
if( ntracks == 0 ) return 0;
TClonesArray* tracks = fSpectro->GetTracks();
if( !tracks ) return -2;
TVector3 beam_org, beam_ray( 0.0, 0.0, 1.0 );
if( fBeam ) {
beam_org = fBeam->GetPosition();
beam_ray = fBeam->GetDirection();
}
static const TVector3 yax( 0.0, 1.0, 0.0 );
static const TVector3 xax( 1.0, 0.0, 0.0 );
TVector3 org, v;
Double_t t;
for( Int_t i = 0; i<ntracks; i++ ) {
THaTrack* theTrack = static_cast<THaTrack*>( tracks->At(i) );
// Ignore junk tracks
if( !theTrack || !theTrack->HasTarget() )
continue;
org.SetX( 0. );
org.SetZ( 0. );
org.SetY( 0. );
if( !IntersectPlaneWithRay( xax, yax, org,
beam_org, beam_ray, t, v ))
continue; // Oops, track and beam parallel?
theTrack->SetVertex(v);
// FIXME: preliminary
if( theTrack == fSpectro->GetGoldenTrack() ) {
fVertex = theTrack->GetVertex();
fVertexOK = kTRUE;
}
// FIXME: calculate vertex coordinate errors here (need beam errors)
}
return 0;
}
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;
}
void digitsTOF(Int_t nevents, Int_t nfiles){
TH1F *hadc = new TH1F("hadc","ADC [bin]",200, -100., 10000.);
TH1F *hadclog = new TH1F("hadclog","ADC [bin]",200, -1., 7.);
TTree *treeD=0x0;
TClonesArray *digits =0x0;
for (Int_t event=0; event<nevents; event++) {
cout << "Event " << event << endl;
treeD = GetTreeD(event, "TOF", nfiles);
if ( ! treeD ) {
cerr << "Event directory not found in " << nfiles << " files" << endl;
exit(1);
}
digits = NULL;
treeD->SetBranchAddress("TOF", &digits);
for(Int_t iev=0; iev<treeD->GetEntries(); iev++){
treeD->GetEntry(iev);
for (Int_t j = 0; j < digits->GetEntries(); j++) {
IlcTOFdigit* dig = dynamic_cast<IlcTOFdigit*> (digits->At(j));
hadc->Fill(dig->GetAdc());
if(dig->GetAdc()>0)hadclog->Fill(TMath::Log10(dig->GetAdc()));
}
}
}
TFile fc("digits.TOF.root","RECREATE");
fc.cd();
hadc->Write();
hadclog->Write();
fc.Close();
}
//_____________________________________________________________________________
void THaVDC::FindBadTracks(TClonesArray& tracks)
{
// Flag tracks that don't intercept S2 scintillator as bad
THaScintillator* s2 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s2") );
if(s2 == NULL) {
//cerr<<"Could not find s2 plane!!"<<endl;
return;
}
Int_t n_exist = tracks.GetLast()+1;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* track = static_cast<THaTrack*>( tracks.At(t) );
Double_t x2, y2;
// project the current x and y positions into the s2 plane
if(!s2->CalcInterceptCoords(track, x2, y2)) {
x2 = 0.0;
y2 = 0.0;
}
// if the tracks go out of the bounds of the s2 plane,
// toss the track out
if( (TMath::Abs(x2 - s2->GetOrigin().X()) > s2->GetSize()[0]) ||
(TMath::Abs(y2 - s2->GetOrigin().Y()) > s2->GetSize()[1]) ) {
// for now, we just flag the tracks as bad
track->SetFlag( track->GetFlag() | kBadTrack );
//tracks.RemoveAt(t);
#ifdef WITH_DEBUG
//cout << "Track " << t << " deleted.\n";
#endif
}
}
// get rid of the slots for the deleted tracks
//tracks.Compress();
}
void digitsPHOS(Int_t nevents, Int_t nfiles)
{
TH1F * hadc = new TH1F ("hadc", "hadc", 100, -10, 200);
TH1F * hadcLog = new TH1F ("hadclog", "hadclog", 100, -2, 4);
IlcRunLoader* runLoader = IlcRunLoader::Open("gilc.root","Event","READ");
IlcPHOSLoader * phosLoader = dynamic_cast<IlcPHOSLoader*>(runLoader->GetLoader("PHOSLoader"));
for (Int_t ievent=0; ievent <nevents; ievent++) {
// for (Int_t ievent = 0; ievent < runLoader->GetNumberOfEvents(); ievent++) {
runLoader->GetEvent(ievent) ;
phosLoader->CleanDigits() ;
phosLoader->LoadDigits("READ") ;
TClonesArray * digits = phosLoader->Digits() ;
printf("Event %d contains %d digits\n",ievent,digits->GetEntriesFast());
for (Int_t j = 0; j < digits->GetEntries(); j++) {
IlcPHOSDigit* dig = dynamic_cast<IlcPHOSDigit*> (digits->At(j));
//cout << dig->GetEnergy() << endl;
hadc->Fill(dig->GetEnergy());
if(dig->GetEnergy()>0)
hadcLog->Fill(TMath::Log10(dig->GetEnergy()));
}
}
TFile fc("digits.PHOS.root","RECREATE");
fc.cd();
hadc->Write();
hadcLog->Write();
fc.Close();
}
void testPicoD0EventRead(TString filename)
{
gROOT->LoadMacro("$STAR/StRoot/StMuDSTMaker/COMMON/macros/loadSharedLibraries.C");
loadSharedLibraries();
gSystem->Load("StPicoDstMaker");
gSystem->Load("StPicoD0Maker");
TFile* f = new TFile(filename.Data());
TTree* T = (TTree*)f->Get("T");
StPicoD0Event* event = new StPicoD0Event();
T->SetBranchAddress("dEvent",&event);
TFile ff("read_test.root","RECREATE");
TNtuple* nt = new TNtuple("nt","","m:pt:eta:phi:theta:"
"decayL:kDca:pDca:dca12:cosThetaStar");
StKaonPion* kp = 0;
for(Int_t i=0;i<100000;++i)
{
T->GetEntry(i);
TClonesArray* arrKPi = event->kaonPionArray();
for(int idx=0;idx<event->nKaonPion();++idx)
{
kp = (StKaonPion*)arrKPi->At(idx);
nt->Fill(kp->m(),kp->pt(),kp->eta(),kp->phi(),kp->pointingAngle(),
kp->decayLength(),kp->kaonDca(),kp->pionDca(),kp->dcaDaughters(),kp->cosThetaStar());
}
}
nt->Write();
ff.Close();
}
void tclread()
{
// read file generated by tclwrite
// loop on all entries.
// histogram center of lines
TFile *f = new TFile("tcl.root");
TTree *T = (TTree*)f->Get("T");
TH2F *h2 = new TH2F("h2","center of lines",40,0,1,40,0,1);
TClonesArray *arr = new TClonesArray("TLine");
T->GetBranch("tcl")->SetAutoDelete(kFALSE);
T->SetBranchAddress("tcl",&arr);
Long64_t nentries = T->GetEntries();
for (Long64_t ev=0;ev<nentries;ev++) {
arr->Clear();
T->GetEntry(ev);
Int_t nlines = arr->GetEntriesFast();
for (Int_t i=0;i<nlines;i++) {
TLine *line = (TLine*)arr->At(i);
h2->Fill(0.5*(line->GetX1()+line->GetX2()), 0.5*(line->GetY1()+line->GetY2()));
}
}
h2->Draw("lego");
}
//---------------------------------------------------------------------------//
//Main Method
//---------------------------------------------------------------------------//
int main(int argc, char** argv)
{
TApplication *App = new TApplication("Application",(Int_t*)&argc, argv);
TCanvas *Canvas = new TCanvas("canvas", "Canvas", 640, 640);
// Set up ROOT as we require.
SetupROOT();
// Get list of files to run over.
TString fileName("/storage/epp2/phseaj/exercise/basket_2010b.list");
std::ifstream inputFile(fileName.Data(), ios::in);
// Declare a TChain for the TGlobalPID module
TChain *gRecon = new TChain("ReconDir/Global");
TChain *gGenVtx = new TChain("TruthDir/Vertices");
// Check if the file exists.
if (!inputFile.is_open()){
std::cout << "ERROR: File prod4 files not found!" << std::endl;
std::cout << " - This file should contain a list of all data files to be processed." << std::endl;
return 0;
}
else{
std::string curFileName;
// Add the input files to the TChains.
//only doing 10 of the basket files, revert to while to do whole run
// while(getline(inputFile,curFileName)){
for(int l = 0; l<10; l++){
if(getline(inputFile,curFileName)){
gRecon->Add(curFileName.c_str());
gGenVtx->Add(curFileName.c_str());
}
}
}
std::cout << "Got input file(s)." << std::endl;
//Setup access to the Recon tree
int NPIDs(0); // This variable counts the number of particles per event
int NVtxFGD1(0), NVtxFGD2(0);
// Declare a TClonesArray to hold objects of type TGlobalPID
TClonesArray *globalPIDs = new TClonesArray("ND::TGlobalReconModule::TGlobalPID",50);
TClonesArray *VtxFGD1 = new TClonesArray("ND::TTruthVerticesModule::TTruthVertex",50);
TClonesArray *VtxFGD2 = new TClonesArray("ND::TTruthVerticesModule::TTruthVertex",50);
// Associate the right branch in the TTree to the right local variable
gRecon->SetBranchAddress("NPIDs",&NPIDs);
gRecon->SetBranchAddress("PIDs",&globalPIDs);
gGenVtx->SetBranchAddress("VtxFGD1", &VtxFGD1);
gGenVtx->SetBranchAddress("NVtxFGD1", &NVtxFGD1);
gGenVtx->SetBranchAddress("VtxFGD2", &VtxFGD2);
gGenVtx->SetBranchAddress("NVtxFGD2", &NVtxFGD2);
//check that truthdir and recon have the same number of entries
if(gRecon->GetEntries() != gGenVtx->GetEntries())
cout<<"not equal entries, probably wrong"<<endl;
// Loop over the entries in the TChain.
//========================================================
// Declare Graphs n stuff here
//========================================================
//adding tclones arrays for use with detectors
Int_t NTPCs;
TClonesArray *TPC;
Int_t NFDGs;
TClonesArray *FDG;
Int_t NECALs;
TClonesArray *ECAL;
Int_t NPODs;
TClonesArray *POD;
Int_t NSMRDs;
TClonesArray *SMRD;
//adding a 2d graph general purpose, change titles each time!
TH1D *graph1 = new TH1D("graph1","Momenta of TPC PIDs from FDGs", 100, -50.0 , 50.0);
Int_t ninteract(0), nfgd(0),nfgdqes(0),fgdqesneu(0);
//========================================================
// end Declare Graphs n stuff here
//========================================================
// Loop over the entries in the TChain. (only 1/1000 of whole entries atm)
for(unsigned int i = 0; i < gRecon->GetEntries()/10; ++i) {
if((i+1)%10000 == 0) std::cout << "Processing event: " << (i+1) << std::endl;
//display status every 10,000 th entry
// Get an entry for the Recon tree
gRecon->GetEntry(i);
gGenVtx->GetEntry(i);
ND::TGlobalReconModule::TGlobalPID *gTrack = NULL;
//added new loop for truth vertex
gGenVtx->GetEntry(i);
for (int j=0; j<NPIDs; j++) {
// Get a specific track from the TClonesArray
gTrack = (ND::TGlobalReconModule::TGlobalPID*)globalPIDs->At(j);
//get truevertex (in example, also gets trueparticle, can add in later)
ND::TTrueVertex vtx = gTrack->TrueParticle.Vertex;
//get position lorrentz vector
TLorentzVector vec = vtx.Position;
ninteract++;
if(ABS(vec.X())<832.2 && ABS(vec.Y()-55)<832.2 && ((vec.Z()>123.45&&vec.Z()<446.95)||(vec.Z()>1481.45&&vec.Z()<1807.95))){ //is it in one of the FGDs?
nfgd++;
if(vtx.ReactionCode.find("Weak[NC],QES;",0)!=-1){
unsigned long det;
det = gTrack->Detectors;
string detstr;
stringstream stream;
stream << det;
detstr = stream.str();
if(detstr.find("1",0)||detstr.find("2",0)||detstr.find("3",0)){
graph1->Fill((Double_t)gTrack->FrontMomentum);
}
nfgdqes++;
}
}
TClonesArray *TPCObjects = new TClonesArray("ND::TGlobalReconModule::TTPCObject",gTrack->NTPCs);
ND::TGlobalReconModule::TObject *tpcTrack = NULL;
for ( int k = 0 ; k < gTrack->NTPCs; k++) {
tpcTrack = (ND::TGlobalReconModule::TObject*) TPCObjects->At(k);
//now we can access variables through tpcTrack->PullEle for example
}
}
} // End loop over events
//plotting bits at the end :D
graph1->Draw();
App->Run();
return 0;
}
//!PG main function
int
selector (TChain * tree, histos & plots, int if_signal)
{
plots.v_hardTAGPt = -99;
plots.v_softTAGPt = -99;
plots.v_TAGDProdEta = -99;
plots.v_TAGDeta = -99;
plots.v_TAGMinv = -99;
plots.v_LepLep = -99;
plots.v_hardLEPPt = -99;
plots.v_softLEPPt = -99;
plots.v_LEPDPhi = -99;
plots.v_LEPDEta = -99;
plots.v_LEPDR = -99;
plots.v_LEPMinv = -99;
plots.v_LEPProdCharge = -99;
plots.v_hardLEPCharge = -99;
plots.v_softLEPCharge = -99;
plots.v_MET = -99;
plots.v_ojets = -99 ;
plots.v_ojetsCJV = -99 ;
plots.v_ojetsRegionalCJV = -99 ;
plots.v_ojetsZepp_01 = -99 ;
plots.v_ojetsZepp_02 = -99 ;
plots.v_ojetsZepp_03 = -99 ;
plots.v_ojetsZepp_04 = -99 ;
plots.v_ojetsZepp_05 = -99 ;
plots.v_ojetsZepp_06 = -99 ;
plots.v_ojetsZepp_07 = -99 ;
plots.v_ojetsZepp_08 = -99 ;
plots.v_ojetsZepp_09 = -99 ;
plots.v_ojetsZepp_10 = -99 ;
plots.v_ojetsZepp_11 = -99 ;
plots.v_ojetsZepp_12 = -99 ;
plots.v_ojetsZepp_13 = -99 ;
plots.v_ojetsZepp_14 = -99 ;
plots.v_decay_Channel_e = -99 ;
plots.v_decay_Channel_mu = -99 ;
plots.v_decay_Channel_tau = -99 ;
TClonesArray * genParticles = new TClonesArray ("TParticle") ;
tree->SetBranchAddress ("genParticles", &genParticles) ;
// TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
// tree->SetBranchAddress ("tagJets", &tagJets) ;
TClonesArray * otherJets_temp = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress (g_KindOfJet.c_str(), &otherJets_temp) ;
// tree->SetBranchAddress ("otherJets", &otherJets_temp) ;
TClonesArray * electrons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("electrons", &electrons) ;
TClonesArray * muons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("muons", &muons) ;
TClonesArray * MET = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("MET", &MET) ;
TClonesArray * tracks = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("tracks", &tracks) ;
TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
TClonesArray * otherJets = new TClonesArray ("TLorentzVector") ;
int EleId[100];
float IsolEleSumPt_VBF[100];
int nEle;
int EleCharge[30];
tree->SetBranchAddress ("nEle", &nEle) ;
tree->SetBranchAddress ("EleId",EleId ) ;
tree->SetBranchAddress ("IsolEleSumPt_VBF",IsolEleSumPt_VBF ) ;
tree->SetBranchAddress ("EleCharge",EleCharge ) ;
float IsolMuTr[100];
int nMu ;
int MuCharge[30];
tree->SetBranchAddress ("nMu", &nMu) ;
tree->SetBranchAddress ("IsolMuTr",IsolMuTr ) ;
tree->SetBranchAddress ("MuCharge", MuCharge) ;
int IdEvent;
tree->SetBranchAddress ("IdEvent", &IdEvent) ;
int nentries = (int) tree->GetEntries () ;
plots.passedJetAndLepNumberSelections = 0;
plots.analyzed = 0;
plots.analyzed_ee = 0;
plots.analyzed_mumu = 0;
plots.analyzed_tautau = 0;
plots.analyzed_emu = 0;
plots.analyzed_etau = 0;
plots.analyzed_mutau = 0;
plots.passedJetAndLepNumberSelections_ee = 0;
plots.passedJetAndLepNumberSelections_mumu = 0;
plots.passedJetAndLepNumberSelections_tautau = 0;
plots.passedJetAndLepNumberSelections_emu = 0;
plots.passedJetAndLepNumberSelections_etau = 0;
plots.passedJetAndLepNumberSelections_mutau = 0;
//PG loop over the events
for (int evt = 0 ; evt < nentries ; ++evt)
{
tree->GetEntry (evt) ;
tagJets -> Clear () ;
otherJets -> Clear () ;
//---- check if signal ----
if (if_signal && (IdEvent!=123 && IdEvent!=124)) continue;
plots.analyzed++;
//!---- MC ----
if (IdEvent==123 || IdEvent==124) { //---- VBF event ----
plots.v_decay_Channel_e = 0;
plots.v_decay_Channel_mu = 0;
plots.v_decay_Channel_tau = 0;
for (int iGen = 0; iGen < genParticles->GetEntries() ; ++iGen){
TParticle* myparticle = (TParticle*) genParticles->At(iGen);
if (abs(myparticle->GetPdgCode()) == 24) { //---- W
Int_t mother1 = 0;
mother1 = myparticle->GetMother(0);
if (mother1 == 25) { //---- mother is higgs ----
for (int iDaughter = 0; iDaughter<2; iDaughter++){
if (abs(myparticle->GetDaughter(iDaughter)) == 11) {//---- W -> e
plots.v_decay_Channel_e++;
}
if (abs(myparticle->GetDaughter(iDaughter)) == 13) {//---- W -> mu
plots.v_decay_Channel_mu++;
}
if (abs(myparticle->GetDaughter(iDaughter)) == 15) {//---- W -> tau
plots.v_decay_Channel_tau++;
}
}
}
}
}
}
if (plots.v_decay_Channel_e == 2) plots.analyzed_ee++;
if (plots.v_decay_Channel_mu == 2) plots.analyzed_mumu++;
if (plots.v_decay_Channel_tau == 2) plots.analyzed_tautau++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.analyzed_emu++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_etau++;
if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_mutau++;
int cutId = 0 ;
plots.increase (cutId++) ; //AM 0 -> total number of events
// std::cerr << "--- preambolo leptoni " << std::endl;
std::vector<lepton> leptons ;
//PG pour electrons into leptons collection
//PG ---------------------------------------
//PG loop over electrons
for (int iele = 0; iele < electrons->GetEntries () ; ++iele)
{
TLorentzVector * theEle = (TLorentzVector*) (electrons->At (iele)) ;
lepton dummy (theEle, 0, iele) ;
leptons.push_back (dummy) ;
} //PG loop over electrons
//PG loop over muons
for (int imu = 0 ; imu < nMu ; ++imu)
{
TLorentzVector * theMu = (TLorentzVector*) (muons->At (imu)) ;
lepton dummy (theMu, 1, imu) ;
leptons.push_back (dummy) ;
} //PG loop over muons
//PG this check is not necessary
//PG if (leptons.size () < 2) continue ;
// std::cerr << "--- inizia leptoni " << std::endl;
//PG 2 LEPTONS
//PG ---------
/*
applied after the leptons choice:
in this case it is possible to differentiate the selections depending on the
position of each lepton in the pt-sorting.
the algorithm searches the first two most energetic candidates which satisfy
the ID selections required for the first and second lepton respectively.
Then check for channel analysis according to "g_LepLep"
0 == ee
1 == mumu
2 == emu
3 == mue
pt ordered
*/
sort (leptons.rbegin (), leptons.rend (), lessThan ()) ;
lepton primoLEP ;
lepton secondoLEP ;
double first_lepton_charge = 0;
double second_lepton_charge = 0;
int lepton_counter = 0;
int electron_counter = 0;
int muon_counter = 0;
//PG find the first lepton
int ilep = 0 ;
for ( ; ilep < leptons.size () ; ++ilep)
{
if (leptons.at (ilep).m_flav == 0) //PG electron
{
//PG iso check
bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento
if (g_ISO1[0] == 1 && eleIso != 1) continue;
//PG eleID check
int eleID = EleId[leptons.at (ilep).m_index] ;
if (g_ID1 == 100 && (eleID/100) != 1) continue;
else if (g_ID1 == 10 && ((eleID%100)/10) != 1) continue;
else if (g_ID1 == 1 && (eleID%10) != 1) continue;
first_lepton_charge = EleCharge[leptons.at (ilep).m_index];
}
else //PG muon
{
//PG iso check
bool muIso = (IsolMuTr[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ;
if (g_ISO1[1] == 1 && muIso != 1) continue;
first_lepton_charge = MuCharge[leptons.at (ilep).m_index];
}
primoLEP = leptons[ilep] ;
lepton_counter++;
if (leptons.at (ilep).m_flav == 0) electron_counter++;
else muon_counter++;
break ;
} //PG find the first lepton
//PG find the second lepton
bool flag_secondoLEP = false;
for (++ilep ; ilep < leptons.size () ; ++ilep)
{
if (leptons.at (ilep).m_flav == 0) //PG electron
{
//PG iso check
bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento
if (g_ISO2[0] == 1 && eleIso != 1) continue;
//PG eleID check
int eleID = EleId[leptons.at (ilep).m_index] ;
if (g_ID2 == 100 && (eleID/100) != 1) continue;
else if (g_ID2 == 10 && ((eleID%100)/10) != 1) continue;
else if (g_ID2 == 1 && (eleID%10) != 1) continue;
second_lepton_charge = EleCharge[leptons.at (ilep).m_index];
}
else //PG muon
{
//PG iso check
bool muIso = (IsolMuTr[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ;
if (g_ISO2[1] == 1 && muIso != 1) continue;
second_lepton_charge = MuCharge[leptons.at (ilep).m_index];
}
if (!flag_secondoLEP) {
secondoLEP = leptons[ilep] ;
flag_secondoLEP = true;
}
if (leptons.at (ilep).m_kine->Pt () > 0) {
if (leptons.at (ilep).m_flav == 0) electron_counter++;
else muon_counter++;
lepton_counter++;
}
} //PG find the second lepton
//---- AM 3 --- 2 leptons after Id
if (primoLEP.m_flav == -1 || secondoLEP.m_flav == -1) continue ;
//---- AM 4 check for the two most transverse-energetic leptons have the right flavours
plots.v_numLep = lepton_counter;
plots.v_numEle = electron_counter;
plots.v_numMu = muon_counter;
if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 0) plots.v_LepLep = 0 ;
if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 1) plots.v_LepLep = 1 ;
if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 1) plots.v_LepLep = 2 ;
if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 0) plots.v_LepLep = 3 ;
plots.v_hardLEPPt = primoLEP.m_kine->Pt () ;
//---- AM 5 pt_min of the most energetic lepton
plots.v_softLEPPt = secondoLEP.m_kine->Pt () ;
//---- AM 6 pt_min of the least energetic lepton
plots.v_LEPDPhi = deltaPhi (primoLEP.m_kine->Phi (), secondoLEP.m_kine->Phi ()) ;
//---- AM 7 Delta_phi_min between leptons
plots.v_LEPDEta = deltaEta (primoLEP.m_kine->Eta (), secondoLEP.m_kine->Eta ()) ;
plots.v_LEPDR = deltaR (primoLEP.m_kine->Phi (),primoLEP.m_kine->Eta (), secondoLEP.m_kine->Phi (), secondoLEP.m_kine->Eta ()) ;
TLorentzVector sumLEP = *(primoLEP.m_kine) + *(secondoLEP.m_kine) ;
plots.v_LEPMinv = sumLEP.M () ;
//---- AM 9 MInv_min of leptons
plots.v_LEPProdCharge = first_lepton_charge * second_lepton_charge ;
plots.v_hardLEPCharge = first_lepton_charge ;
plots.v_softLEPCharge = second_lepton_charge ;
//PG MET
//PG ---
// std::cerr << "--- finito " << std::endl;
TLorentzVector* met = ((TLorentzVector*) (MET->At(0))) ;
//correct for muons
for (int i = 0 ; i < nMu ; i++)
{
TLorentzVector * mu_v = (TLorentzVector*) (muons->At (i)) ;
if (mu_v->Pt () > 3)
{
met->SetPx (met->Px () - mu_v->Px ()) ;
met->SetPy (met->Py () - mu_v->Py ()) ;
}
}
plots.v_MET = met->Pt () ;
//---- AM 11 Met_min ----------------> Met correction ?
// if (((TLorentzVector*) (MET->At (0)))->Pt () < g_METMin) continue ; plots.increase (cutId++) ; //PG 10
//PG Ztautau vetos
//PG -------------
//PG the two electrons should not be opposite to each other
//
// TVector2 primoLEPT (primoLEP.m_kine->X (), primoLEP.m_kine->Y ()) ;
// TVector2 secondoLEPT (secondoLEP.m_kine->X (), secondoLEP.m_kine->Y ()) ;
// TVector2 METT (met->X (), met->Y ()) ;
//
// double Sum = METT * primoLEPT + METT * secondoLEPT / (1 + primoLEPT * secondoLEPT) ;
// double Dif = METT * primoLEPT - METT * secondoLEPT / (1 - primoLEPT * secondoLEPT) ;
//
// TVector2 METT1 = 0.5 * (Sum + Dif) * primoLEPT ;
// TVector2 METT2 = 0.5 * (Sum - Dif) * secondoLEPT ;
//
// double ptNu1 = METT1.Mod () / cos (primoLEP.m_kine->Theta ()) ;
// double ptNu2 = METT2.Mod () / cos (secondoLEP.m_kine->Theta ()) ;
plots.m_tree_selections->Fill();
plots.passedJetAndLepNumberSelections++;
if (plots.v_decay_Channel_e == 2) plots.passedJetAndLepNumberSelections_ee++;
if (plots.v_decay_Channel_mu == 2) plots.passedJetAndLepNumberSelections_mumu++;
if (plots.v_decay_Channel_tau == 2) plots.passedJetAndLepNumberSelections_tautau++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.passedJetAndLepNumberSelections_emu++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_etau++;
if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_mutau++;
} //PG loop over the events
plots.m_efficiency->Fill();
plots.m_efficiency->Write();
plots.m_tree_selections->Write();
delete otherJets_temp ;
delete tagJets ;
delete otherJets ;
delete electrons ;
delete muons ;
delete MET ;
delete tracks ;
return 0;
}
TPCTOFpid(const Char_t *filename, Int_t evMax = kMaxInt, Int_t startEv = 0)
{
/* include path for ACLic */
gSystem->AddIncludePath("-I$ALICE_ROOT/include");
gSystem->AddIncludePath("-I$ALICE_ROOT/TOF");
/* load libraries */
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
/* build analysis task class */
gROOT->LoadMacro("AliAnalysisParticle.cxx+g");
gROOT->LoadMacro("AliAnalysisEvent.cxx+g");
gROOT->LoadMacro("AliAnalysisTrack.cxx+g");
/* open file, get tree and connect */
TFile *filein = TFile::Open(filename);
TTree *treein = (TTree *)filein->Get("aodTree");
printf("got \"aodTree\": %d entries\n", treein->GetEntries());
AliAnalysisEvent *analysisEvent = new AliAnalysisEvent();
TClonesArray *analysisTrackArray = new TClonesArray("AliAnalysisTrack");
AliAnalysisTrack *analysisTrack = NULL;
treein->SetBranchAddress("AnalysisEvent", &analysisEvent);
treein->SetBranchAddress("AnalysisTrack", &analysisTrackArray);
/**************************************************************/
/*** HISTOS ***************************************************/
/**************************************************************/
/* run-time binning */
for (Int_t ibin = 0; ibin < NsigmaBins + 1; ibin++)
sigmaBin[ibin] = sigmaMin + ibin * sigmaStep;
/* THnSparse */
THnSparse *hTPCTOFpid[AliPID::kSPECIES][kNCharges];
for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
for (Int_t icharge = 0; icharge< kNCharges; icharge++) {
hTPCTOFpid[ipart][icharge] = new THnSparseF(Form("hTPCTOFpid_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]), "", kNHistoParams, NparamsBins);
for (Int_t iparam = 0; iparam < kNHistoParams; iparam++) {
hTPCTOFpid[ipart][icharge]->SetBinEdges(iparam, paramBin[iparam]);
}
}
}
/**************************************************************/
/**************************************************************/
/**************************************************************/
/* TOF PID response */
AliTOFPIDResponse tofResponse;
tofResponse.SetTimeResolution(tofReso);
/* TPC PID response */
AliTPCPIDResponse *tpcResponse = AliAnalysisTrack::GetTPCResponse();
/* start stopwatch */
TStopwatch timer;
timer.Start();
/* loop over events */
Bool_t hastofpid;
Int_t charge, index;
UShort_t dedxN;
Double_t ptpc, dedx, bethe, deltadedx, dedx_sigma, tpcsignal;
Double_t p, time, time_sigma, timezero, timezero_sigma, tof, tof_sigma, texp, texp_sigma, deltat, deltat_sigma, tofsignal;
Double_t tpctofsignal;
Double_t param[kNHistoParams];
for (Int_t iev = startEv; iev < treein->GetEntries() && iev < evMax; iev++) {
/* get event */
treein->GetEvent(iev);
if (iev % 100 == 0) printf("iev = %d\n", iev);
/* check vertex */
if (!analysisEvent->AcceptVertex()) continue;
/* check collision candidate */
if (!analysisEvent->IsCollisionCandidate()) continue;
/* check centrality quality */
if (analysisEvent->GetCentralityQuality() != 0.) continue;
/*** ACCEPTED EVENT ***/
/* apply time-zero TOF correction */
analysisEvent->ApplyTimeZeroTOFCorrection();
/* get centrality */
param[kCentrality] = analysisEvent->GetCentralityPercentile(AliAnalysisEvent::kCentEst_V0M);
/* loop over tracks */
for (Int_t itrk = 0; itrk < analysisTrackArray->GetEntries(); itrk++) {
/* get track */
analysisTrack = (AliAnalysisTrack *)analysisTrackArray->At(itrk);
if (!analysisTrack) continue;
/* check accepted track */
if (!analysisTrack->AcceptTrack()) continue;
/* get charge */
charge = analysisTrack->GetSign() > 0. ? kPositive : kNegative;
/*** ACCEPTED TRACK ***/
/* check TOF pid */
if (!analysisTrack->HasTOFPID() || !analysisTrack->HasTPCPID()) continue;
/*** ACCEPTED TRACK WITH TPC+TOF PID ***/
/* apply expected time correction */
analysisTrack->ApplyTOFExpectedTimeCorrection();
/* get track info */
p = analysisTrack->GetP();
param[kPt] = analysisTrack->GetPt();
/* get TPC info */
dedx = analysisTrack->GetTPCdEdx();
dedxN = analysisTrack->GetTPCdEdxN();
ptpc = analysisTrack->GetTPCmomentum();
/* get TOF info */
time = analysisTrack->GetTOFTime();
time_sigma = tofReso;
timezero = analysisEvent->GetTimeZeroTOF(p);
timezero_sigma = analysisEvent->GetTimeZeroTOFSigma(p);
tof = time - timezero;
tof_sigma = TMath::Sqrt(time_sigma * time_sigma + timezero_sigma * timezero_sigma);
/* loop over particle IDs */
for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
/* check rapidity */
if (TMath::Abs(analysisTrack->GetY(AliPID::ParticleMass(ipart))) > 0.5) continue;
/*** ACCEPTED TRACK WITHIN CORRECT RAPIDITY ***/
/* TPC signal */
bethe = tpcResponse->GetExpectedSignal(ptpc, ipart);
deltadedx = dedx - bethe;
dedx_sigma = tpcResponse->GetExpectedSigma(ptpc, dedxN, ipart);
tpcsignal = deltadedx / dedx_sigma;
param[kTPCsignal] = tpcsignal;
/* TOF expected time */
texp = analysisTrack->GetTOFExpTime(ipart);
texp_sigma = analysisTrack->GetTOFExpTimeSigma(ipart);
/* TOF signal */
deltat = tof - texp;
deltat_sigma = TMath::Sqrt(tof_sigma * tof_sigma + texp_sigma * texp_sigma);
tofsignal = deltat / deltat_sigma;
param[kTOFsignal] = tofsignal;
/* TPC+TOF signal */
tpctofsignal = TMath::Sqrt(tpcsignal * tpcsignal + tofsignal * tofsignal);
param[kTPCTOFsignal] = tpctofsignal;
/* fill histo */
hTPCTOFpid[ipart][charge]->Fill(param);
} /* end of loop over particle IDs */
} /* end of loop over tracks */
} /* end of loop over events */
/* start stopwatch */
timer.Stop();
timer.Print();
/* output */
TFile *fileout = TFile::Open(Form("TPCTOFpid.%s", filename), "RECREATE");
for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
hTPCTOFpid[ipart][icharge]->Write();
}
}
fileout->Close();
}
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 main(int argc, char **argv){
std::cout.precision(4);
// Counting time
Double_t initialTime = clock();
/*
* Histograms
*/
// All jets
TH1 *h_numberJet = new TH1F("Number Jets","Number Jets",11,-0.5,10.5);
// Non Isr jets
TH1 *h_jet_PT = new TH1F("Jet PT","Jet PT", 201,0.0,600.0);
TH1 *h_jet_Eta = new TH1F("Jet Eta","Jet Eta", 171,-5.0,5.0);
TH1 *h_jet_Phi = new TH1F("Jet Phi","Jet Phi", 375,-3.5,3.5);
TH1 *h_jet_DPhi_MET = new TH1F("Jet - MET Delta_Phi","Jet - MET Delta_Phi",300,0.0,4.0);
TH1 *h_jet_DPhi_MET_hpt = new TH1F("Jet - MET Delta_Phi_hpt","Jet - MET Delta_Phi_hpt",300,0.0,4.0);
TH1 *h_jet_MT = new TH1F("Jet Transverse mass","Jet Transverse Mass",201,0.0,600.0);
TH1 *h_jet_Delta_PT = new TH1F("Jet Delta-PT","Non ISR Delta-PT", 201,0.0,300.0);
TH1 *h_jet_PT_HT = new TH1F("Jet PT-HT ratio","Jet PT-HT ratio",201,-0.0025,1.0025);
TH1 *h_jet_PT_over_PT_others = new TH1F("Jet PT/PT_others","Jet PT/PT_others",401,-0.0025,2.0025);
TH1 *h_jet_Eta_over_Eta_others = new TH1F("Jet Eta/Eta_others","Jet Eta/Eta_others",401,-0.0025,2.0025);
TH1 *h_jet_DPhi_over_Phi_others = new TH1F("Jet Phi/Phi_others","Jet Phi/Phi_others",401,-0.0025,2.0025);
TH1 *h_jet_Delta_Eta = new TH1F("Jet Delta-Eta","Jet Delta-Eta", 171,0.0,5.0);
TH1 *h_jet_DPhi_MET_other = new TH1F("Jet - MET Delta_Phi other","Jet - MET Delta_Phi other",300,0.0,4.0);
TH1 *h_jet_multiplicity = new TH1F("Jet - Multiplicity","Jet - Multiplicity",101,-0.5,100.5);
TH1 *h_jet_DeltaR = new TH1F ("Jet - Delta_R","Jet - Delta_R",201,-0.0025,0.8025);
TH1 *h_jet_Delta_PT_leading = new TH1F("Delta PT: leading - Jet","Delta PT: leading - Jet", 201,0.0,600.0);
TH1 *h_jet_Delta_Eta_leading = new TH1F("Delta Eta: Jet - leading","Delta Eta: Jet - leading", 171,0.0,8.0);
TH2 *h2_jet_PTEta=new TH2F("Non_ISR_Jet_PT_Eta","Non ISR Jet PT Vs. Eta",201,-1.25,501.25,201,-4.02,4.02);
// ISR jets
TH1 *h_ISR_PT = new TH1F("ISR PT","ISR PT", 201,0.0,600.0);
TH1 *h_ISR_Eta = new TH1F("ISR Eta","ISR Eta", 171,-5.0,5.0);
TH1 *h_ISR_Phi = new TH1F("ISR Phi","ISR Phi", 375,-3.5,3.5);
TH1 *h_ISR_DPhi_MET = new TH1F("ISR - MET Delta_Phi","ISR - MET Delta_Phi",300,0.0,4.0);
TH1 *h_ISR_DPhi_MET_hpt = new TH1F("ISR - MET Delta_Phi_hpt","ISR - MET Delta_Phi_hpt",300,0.0,4.0);
TH1 *h_ISR_MT = new TH1F("ISR Transverse mass","ISR Transverse Mass",201,0.0,600.0);
TH1 *h_ISR_Delta_PT = new TH1F("ISR Delta-PT","ISR Delta-PT", 201,0.0,300.0);
TH1 *h_ISR_PT_HT = new TH1F("ISR PT-HT ratio","ISR PT-HT ratio",201,-0.0025,1.0025);
TH1 *h_ISR_PT_over_PT_others = new TH1F("ISR PT/PT_others","ISR PT/PT_others",401,-0.0025,2.0025);
TH1 *h_ISR_Eta_over_Eta_others = new TH1F("ISR Eta/Eta_others","ISR Eta/Eta_others",401,-0.0025,2.0025);
TH1 *h_ISR_DPhi_over_Phi_others = new TH1F("ISR Phi/Phi_others","ISR Phi/Phi_others",401,-0.0025,2.0025);
TH1 *h_ISR_Delta_Eta = new TH1F("ISR Delta-Eta","ISR Delta-Eta", 171,0.0,5.0);
TH1 *h_ISR_DPhi_MET_other = new TH1F("ISR - MET Delta_Phi other","ISR - MET Delta_Phi other",300,0.0,4.0);
TH1 *h_ISR_multiplicity = new TH1F("ISR - Multiplicity","ISR - Multiplicity",101,-0.5,100.5);
TH1 *h_ISR_DeltaR = new TH1F ("ISR - Delta_R","ISR - Delta_R",201,-0.0025,0.8025);
TH1 *h_ISR_Delta_PT_leading = new TH1F("Delta PT: leading - ISR","Delta PT: leading - ISR", 201,0.0,600.0);
TH1 *h_ISR_Delta_Eta_leading = new TH1F("Delta Eta: ISR - leading","Delta Eta: ISR - leading", 171,0.0,8.0);
TH2 *h2_ISR_PTEta=new TH2F("ISR_Jet_PT_Eta","ISR Jet PT Vs. Eta",201,-1.25,501.25,201,-4.02,4.02);
// MET
TH1 *h_MET = new TH1F("Missing ET","Missing ET",200,0,600);
TH1 *h_MET_hpt1 = new TH1F("Missing ET high_ISR_pt-1","Missing ET high_ISR_pt-1",200,0.0,600.0);
TH1 *h_MET_hpt2 = new TH1F("Missing ET high_ISR_pt-2","Missing ET high_ISR_pt-2",200,0.0,600.0);
TH1 *h_MET_hpt3 = new TH1F("Missing ET high_ISR_pt-3","Missing ET high_ISR_pt-3",200,0.0,600.0);
TH1 *h_MET_hpt4 = new TH1F("Missing ET high_ISR_pt-4","Missing ET high_ISR_pt-4",200,0.0,600.0);
TH2 *h2_dif_PTEta=new TH2F("FSR_ISR_Jet_PT_Eta_Difference","Difference between FSR and ISR Jet PT Vs. Eta distributions",201,-1.25,501.25,201,-4.02,4.02);
TH2 *h2_dif_lead_PTEta=new TH2F("Lead_ISR_Jet_PT_Eta_Difference","Difference between Lead and ISR Jet PT Vs. Eta distributions",201,-1.25,501.25,201,-4.02,4.02);
// Leading PT
TH1 *h_leading_PT = new TH1F("Leading PT","Leading PT", 201,0.0,600.0);
TH1 *h_leading_MT = new TH1F("Leading Transverse mass","Leading Transverse Mass",201,0.0,600.0);
TH1 *h_leading_Eta = new TH1F("Leading Eta","Leading Eta", 171,-5.0,5.0);
TH1 *h_leading_DPhi_MET = new TH1F("Leading - MET Delta_Phi","Leading - MET Delta_Phi",300,0.0,4.0);
TH2 *h2_leading_PTEta=new TH2F("Leading_Jet_PT_Eta","Leading Jet PT Vs. Eta",201,-1.25,501.25,201,-4.02,4.02);
// Other variables
TH1 *h_HT = new TH1F("HT","HT",201,0.0,600.0);
TH1 *h_HT_R1 = new TH1F("HT_R1","HT_R1",51,-0.01,1.01);
TH1 *h_HT_R2 = new TH1F("HT_R2","HT_R2",51,-0.01,1.01);
// B tagging
TH1 *h_BTag = new TH1F("BTag","BTag",5,-0.5,4.5);
TH1 *h_BTag_PT = new TH1F("BTag PT","BTag PT", 201,0.0,600.0);
TH1 *h_BTag_Eta = new TH1F("BTag Eta","BTag Eta", 171,-5.0,5.0);
TH1 *h_BTag_DPhi_MET = new TH1F("BTag - MET Delta_Phi","BTag - MET Delta_Phi",300,0.0,4.0);
TH1 *h_BTags_per_Event = new TH1F("BTags per event","BTags per event",5,-0.5,4.5);
// Further analysis
TH1 *h_ISR_PT_comp = new TH1F("ISR PT for comparison","ISR PT for comparison with histo", 20,0.0,800.0);
TH1 *h_ISR_Eta_comp = new TH1F("ISR Eta for comparison","ISR Eta for comparison with histo", 20,-4.2,4.2);
TH1 *h_ISR_DPhi_MET_comp = new TH1F("ISR Phi for comparison","ISR Phi for comparison with histo", 20,0,PI);
// To check the histograms' creation
TH1 *hist_ISR_PT = new TH1F("ISR PT comp","ISR PT comp", 20,0.0,800.0);
TH1 *hist_ISR_Abs_Eta = new TH1F("ISR Abs Eta comp","ISR Abs Eta comp", 20,0.0,5.2);
TH1 *hist_ISR_DPhi_MET = new TH1F("ISR Delta Phi comp","ISR Delta Phi comp", 20,0.0,PI);
TH1 *hist_ISR_PT_ratio = new TH1F("ISR PT/PT_others comp","ISR PT/PT_others comp",20,0.0,8.0);
TH1 *hist_ISR_Delta_Eta = new TH1F("ISR Delta-Eta comp","ISR Delta-Eta comp", 20,0.0,7.0);
TH1 *hist_ISR_DPhi_MET_other = new TH1F("ISR - MET Delta_Phi other comp","ISR - MET Delta_Phi other comp",20,0.0,PI);
TH1 *hist_ISR_Delta_PT_leading = new TH1F("Delta PT: leading - ISR comp","Delta PT: leading - ISR comp", 20,0.0,500.0);
TH1 *hist_ISR_Delta_Eta_leading = new TH1F("Delta Eta: ISR - leading comp","Delta Eta: ISR - leading comp", 20,0.0,6.5);
TH1 *hist_jet_PT = new TH1F("Jet PT comp","Jet PT comp", 20,0.0,800.0);
TH1 *hist_jet_Abs_Eta = new TH1F("Jet Abs Eta comp","Jet Abs Eta comp", 20,0.0,5.2);
TH1 *hist_jet_DPhi_MET = new TH1F("Jet Delta Phi comp","Jet Delta Phi comp", 20,0.0,PI);
TH1 *hist_jet_PT_ratio = new TH1F("Jet PT/PT_others comp","Jet PT/PT_others comp",20,0.0,7.0);
TH1 *hist_jet_Delta_Eta = new TH1F("Jet Delta-Eta comp","Jet Delta-Eta comp", 20,0.0,8.0);
TH1 *hist_jet_DPhi_MET_other = new TH1F("Jet - MET Delta_Phi other comp","Jet - MET Delta_Phi other comp",20,0.0,PI);
TH1 *hist_jet_Delta_PT_leading = new TH1F("Delta PT: leading - Jet comp","Delta PT: leading - Jet comp", 20,0.0,500.0);
TH1 *hist_jet_Delta_Eta_leading = new TH1F("Delta Eta: Jet - leading comp","Delta Eta: Jet - leading comp", 20,0.0,6.5);
for(int iRun = 1; iRun < 11; iRun ++){
// Create chains of root trees
TChain chain_Delphes("Delphes");
// Loading simulations from Delphes
Char_t *local_path;
local_path = (Char_t*) malloc(512*sizeof(Char_t));
if (atServer)
strcpy(local_path,"/home/af.garcia1214/PhenoMCsamples/Simulations/MG_pythia8_delphes_parallel/"); // At the server
else
strcpy(local_path,"/home/afgarcia1214/Documentos/Simulations/"); // At the University's pc
Char_t *head_folder;
head_folder = (Char_t*) malloc(512*sizeof(Char_t));
if (Matching)
strcpy(head_folder,"_Tops_Events_WI_Matching/");
else
strcpy(head_folder,"_Tops_Events_WI/");
head_folder[0] = channel;
head_folder[13] = ISR_or_NOT[0];
head_folder[14] = ISR_or_NOT[1];
Char_t current_folder[] = "_Tops_MG_1K_AG_WI_003/";
current_folder[0] = channel;
current_folder[15] = ISR_or_NOT[0];
current_folder[16] = ISR_or_NOT[1];
Char_t unidad = 0x30 + iRun%10;
Char_t decena = 0x30 + int(iRun/10)%10;
Char_t centena = 0x30 + int(iRun/100)%10;
current_folder[18] = centena;
current_folder[19] = decena;
current_folder[20] = unidad;
Char_t *file_delphes;
file_delphes = (Char_t*) malloc(512*sizeof(Char_t));
strcpy(file_delphes,local_path);
strcat(file_delphes,head_folder);
strcat(file_delphes,current_folder);
strcat(file_delphes,"Events/run_01/output_delphes.root");
cout << "\nReading the file: \nDelphes: " << file_delphes << endl;
chain_Delphes.Add(file_delphes);
// Objects of class ExRootTreeReader for reading the information
ExRootTreeReader *treeReader_Delphes = new ExRootTreeReader(&chain_Delphes);
Long64_t numberOfEntries = treeReader_Delphes->GetEntries();
// Get pointers to branches used in this analysis
TClonesArray *branchJet = treeReader_Delphes->UseBranch("Jet");
TClonesArray *branchMissingET = treeReader_Delphes->UseBranch("MissingET");
cout << endl;
cout << " Number of Entries Delphes = " << numberOfEntries << endl;
cout << endl;
// particles, jets and vectors
MissingET *METpointer;
TLorentzVector *vect_currentJet = new TLorentzVector;
TLorentzVector *vect_auxJet = new TLorentzVector;
TLorentzVector *vect_leading = new TLorentzVector;
Jet *currentJet = new Jet;
Jet *auxJet = new Jet;
TRefArray array_temp;
// Temporary variables
Double_t MET = 0.0; // Missing transverse energy
Double_t delta_phi = 0.0; // difference between the phi angle of MET and the jet
Double_t transverse_mass = 0.0; // Transverse mass
Double_t HT = 0.0; // Sum of jets' PT
Double_t HT_R1 = 0.0; // Sum of jets' PT which are in the same hemisphere of the ISR jet hemisphere
Double_t HT_R2 = 0.0; // Sum of jets' PT which are in the opposite hemisphere of the ISR jet hemisphere
Double_t ISR_Eta = 0.0; // Pseudorapidity of the ISR jet
Int_t number_Btags = 0; // Number of B jets per event
Int_t ISR_Btags = 0; // Number of BTags which are also ISR jets
Double_t delta_PT_jet = 0.0; // |PT-<PT>|
Double_t PT_sum = 0.0; // sum(PT)
Double_t PT_aver = 0.0; // <PT>
Double_t Delta_eta_aver = 0.0; // sum_i|eta-eta_i|/(Nj-1)
Double_t Delta_phi_sum = 0.0; // sum delta_phi
Double_t Delta_phi_other_jets = 0.0; // Average of delta phi of other jets
Double_t PT_ratio = 0.0; // PT/PT_others
Double_t Eta_ratio = 0.0; // Eta/Eta_others
Double_t Eta_sum = 0.0; // sum(Eta)
Double_t Delta_R = 0.0; // Size of the jet
Double_t Delta_phi_ratio = 0.0; // Delta_phi/Delta_phi_others
Double_t Delta_PT_leading = 0.0; // PT - PT_leading
Double_t Delta_Eta_leading = 0.0; // |Eta - Eta_leading|
/*
* Some variables used through the code
*/
Int_t ISR_jets[numberOfEntries];
Int_t NumJets = 0;
Char_t *local_path_binary;
local_path_binary = (Char_t*) malloc(512*sizeof(Char_t));
if (atServer)
strcpy(local_path_binary,"/home/af.garcia1214/PhenoMCsamples/Results/matching_Results/"); // At the server
else
strcpy(local_path_binary,"/home/afgarcia1214/Documentos/Results_and_data/matching_Results/"); // At the University's pc
Char_t *head_folder_binary;
head_folder_binary = (Char_t*) malloc(512*sizeof(Char_t));
if (Matching)
strcpy(head_folder_binary,"_Tops_matchs_WI_Matching/");
else
strcpy(head_folder_binary,"_Tops_matchs_WI/");
head_folder_binary[0] = channel;
head_folder_binary[13] = ISR_or_NOT[0];
head_folder_binary[14] = ISR_or_NOT[1];
Char_t matching_name[] = "ISR_jets_Tops_WI_003.bn";
matching_name[8] = channel;
matching_name[14] = ISR_or_NOT[0];
matching_name[15] = ISR_or_NOT[1];
matching_name[17] = centena;
matching_name[18] = decena;
matching_name[19] = unidad;
Char_t * fileName;
fileName = (Char_t*) malloc(512*sizeof(Char_t));
strcpy(fileName,local_path_binary);
strcat(fileName,head_folder_binary);
strcat(fileName,matching_name);
ifstream ifs(fileName,ios::in | ios::binary);
for (Int_t j = 0; j<numberOfEntries; j++){
ifs.read((Char_t *) (ISR_jets+j),sizeof(Int_t));
}
ifs.close();
// Jet with greatest PT
Double_t PT_max = 0;
Int_t posLeadingPT = -1;
Int_t ISR_greatest_PT = 0;
Double_t MT_leading_jet = 0.0; // Transverse mass
/*
* Main cycle of the program
*/
numberOfEntries = 100000;
for (Int_t entry = 0; entry < numberOfEntries; ++entry){
// Progress
if(numberOfEntries>10 && (entry%((int)numberOfEntries/10))==0.0){
cout<<"progress = "<<(entry*100/numberOfEntries)<<"%\t";
cout<< "Time :"<< (clock()-initialTime)/double_t(CLOCKS_PER_SEC)<<"s"<<endl;
}
// Load selected branches with data from specified event
treeReader_Delphes->ReadEntry(entry);
// MET
METpointer = (MissingET*) branchMissingET->At(0);
MET = METpointer->MET;
h_MET->Fill(MET);
NumJets=branchJet->GetEntries();
h_numberJet->Fill(NumJets);
// checking the ISR
if (ISR_jets[entry] == -1 || NumJets < 3)
continue;
PT_max = 0;
posLeadingPT = -1;
HT = 0;
HT_R1 = 0;
HT_R2 = 0;
number_Btags = 0;
delta_PT_jet = 0.0;
PT_aver = 0.0;
PT_sum = 0.0;
Delta_eta_aver = 0.0;
Delta_phi_sum = 0.0;
Delta_phi_other_jets = 0.0;
Delta_phi_ratio = 0.0;
Delta_PT_leading = 0.0;
Delta_Eta_leading = 0.0;
PT_ratio = 0.0;
Eta_ratio = 0.0;
Eta_sum = 0.0;
Delta_R = 0.0;
if (ISR_jets[entry] >= NumJets){
cout << "Error en el matching" << endl;
return 1;
}
// Preliminary for. It is used to calculate PT_aver and Delta_phi_sum
for (Int_t iJet = 0; iJet<NumJets; iJet++){
currentJet = (Jet*) branchJet->At(iJet);
vect_currentJet->SetPtEtaPhiM(currentJet->PT,currentJet->Eta,currentJet->Phi,currentJet->Mass);
delta_phi = deltaAng(vect_currentJet->Phi(), METpointer->Phi);
PT_sum += vect_currentJet->Pt();
Eta_sum += vect_currentJet->Eta();
Delta_phi_sum += delta_phi;
// HT
HT += vect_currentJet->Pt();
// HT ratios
if((vect_currentJet->Eta()*ISR_Eta) > 0)
HT_R1 += vect_currentJet->Pt();
else
HT_R2 += vect_currentJet->Pt();
// PT Leading jet
if(PT_max < vect_currentJet->Pt()){
PT_max = vect_currentJet->Pt();
posLeadingPT = iJet;
}
}
//PT_aver
PT_aver = PT_sum/NumJets;
// Leading PT
currentJet = (Jet*) branchJet->At(posLeadingPT);
vect_leading->SetPtEtaPhiM(currentJet->PT,currentJet->Eta,currentJet->Phi,currentJet->Mass);
// ISR jet
currentJet = (Jet*) branchJet->At(ISR_jets[entry]);
vect_currentJet->SetPtEtaPhiM(currentJet->PT,currentJet->Eta,currentJet->Phi,currentJet->Mass);
ISR_Eta = vect_currentJet->Eta();
for (Int_t iJet = 0; iJet<NumJets; iJet++){
currentJet = (Jet*) branchJet->At(iJet);
vect_currentJet->SetPtEtaPhiM(currentJet->PT,currentJet->Eta,currentJet->Phi,currentJet->Mass);
delta_phi = deltaAng(vect_currentJet->Phi(), METpointer->Phi);
transverse_mass = sqrt(2*vect_currentJet->Pt()*MET*(1-cos(delta_phi)));
// Correlated variables
delta_PT_jet = TMath::Abs(vect_currentJet->Pt()-PT_aver);
Delta_phi_other_jets = (Delta_phi_sum-delta_phi)/(NumJets-1);
PT_ratio = vect_currentJet->Pt()*(NumJets-1)/(PT_sum-vect_currentJet->Pt());
Eta_ratio = vect_currentJet->Eta()*(NumJets-1)/(Eta_sum-vect_currentJet->Eta());
Delta_phi_ratio = delta_phi*(NumJets-1)/(Delta_phi_sum-delta_phi);
Delta_Eta_leading = TMath::Abs(vect_currentJet->Eta()-vect_leading->Eta());
Delta_PT_leading = vect_leading->Pt()-vect_currentJet->Pt();
Delta_eta_aver = 0.0;
// For cycle used to calculate Delta_eta_aver
for(Int_t iJet2 = 0; iJet2<NumJets; iJet2++){
auxJet = (Jet*) branchJet->At(iJet2);
vect_auxJet->SetPtEtaPhiM(auxJet->PT,auxJet->Eta,auxJet->Phi,auxJet->Mass);
if (iJet2 != iJet) Delta_eta_aver += TMath::Abs(vect_auxJet->Eta()-vect_currentJet->Eta());
}
Delta_eta_aver = Delta_eta_aver/(NumJets-1);
Delta_R = sqrt(pow(currentJet->DeltaEta,2)+pow(currentJet->DeltaPhi,2));
// Multiplicity
array_temp = (TRefArray) currentJet->Constituents;
if (iJet != ISR_jets[entry]){ // Non ISR
h_jet_PT->Fill(vect_currentJet->Pt());
h_jet_Eta->Fill(vect_currentJet->Eta());
h_jet_Phi->Fill(vect_currentJet->Phi());
h_jet_DPhi_MET->Fill(delta_phi);
h_jet_MT->Fill(transverse_mass);
h_jet_Delta_PT->Fill(delta_PT_jet);
h_jet_Delta_Eta->Fill(Delta_eta_aver);
h_jet_DPhi_MET_other->Fill(Delta_phi_other_jets);
h_jet_PT_HT->Fill(vect_currentJet->Pt()/HT);
h_jet_multiplicity->Fill(array_temp.GetEntries());
h_jet_PT_over_PT_others->Fill(PT_ratio);
h_jet_Eta_over_Eta_others->Fill(Eta_ratio);
h_jet_DeltaR->Fill(Delta_R);
h_jet_DPhi_over_Phi_others->Fill(Delta_phi_ratio);
h_jet_Delta_PT_leading->Fill(Delta_PT_leading);
h_jet_Delta_Eta_leading->Fill(Delta_Eta_leading);
if (vect_currentJet->Pt()>240)
h_jet_DPhi_MET_hpt->Fill(delta_phi);
h2_jet_PTEta->Fill(vect_currentJet->Pt(),vect_currentJet->Eta());
// For testing creating histo
hist_jet_PT->Fill(vect_currentJet->Pt());
hist_jet_Abs_Eta->Fill(TMath::Abs(vect_currentJet->Eta()));
hist_jet_DPhi_MET->Fill(delta_phi);
hist_jet_PT_ratio->Fill(PT_ratio);
hist_jet_Delta_Eta->Fill(Delta_eta_aver);
hist_jet_DPhi_MET_other->Fill(Delta_phi_other_jets);
hist_jet_Delta_PT_leading->Fill(Delta_PT_leading);
hist_jet_Delta_Eta_leading->Fill(Delta_Eta_leading);
}
else{ //ISR
h_ISR_PT->Fill(vect_currentJet->Pt());
h_ISR_Eta->Fill(vect_currentJet->Eta());
h_ISR_Phi->Fill(vect_currentJet->Phi());
h_ISR_DPhi_MET->Fill(delta_phi);
h_ISR_Eta_comp->Fill(vect_currentJet->Eta());
h_ISR_PT_comp->Fill(vect_currentJet->Pt());
h_ISR_DPhi_MET_comp->Fill(delta_phi);
h_ISR_Delta_PT->Fill(delta_PT_jet);
h_ISR_Delta_Eta->Fill(Delta_eta_aver);
h_ISR_DPhi_MET_other->Fill(Delta_phi_other_jets);
h_ISR_PT_HT->Fill(vect_currentJet->Pt()/HT);
h_ISR_multiplicity->Fill(array_temp.GetEntries());
h_ISR_PT_over_PT_others->Fill(PT_ratio);
h_ISR_Eta_over_Eta_others->Fill(Eta_ratio);
h_ISR_DeltaR->Fill(Delta_R);
h_ISR_DPhi_over_Phi_others->Fill(Delta_phi_ratio);
h_ISR_Delta_PT_leading->Fill(Delta_PT_leading);
h_ISR_Delta_Eta_leading->Fill(Delta_Eta_leading);
if (vect_currentJet->Pt()>120)
h_MET_hpt1->Fill(MET);
if (vect_currentJet->Pt()>200)
h_MET_hpt2->Fill(MET);
if (vect_currentJet->Pt()>240){
h_MET_hpt3->Fill(MET);
h_ISR_DPhi_MET_hpt->Fill(delta_phi);
}
if (vect_currentJet->Pt()>300)
h_MET_hpt4->Fill(MET);
h2_ISR_PTEta->Fill(vect_currentJet->Pt(),vect_currentJet->Eta());
// Transverse mass
h_ISR_MT->Fill(transverse_mass);
// For testing creating histo
hist_ISR_PT->Fill(vect_currentJet->Pt());
hist_ISR_Abs_Eta->Fill(TMath::Abs(vect_currentJet->Eta()));
hist_ISR_DPhi_MET->Fill(delta_phi);
hist_ISR_PT_ratio->Fill(PT_ratio);
hist_ISR_Delta_Eta->Fill(Delta_eta_aver);
hist_ISR_DPhi_MET_other->Fill(Delta_phi_other_jets);
hist_ISR_Delta_PT_leading->Fill(Delta_PT_leading);
hist_ISR_Delta_Eta_leading->Fill(Delta_Eta_leading);
}
// BTag
h_BTag->Fill(currentJet->BTag);
if (currentJet->BTag == 1){ // The current jet is B Tagged
h_BTag_PT->Fill(vect_currentJet->Pt());
h_BTag_Eta->Fill(vect_currentJet->Eta());
h_BTag_DPhi_MET->Fill(delta_phi);
number_Btags++;
if (iJet == ISR_jets[entry]){ // If the ISR jet is also a B jet
ISR_Btags++;
}
}
}
// Jet with greatest PT
if (posLeadingPT != -1){
h_leading_PT->Fill(PT_max);
if(posLeadingPT == ISR_jets[entry]) ISR_greatest_PT++;
currentJet = (Jet*) branchJet->At(posLeadingPT);
vect_currentJet->SetPtEtaPhiM(currentJet->PT,currentJet->Eta,currentJet->Phi,currentJet->Mass);
delta_phi = deltaAng(vect_currentJet->Phi(), METpointer->Phi);
MT_leading_jet = sqrt(2*vect_currentJet->Pt()*MET*(1-cos(delta_phi)));
h_leading_MT->Fill(MT_leading_jet);
h_leading_Eta->Fill(vect_currentJet->Eta());
h_leading_DPhi_MET->Fill(delta_phi);
h2_leading_PTEta->Fill(vect_currentJet->Pt(),vect_currentJet->Eta());
}
// HT
if (1 < HT_R1/HT || 1 < HT_R2/HT){
cout << "Error en el evento: " << entry << endl;
cout << "HT: " << HT << "\tHT_R1: " << HT_R1 << "\tHT_R2: " << HT_R2 << endl;
return 1;
}
h_HT->Fill(HT);
h_HT_R1->Fill(HT_R1/HT);
h_HT_R2->Fill(HT_R2/HT);
h_BTags_per_Event->Fill(number_Btags);
}
cout<<"progress = 100%\t";
cout<< "Time :"<< (clock()-initialTime)/double_t(CLOCKS_PER_SEC)<<"s"<<endl;
cout<< "Percentage of events where the ISR jet is the jet with greatest PT: " << (Double_t) (ISR_greatest_PT*100)/numberOfEntries << "%\n";
cout<< "Percentage of events where the ISR jet is tagged as Bjet: " << (Double_t) (ISR_Btags*100)/numberOfEntries << "%\n";
} // End run's for cicle
TFile* hfile = new TFile("./histos/histos.root", "RECREATE");
h_jet_DPhi_MET->Write();
h_jet_Eta->Write();
h_jet_PT->Write();
h_jet_Phi->Write();
h_jet_MT->Write();
h_jet_Delta_PT->Write();
h_jet_Delta_Eta->Write();
h_jet_DPhi_MET_other->Write();
h_jet_PT_HT->Write();
h_jet_multiplicity->Write();
h_jet_PT_over_PT_others->Write();
h_jet_Eta_over_Eta_others->Write();
h_jet_DeltaR->Write();
h_jet_DPhi_over_Phi_others->Write();
h_jet_Delta_Eta_leading->Write();
h_jet_Delta_PT_leading->Write();
h_ISR_DPhi_MET->Write();
h_ISR_Eta->Write();
h_ISR_PT->Write();
h_ISR_Phi->Write();
h_ISR_MT->Write();
h_ISR_Delta_PT->Write();
h_ISR_Delta_Eta->Write();
h_ISR_DPhi_MET_other->Write();
h_ISR_PT_HT->Write();
h_ISR_multiplicity->Write();
h_ISR_PT_over_PT_others->Write();
h_ISR_Eta_over_Eta_others->Write();
h_ISR_DeltaR->Write();
h_ISR_DPhi_over_Phi_others->Write();
h_ISR_Delta_Eta_leading->Write();
h_ISR_Delta_PT_leading->Write();
h_MET->Write();
h_MET_hpt1->Write();
h_MET_hpt2->Write();
h_MET_hpt3->Write();
h_leading_MT->Write();
h_leading_PT->Write();
h_leading_Eta->Write();
h_leading_DPhi_MET->Write();
h_HT->Write();
h_HT_R1->Write();
h_HT_R2->Write();
h_numberJet->Write();
h_BTag->Write();
h_BTag_PT->Write();
h_BTag_Eta->Write();
h_BTag_DPhi_MET->Write();
h_BTags_per_Event->Write();
h2_ISR_PTEta->Write();
h2_jet_PTEta->Write();
h2_dif_PTEta->Add(h2_ISR_PTEta,h2_jet_PTEta,1,-1);
h2_dif_PTEta->Write();
h2_dif_lead_PTEta->Add(h2_ISR_PTEta,h2_leading_PTEta,1,-1);
h2_dif_lead_PTEta->Write();
{
TCanvas *C = new TCanvas("Eta","Pseudorapidity",1280,720);
Present(h_ISR_Eta,h_jet_Eta,C,1,"h","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Eta ISR vs BTag","Pseudorapidity ISR vs BTag",1280,720);
Present(h_ISR_Eta,h_BTag_Eta,C,1,"h","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Eta ISR vs Leading","Pseudorapidity ISR vs Leading",1280,720);
Present(h_ISR_Eta,h_leading_Eta,C,1,"h","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Transverse momentum","Transverse momentum",1280,720);
Present(h_ISR_PT,h_jet_PT,C,2,"PT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Transverse momentum ISR vs Leading","Transverse momentum ISR vs Leading",1280,720);
Present(h_ISR_PT,h_leading_PT,C,2,"PT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Transverse momentum ISR vs B_Tag","Transverse momentum ISR vs B_Tag",1280,720);
Present(h_ISR_PT,h_BTag_PT,C,2,"PT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Transverse momentum ISR, B_Tag, Leading","Transverse momentum ISR, B_Tag, Leading",1280,720);
Present_3(h_ISR_PT,h_BTag_PT,h_leading_PT,C,2,"PT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Transverse momentum ISR, B_Tag, Leading LOG","Transverse momentum ISR, B_Tag, Leading LOG",1280,720);
Present_3(h_ISR_PT,h_BTag_PT,h_leading_PT,C,2,"PT [GeV]","Num. Jets / Total",12,12,true);
C->Write();
C->Close();
C = new TCanvas("Transverse mass Leading vs ISR Jet","Transverse mass Leading vs ISR Jet",1280,720);
Present(h_ISR_MT,h_leading_MT,C,2,"MT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Transverse mass ISR vs Jet","Transverse mass ISR vs Jet",1280,720);
Present(h_ISR_MT,h_jet_MT,C,2,"MT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Phi","Phi",1280,720);
Present(h_ISR_Phi,h_jet_Phi,C,3,"f","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Delta Phi - Jet - MET","Delta Phi - Jet - MET",1280,720);
Present(h_ISR_DPhi_MET,h_jet_DPhi_MET,C,3,"Df","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Delta Phi - Jet - MET - Btag","Delta Phi - Jet - MET - Btag",1280,720);
Present(h_ISR_DPhi_MET,h_BTag_DPhi_MET,C,3,"Df","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Delta Phi - Jet - MET - leading","Delta Phi - Jet - MET - leading",1280,720);
Present(h_ISR_DPhi_MET,h_leading_DPhi_MET,C,1,"Df","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("MET > 120","MET > 120",1280,720);
Present(h_MET,h_MET_hpt1,C,2,"MET","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("MET > 200","MET > 200",1280,720);
Present(h_MET,h_MET_hpt2,C,2,"MET","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("MET > 240","MET > 240",1280,720);
Present(h_MET,h_MET_hpt3,C,2,"MET","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("HT ratio comparison","HT ratio comparison",1280,720);
Present(h_HT_R1,h_HT_R2,C,2,"HT","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("PT vs ETA - ISR","PT vs ETA - ISR",1280,720);
Plot_Single_2D(h2_ISR_PTEta,C,2, "PT [GeV]", "h", 12, 122);
C->Write();
C->Close();
C = new TCanvas("PT vs ETA - Jet","PT vs ETA - Jet",1280,720);
Plot_Single_2D(h2_jet_PTEta,C,2, "PT [GeV]", "h", 12, 122);
C->Write();
C->Close();
C = new TCanvas("PT vs ETA - Diff with any jet","PT vs ETA - Diff with any jet",1280,720);
Plot_Single_2D(h2_dif_PTEta,C,2, "PT [GeV]", "h", 12, 122);
C->Write();
C->Close();
C = new TCanvas("PT vs ETA - leading","PT vs ETA - leading",1280,720);
Plot_Single_2D(h2_leading_PTEta,C,2, "PT [GeV]", "h", 12, 122);
C->Write();
C->Close();
C = new TCanvas("PT vs ETA - Diff with leading","PT vs ETA - Diff with leading",1280,720);
Plot_Single_2D(h2_dif_lead_PTEta,C,2, "PT [GeV]", "h", 12, 122);
C->Write();
C->Close();
C = new TCanvas("HT","HT",1280,720);
Plot_Single(h_HT,C,2, "HT [GeV]", "Num. Jets / Total", 12, 12);
C->Write();
C->Close();
C = new TCanvas("Number_of_B_Tags","Number of B Tags",1280,720);
Plot_Single(h_BTags_per_Event,C,2, "B Tags / event", "Num. Jets / Total", 12, 12);
C->Write();
C->Close();
C = new TCanvas("Jet_multiplitcity","Jet multiplicity",1280,720);
Present(h_ISR_multiplicity,h_jet_multiplicity,C,2,"Tracks","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Delta_R_-_Jet_size","Delta R - Jet Size",1280,720);
Present(h_ISR_DeltaR,h_jet_DeltaR,C,1,"Delta_R","Num. Jets / Total");
C->Write();
C->Close();
// Correlated variables
C = new TCanvas("Cor_Delta_PT_Jet", "Delta PT jet",1280,720);
Present(h_ISR_Delta_PT,h_jet_Delta_PT,C,2,"PT [GeV]","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Cor_PT_proportion","PT proportion",1280,720);
Present(h_ISR_PT_HT,h_jet_PT_HT,C,2,"PT/HT","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Cor_Delta_Eta_Average","Delta Eta Average",1280,720);
Present(h_ISR_Delta_Eta,h_jet_Delta_Eta,C,2,"Dh","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Cor_Delta_Phi_Jet_MET_other_jets","Delta Phi - Jet MET - other jets",1280,720);
Present(h_ISR_DPhi_MET_other,h_jet_DPhi_MET_other,C,2,"Df","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Cor_PT_over_<PT_other>","PT/<PT_other>",1280,720);
Present(h_ISR_PT_over_PT_others,h_jet_PT_over_PT_others,C,2,"PT/<PT>","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Cor_Eta_over_<Eta_other>","Eta/<Eta_other>",1280,720);
Present(h_ISR_Eta_over_Eta_others,h_jet_Eta_over_Eta_others,C,3,"h/<h>","Num. Jets / Total",122);
C->Write();
C->Close();
C = new TCanvas("Cor_Delta_Phi_over_<Delta_Phi_other>","Delta_Phi/<Delta_Phi_other>",1280,720);
Present(h_ISR_DPhi_over_Phi_others,h_jet_DPhi_over_Phi_others,C,3,"Df/<Df>","Num. Jets / Total",122);
C->Write();
C->Close();
// Comparison with the leading Jet
C = new TCanvas("Leading_Delta_PT","Delta PT: PT_leading-PT",1280,720);
Present(h_ISR_Delta_PT_leading,h_jet_Delta_PT_leading,C,2,"(PT_leading - PT)","Num. Jets / Total");
C->Write();
C->Close();
C = new TCanvas("Leading_Delta_Eta","Delta Eta: |Eta-Eta_leading|",1280,720);
Present(h_ISR_Delta_Eta_leading,h_jet_Delta_Eta_leading,C,2,"|Eta - Eta_leading|","Num. Jets / Total");
C->Write();
C->Close();
}
hfile->Close();
TFile* hfile2 = new TFile("./histos/histos2.root", "RECREATE");
h_ISR_PT_comp->Write();
h_ISR_Eta_comp->Write();
h_ISR_DPhi_MET_comp->Write();
hist_ISR_PT->Write();
hist_ISR_Abs_Eta->Write();
hist_ISR_DPhi_MET->Write();
hist_ISR_PT_ratio->Write();
hist_ISR_Delta_Eta->Write();
hist_ISR_DPhi_MET_other->Write();
hist_ISR_Delta_PT_leading->Write();
hist_ISR_Delta_Eta_leading->Write();
hist_jet_PT->Write();
hist_jet_Abs_Eta->Write();
hist_jet_DPhi_MET->Write();
hist_jet_PT_ratio->Write();
hist_jet_Delta_Eta->Write();
hist_jet_DPhi_MET_other->Write();
hist_jet_Delta_PT_leading->Write();
hist_jet_Delta_Eta_leading->Write();
hfile2->Close();
return 0;
}
//!PG main function
int
selector (TChain * tree, histos & plots, int if_signal)
{
plots.v_Jet_1_Pt = -99;
plots.v_Jet_2_Pt = -99;
plots.v_Jet_3_Pt = -99;
plots.v_Jet_4_Pt = -99;
plots.v_Jet_5_Pt = -99;
plots.v_Jet_6_Pt = -99;
plots.v_Jet_1_x = -99;
plots.v_Jet_2_x = -99;
plots.v_Jet_3_x = -99;
plots.v_Jet_4_x = -99;
plots.v_Jet_5_x = -99;
plots.v_Jet_6_x = -99;
plots.v_Jet_1_y = -99;
plots.v_Jet_2_y = -99;
plots.v_Jet_3_y = -99;
plots.v_Jet_4_y = -99;
plots.v_Jet_5_y = -99;
plots.v_Jet_6_y = -99;
plots.v_Jet_1_z = -99;
plots.v_Jet_2_z = -99;
plots.v_Jet_3_z = -99;
plots.v_Jet_4_z = -99;
plots.v_Jet_5_z = -99;
plots.v_Jet_6_z = -99;
plots.v_Jet_1_e = -99;
plots.v_Jet_2_e = -99;
plots.v_Jet_3_e = -99;
plots.v_Jet_4_e = -99;
plots.v_Jet_5_e = -99;
plots.v_Jet_6_e = -99;
plots.v_Jet_1_eta = -99;
plots.v_Jet_2_eta = -99;
plots.v_Jet_3_eta = -99;
plots.v_Jet_4_eta = -99;
plots.v_Jet_5_eta = -99;
plots.v_Jet_6_eta = -99;
plots.v_Jet_1_phi = -99;
plots.v_Jet_2_phi = -99;
plots.v_Jet_3_phi = -99;
plots.v_Jet_4_phi = -99;
plots.v_Jet_5_phi = -99;
plots.v_Jet_6_phi = -99;
plots.v_Jet_1_DR = -99;
plots.v_Jet_2_DR = -99;
plots.v_Jet_3_DR = -99;
plots.v_Jet_4_DR = -99;
plots.v_Jet_5_DR = -99;
plots.v_Jet_6_DR = -99;
plots.v_numEle = -99;
plots.v_numMu = -99;
plots.v_numJets = -99;
plots.v_totNumJets = -99;
// TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
// tree->SetBranchAddress ("tagJets", &tagJets) ;
TClonesArray * otherJets_temp = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress (g_KindOfJet.c_str(), &otherJets_temp) ;
// tree->SetBranchAddress ("otherJets", &otherJets_temp) ;
TClonesArray * electrons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("electrons", &electrons) ;
TClonesArray * muons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("muons", &muons) ;
TClonesArray * MET = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("MET", &MET) ;
TClonesArray * tracks = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("tracks", &tracks) ;
TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
TClonesArray * otherJets = new TClonesArray ("TLorentzVector") ;
TClonesArray * HiggsParticle = new TClonesArray ("TParticle") ;
tree->SetBranchAddress ("HiggsParticle", &HiggsParticle) ;
int EleId[100];
float IsolEleSumPt_VBF[100];
int nEle;
tree->SetBranchAddress ("nEle", &nEle) ;
tree->SetBranchAddress ("EleId",EleId ) ;
tree->SetBranchAddress ("IsolEleSumPt_VBF",IsolEleSumPt_VBF ) ;
float IsolMuTr[100];
int nMu ;
tree->SetBranchAddress ("nMu", &nMu) ;
tree->SetBranchAddress ("IsolMuTr",IsolMuTr ) ;
int IdEvent;
tree->SetBranchAddress ("IdEvent", &IdEvent) ;
int nentries = (int) tree->GetEntries () ;
plots.passedJetAndLepNumberSelections = 0;
plots.analyzed = 0;
//PG loop over the events
// std::cerr << " --- nentries = " << nentries << std::endl;
// nentries = std::min(10000,nentries);
// nentries = 10000;
if (g_numEvents!= -1) nentries = std::min(g_numEvents,nentries);
std::cerr << " --- nentries = " << nentries << std::endl;
for (int evt = 0 ; evt < nentries ; ++evt)
{
if (!(evt%1000)) std::cerr << " --- evt = " << evt << std::endl;
plots.v_Jet_1_Pt = -99;
plots.v_Jet_2_Pt = -99;
plots.v_Jet_3_Pt = -99;
plots.v_Jet_4_Pt = -99;
plots.v_Jet_5_Pt = -99;
plots.v_Jet_6_Pt = -99;
plots.v_Jet_7_Pt = -99;
plots.v_Jet_8_Pt = -99;
plots.v_Jet_1_x = -99;
plots.v_Jet_2_x = -99;
plots.v_Jet_3_x = -99;
plots.v_Jet_4_x = -99;
plots.v_Jet_5_x = -99;
plots.v_Jet_6_x = -99;
plots.v_Jet_7_x = -99;
plots.v_Jet_8_x = -99;
plots.v_Jet_1_y = -99;
plots.v_Jet_2_y = -99;
plots.v_Jet_3_y = -99;
plots.v_Jet_4_y = -99;
plots.v_Jet_5_y = -99;
plots.v_Jet_6_y = -99;
plots.v_Jet_7_y = -99;
plots.v_Jet_8_y = -99;
plots.v_Jet_1_z = -99;
plots.v_Jet_2_z = -99;
plots.v_Jet_3_z = -99;
plots.v_Jet_4_z = -99;
plots.v_Jet_5_z = -99;
plots.v_Jet_6_z = -99;
plots.v_Jet_7_z = -99;
plots.v_Jet_8_z = -99;
plots.v_Jet_1_e = -99;
plots.v_Jet_2_e = -99;
plots.v_Jet_3_e = -99;
plots.v_Jet_4_e = -99;
plots.v_Jet_5_e = -99;
plots.v_Jet_6_e = -99;
plots.v_Jet_7_e = -99;
plots.v_Jet_8_e = -99;
plots.v_Jet_1_eta = -99;
plots.v_Jet_2_eta = -99;
plots.v_Jet_3_eta = -99;
plots.v_Jet_4_eta = -99;
plots.v_Jet_5_eta = -99;
plots.v_Jet_6_eta = -99;
plots.v_Jet_7_eta = -99;
plots.v_Jet_8_eta = -99;
plots.v_Jet_1_phi = -99;
plots.v_Jet_2_phi = -99;
plots.v_Jet_3_phi = -99;
plots.v_Jet_4_phi = -99;
plots.v_Jet_5_phi = -99;
plots.v_Jet_6_phi = -99;
plots.v_Jet_7_phi = -99;
plots.v_Jet_8_phi = -99;
plots.v_Jet_1_DR = -99;
plots.v_Jet_2_DR = -99;
plots.v_Jet_3_DR = -99;
plots.v_Jet_4_DR = -99;
plots.v_Jet_5_DR = -99;
plots.v_Jet_6_DR = -99;
plots.v_Jet_7_DR = -99;
plots.v_Jet_8_DR = -99;
plots.v_numEle = -99;
plots.v_numMu = -99;
plots.v_numJets = -99;
plots.v_totNumJets = -99;
tree->GetEntry (evt) ;
tagJets -> Clear () ;
otherJets -> Clear () ;
//---- check if signal ----
if (if_signal && (IdEvent!=123 && IdEvent!=124)) continue;
plots.analyzed++;
//---- MC data ----
std::vector<TLorentzVector*> MCJets ;
TLorentzVector* MCJets_temp[6] ;
int counter = 0;
if (if_signal && (IdEvent==123 || IdEvent==124)){
for(int ii=0; ii<9; ii++){
// if (ii==0 || ii==1){
// if (ii!=0 && ii!=1 && ii!=2 && ii!=3 && ii!=6){
if (ii!=2 && ii!=3 && ii!=6){
TParticle* myparticle = (TParticle*) HiggsParticle->At(ii);
// std::cerr << "pdg = " << ii << " = " << myparticle->GetPdgCode() << std::endl;
MCJets_temp[counter] = new TLorentzVector;
myparticle->Momentum(*(MCJets_temp[counter]));
MCJets.push_back((MCJets_temp[counter]));
counter++;
}
}
}
//---- find Tagging Jets ----
double m_jetPtMin = 15.;
double m_jetEtaMax = 5.;
double m_jetDEtaMin = -1;
double m_jetMjjMin = -1;
std::vector<myJet> goodJets ;
// std::cerr << std::endl << std::endl << std::endl << std::endl << std::endl;
for (int l=0; l<otherJets_temp->GetEntries (); l++ ){
TLorentzVector* jet_temp = (TLorentzVector*) otherJets_temp->At(l);
if (jet_temp->Pt()<m_jetPtMin) continue;
//---- Eta max threshold ----
if (jet_temp->Eta()>m_jetEtaMax) continue;
//---- pt min threshold ----
myJet dummy (jet_temp, 0, 0) ;
goodJets.push_back (dummy) ;
}
// for (int gg=0; gg<goodJets.size(); gg++ ) std::cerr << " goodJets[" << gg << "] = " << &(goodJets.at(gg)) << std::endl;
sort (goodJets.rbegin (), goodJets.rend (), lessThan ()) ;
std::vector<std::pair<TLorentzVector*,TLorentzVector*> > Vect_PairQuark_RecoJet;
std::vector<double> Map2D_PairQuark_RecoJet;
int counter_map = 0;
for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ----
for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ----
TLorentzVector* quark_temp = MCJets.at(k);
TLorentzVector* jet_temp = goodJets.at(rr).m_kine;
double DR = ROOT::Math::VectorUtil::DeltaR(quark_temp->BoostVector(),jet_temp->BoostVector());
Map2D_PairQuark_RecoJet.push_back(DR);
counter_map++;
} //--- end loop over recoJet ----
} //--- end loop over quarks ----
int selected_pair_jet[6] ;
int selected_pair_quark[6] ;
for (int jj=0; jj<MCJets.size(); jj++ ){
selected_pair_jet[jj] = -1;
selected_pair_quark[jj] = -1;
}
for (int jj=0; jj<MCJets.size(); jj++ ){
double DR_min = 1000;
counter_map = 0;
int temp_selected_pair_jet = -1;
int temp_selected_pair_quark = -1;
for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ----
for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ----
bool already_done = false;
for (int qq=0; qq<MCJets.size(); qq++) {
if ((selected_pair_jet[qq] == rr) || (selected_pair_quark[qq] == k)) already_done = true;
}
if (!already_done){
double DR_temp = Map2D_PairQuark_RecoJet.at(counter_map);
if (DR_temp<DR_min) {
DR_min = DR_temp;
temp_selected_pair_jet = rr;
temp_selected_pair_quark = k;
}
}
counter_map++;
}
}
selected_pair_jet[jj] = temp_selected_pair_jet;
selected_pair_quark[jj] = temp_selected_pair_quark;
}
for (int rr=0; rr<std::min(g_numJet,static_cast<int>(goodJets.size())); rr++ ){ //--- loop over recoJets ----
for (int k=0; k<MCJets.size(); k++ ){ //--- loop over quarks ----
bool used_one = false;
for (int qq=0; qq<MCJets.size(); qq++) {
if ((selected_pair_jet[qq] == rr) && (selected_pair_quark[qq] == k)) used_one = true;
}
if (used_one){
TLorentzVector* quark_temp = MCJets.at(k);
TLorentzVector* jet_temp = goodJets.at(rr).m_kine;
std::pair<TLorentzVector*,TLorentzVector*> PairQuark_RecoJet(quark_temp,jet_temp);
Vect_PairQuark_RecoJet.push_back(PairQuark_RecoJet);
}
} //--- end loop over recoJet ----
} //--- end loop over quarks ----
for (int iJet=0; iJet<std::min(g_numJet,static_cast<int>(goodJets.size())); iJet++){
double minDR = -1000;
double eta_reco_temp = goodJets.at (iJet).m_kine->Eta () ;
double phi_reco_temp = goodJets.at (iJet).m_kine->Phi () ;
for (int pp=0; pp<static_cast<int>(Vect_PairQuark_RecoJet.size()); pp++ ){
double eta_1 = Vect_PairQuark_RecoJet.at(pp).second->Eta();
double phi_1 = Vect_PairQuark_RecoJet.at(pp).second->Phi();
double DR_temp = deltaR(phi_1,eta_1,phi_reco_temp,eta_reco_temp);
if (DR_temp<0.001) {
double eta_2 = Vect_PairQuark_RecoJet.at(pp).first->Eta();
double phi_2 = Vect_PairQuark_RecoJet.at(pp).first->Phi();
minDR = deltaR(phi_1,eta_1,phi_2,eta_2);
break;
}
}
if (iJet==0) {
plots.v_Jet_1_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_1_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_1_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_1_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_1_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_1_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_1_DR = minDR;
}
if (iJet==1) {
plots.v_Jet_2_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_2_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_2_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_2_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_2_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_2_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_2_DR = minDR;
}
if (iJet==2) {
plots.v_Jet_3_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_3_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_3_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_3_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_3_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_3_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_3_DR = minDR;
}
if (iJet==3) {
plots.v_Jet_4_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_4_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_4_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_4_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_4_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_4_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_4_DR = minDR;
}
if (iJet==4) {
plots.v_Jet_5_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_5_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_5_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_5_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_5_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_5_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_5_DR = minDR;
}
if (iJet==5) {
plots.v_Jet_6_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_6_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_6_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_6_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_6_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_6_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_6_DR = minDR;
}
if (iJet==6) {
plots.v_Jet_7_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_7_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_7_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_7_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_7_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_7_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_7_DR = minDR;
}
if (iJet==7) {
plots.v_Jet_8_Pt = goodJets.at (iJet).m_kine->Pt () ;
plots.v_Jet_8_x = goodJets.at (iJet).m_kine->X () ;
plots.v_Jet_8_y = goodJets.at (iJet).m_kine->Y () ;
plots.v_Jet_8_z = goodJets.at (iJet).m_kine->Z () ;
plots.v_Jet_8_eta = goodJets.at (iJet).m_kine->Eta () ;
plots.v_Jet_8_phi = goodJets.at (iJet).m_kine->Phi () ;
plots.v_Jet_8_DR = minDR;
}
}
int numJets = goodJets.size();
plots.v_numJets = numJets;
plots.v_totNumJets = static_cast<double>(otherJets_temp->GetEntries ());
//---- leptons ----
plots.v_numEle = 0;
plots.v_numMu = 0;
std::vector<lepton> leptons ;
//---- AM ---- loop over electrons
for (int iele = 0; iele < electrons->GetEntries () ; ++iele)
{
TLorentzVector * theEle = (TLorentzVector*) (electrons->At (iele)) ;
lepton dummy (theEle, 0, iele) ;
leptons.push_back (dummy) ;
}
//---- AM ---- loop over muons
for (int imu = 0 ; imu < nMu ; ++imu)
{
TLorentzVector * theMu = (TLorentzVector*) (muons->At (imu)) ;
lepton dummy (theMu, 1, imu) ;
leptons.push_back (dummy) ;
}
for (int ilep=0 ; ilep < leptons.size () ; ++ilep){
if (leptons.at (ilep).m_flav == 0) {//PG electron
plots.v_numEle += 1;
}
if (leptons.at (ilep).m_flav == 1) {//PG muon
plots.v_numMu += 1;
}
}
plots.m_tree_selections->Fill();
if (numJets >=6 ) plots.passedJetAndLepNumberSelections++;
for (int hh=0; hh<counter; hh++) delete MCJets_temp[hh];
} //PG loop over the events
// std::cerr << "---- Finishes ----" << std::endl;
g_OutputFile->cd(0);
plots.m_efficiency->Fill();
plots.m_efficiency->Write();
plots.m_tree_selections->Write();
// std::cerr << "---- Written ----" << std::endl;
delete otherJets_temp ;
delete tagJets ;
delete otherJets ;
delete electrons ;
delete muons ;
delete MET ;
delete tracks ;
// std::cerr << "---- Deleted ----" << std::endl;
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 pythia8_susy() {
Int_t maxEvts = 100; // Maximo numero de eventos
char* path = gSystem->ExpandPathName("$PYTHIA8DATA");
if (gSystem->AccessPathName(path)) {
Warning("pythia8.C",
"Environment variable PYTHIA8DATA must contain path to pythi8100/xmldoc directory !");
return;
}
// Load libraries
gSystem->Load("$PYTHIA8/lib/libpythia8");
gSystem->Load("$PYTHIA8/lib/liblhapdfdummy");
gSystem->Load("libEG");
gSystem->Load("libEGPythia8");
//Definir archivo de salida
TFile * outfile = new TFile("eventos_pythia8_SUSY.root","RECREATE");
// Array of particles
TClonesArray* particles = new TClonesArray("TParticle", 5000);
//Definir el TTree
TTree*tree= new TTree("tree","Arbol con particulas segun Pythia8");
tree->Branch("particles",&particles);
// Create pythia8 object
TPythia8* pythia8 = new TPythia8();
//*Configurar: Aqui seleccione el proceso que quiere simular
pythia8->ReadString("SUSY:all = on"); //Todos los procesos susy posibles
//pythia8->ReadString("SUSY:qqbar2chi+-chi0 = on"); //Un proceso en especial
//Importante: pasar a Pythia8 el nombre del archivo SLHA
pythia8->ReadString("SLHA:file = SUSY_LM2_sftsht.slha"); //insertar aqui el nombre del archivo SLHA
// Initialize
pythia8->Initialize(2212 /* p */, 2212 /* p */, 7000. /* TeV */);
int iev = 0;
// Event loop
while( iev < maxEvts ) {
pythia8->GenerateEvent();
if (iev < 1) pythia8->EventListing();
pythia8->ImportParticles(particles,"All");
Int_t np = particles->GetEntriesFast();
// Particle loop
for (Int_t ip = 0; ip < np; ip++) {
TParticle* part = (TParticle*) particles->At(ip);
Int_t ist = part->GetStatusCode();
Int_t pdg = part->GetPdgCode();
}
tree->Fill();
++iev;
}
pythia8->PrintStatistics();
outfile->Write();
outfile->Close();
}
void pythia8(Int_t nev = 100, Int_t ndeb = 1)
{
const char *p8dataenv = gSystem->Getenv("PYTHIA8DATA");
if (!p8dataenv) {
const char *p8env = gSystem->Getenv("PYTHIA8");
if (!p8env) {
Error("pythia8.C",
"Environment variable PYTHIA8 must contain path to pythia directory!");
return;
}
TString p8d = p8env;
p8d += "/xmldoc";
gSystem->Setenv("PYTHIA8DATA", p8d);
}
const char* path = gSystem->ExpandPathName("$PYTHIA8DATA");
if (gSystem->AccessPathName(path)) {
Error("pythia8.C",
"Environment variable PYTHIA8DATA must contain path to $PYTHIA8/xmldoc directory !");
return;
}
// Load libraries
#ifndef G__WIN32 // Pythia8 is a static library on Windows
if (gSystem->Getenv("PYTHIA8")) {
gSystem->Load("$PYTHIA8/lib/libpythia8");
} else {
gSystem->Load("libpythia8");
}
#endif
gSystem->Load("libEG");
gSystem->Load("libEGPythia8");
// Histograms
TH1F* etaH = new TH1F("etaH", "Pseudorapidity", 120, -12., 12.);
TH1F* ptH = new TH1F("ptH", "pt", 50, 0., 10.);
// Array of particles
TClonesArray* particles = new TClonesArray("TParticle", 1000);
// Create pythia8 object
TPythia8* pythia8 = new TPythia8();
// Configure
pythia8->ReadString("HardQCD:all = on");
// Initialize
pythia8->Initialize(2212 /* p */, 2212 /* p */, 14000. /* TeV */);
// Event loop
for (Int_t iev = 0; iev < nev; iev++) {
pythia8->GenerateEvent();
if (iev < ndeb) pythia8->EventListing();
pythia8->ImportParticles(particles,"All");
Int_t np = particles->GetEntriesFast();
// Particle loop
for (Int_t ip = 0; ip < np; ip++) {
TParticle* part = (TParticle*) particles->At(ip);
Int_t ist = part->GetStatusCode();
// Positive codes are final particles.
if (ist <= 0) continue;
Int_t pdg = part->GetPdgCode();
Float_t charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
if (charge == 0.) continue;
Float_t eta = part->Eta();
Float_t pt = part->Pt();
etaH->Fill(eta);
if (pt > 0.) ptH->Fill(pt, 1./(2. * pt));
}
}
pythia8->PrintStatistics();
TCanvas* c1 = new TCanvas("c1","Pythia8 test example",800,800);
c1->Divide(1, 2);
c1->cd(1);
etaH->Scale(5./Float_t(nev));
etaH->Draw();
etaH->SetXTitle("#eta");
etaH->SetYTitle("dN/d#eta");
c1->cd(2);
gPad->SetLogy();
ptH->Scale(5./Float_t(nev));
ptH->Draw();
ptH->SetXTitle("p_{t} [GeV/c]");
ptH->SetYTitle("dN/dp_{t}^{2} [GeV/c]^{-2}");
}
void Trasporta(Int_t s,Int_t Rhum, TRandom *GeneratoreEsterno=0,Int_t Noise_Medio = 20) {
TStopwatch tempo;
tempo.Start(kTRUE);
cout<<endl<<"Sto trasportando attraverso i rivelatori: attendere... "<<endl;
TRandom *smear;
if(GeneratoreEsterno == 0){
smear = new TRandom3();
cout<<"Generatore Interno";
}else{
smear = GeneratoreEsterno;
cout<<"Generatore Esterno";
}
cout<<" FirstRNDM: "<<smear->Rndm()<<endl;
//////////////////////////////////////////////////////
//Creo un nuovo file e
//Definisco Struct per salvare i nuovi dati x y z
//////////////////////////////////////////////////////
//Definisco il nuovo albero per salvare i punti di hit
TFile sfile("trasporto_tree.root","RECREATE");
TTree *trasporto = new TTree("Ttrasporto","TTree con 3 branches");
//Punti sul layer
TTree *Rel_Lay1 = new TTree("Layer1","TTree con 1 branch");
TTree *Rel_Lay2 = new TTree("Layer2","TTree con 1 branch");
//rumore
TTree *Noise = new TTree("Rumore","TTree con 1 branch");
typedef struct {
Double_t X,Y,Z;
Int_t Flag;
} HIT;
static HIT beam;
static HIT lay1;
static HIT lay2;
typedef struct {
Int_t event;
Int_t tipo;
Int_t Noiselay1;
Int_t Noiselay2;
} infoRumore;
static infoRumore InfoR;
//Dichiaro i rami dei tree
trasporto->Branch("BeamPipe",&beam.X,"X/D:Y:Z:Flag/I");
trasporto->Branch("Layer1",&lay1.X,"X/D:Y:Z:Flag/I");
trasporto->Branch("Layer2",&lay2.X,"X/D:Y:Z:Flag/I");
Rel_Lay1->Branch("RealLayer1",&lay1.X,"X/D:Y:Z:Flag/I");
Rel_Lay2->Branch("RealLayer2",&lay2.X,"X/D:Y:Z:Flag/I");
Noise->Branch("Rumore",&InfoR,"event/I:tipo:Noiselay1:Noiselay2");
Double_t temp_phi = 0;
Int_t Nnoise=0;
////////////////////////////////
//Acquisizione Vertici
///////////////////////////////
TClonesArray *dir = new TClonesArray("Direction",100);
typedef struct {
Double_t X,Y,Z;
Int_t N;
}SINGLE_EVENT;
static SINGLE_EVENT event; //struct con molteplicita' e vertice di un singolo evento
TFile hfile("event_tree.root");
TTree *Born = (TTree*)hfile.Get("T");
TBranch *b1=Born->GetBranch("Event");
TBranch *b2=Born->GetBranch("Direzioni"); //acquisisco i due branches
b1->SetAddress(&event.X); //passo l'indirizzo del primo oggetto della struct e assegno tutto a b1
b2->SetAddress(&dir); // lo stesso per il vettore
/////////////////////////
//Geometria del rivelatore
/////////////////////////
Double_t R1=3; //raggio 3 cm beam pipe
Double_t R2=4; //raggio 4 cm primo layer
Double_t R3=7; //raggio 7 cm secondo layer
Double_t limit = 8.; //lunghezza layer su z-> z in [-8,8]
//Variabili Varie
Double_t Xo=0.;Double_t Yo=0.;Double_t Zo=0.;
Double_t X1=0.;Double_t Y1=0.;Double_t Z1=0.;
Double_t X2=0.;Double_t Y2=0.;Double_t Z2=0.;
Int_t N=0; //molteplicita'
Int_t yes = 0;
Int_t no = 0;
for(Int_t e=0; e < Born->GetEntries(); e++){
Born->GetEvent(e);
Xo=event.X;
Yo=event.Y;
Zo=event.Z;
N=event.N;
for(Int_t i=0; i<N; i++){
//Cast dell'elemenento i di TClones a Direction
Direction *angolacci=(Direction*)dir->At(i);
angolacci->SetRNDGenerator(smear);//uso lo stesso generatore anche nella classe
//primo hit beam pipe
angolacci->GeneraHit(Xo,Yo,Zo,R1);//genero il punto di impatto sul beam pipe
beam.X=angolacci->GetNewX(); //recupero le coordinate del punto d'impatto sul BP
beam.Y=angolacci->GetNewY();
beam.Z=angolacci->GetNewZ();
beam.Flag=1;
///////////////////////////////////////////////////
/////////////scattering sul beam pipe//////////////
///////////////////////////////////////////////////
if(s==1){
//dipende dal tipo di materiale
angolacci->Scattering(0.08,35.28);
}
//secondo hit layer 1
angolacci->GeneraHit(beam.X,beam.Y,beam.Z,R2);
X1 = angolacci->GetNewX();
Y1 = angolacci->GetNewY();
Z1 = angolacci->GetNewZ();
lay1.X=X1;
lay1.Y=Y1;
lay1.Z=Z1;
//verifico che la particella colpisca il layer
if(TMath::Abs(Z1) < limit){
lay1.Flag = e;
Rel_Lay1->Fill();
///////////////////////////////////////////////
/////////////scattering sul layer//////////////
///////////////////////////////////////////////
if(s==1){
angolacci->Scattering(0.02,9.37);
}
yes++;
}else no++;
//terzo hit layer 2
angolacci->GeneraHit(X1,Y1,Z1,R3);
X2 = angolacci->GetNewX();
Y2 = angolacci->GetNewY();
Z2 = angolacci->GetNewZ();
lay2.X=X2;
lay2.Y=Y2;
lay2.Z=Z2;
//verifico che la particella colpisca il layer
if(TMath::Abs(Z2) < limit){
lay2.Flag = e;
Rel_Lay2->Fill();
yes++;
}else{
no++;
}
angolacci->RemoveGenerator();
trasporto->Fill(); //riempie tutto con quello che ho definito sopra
// Debug
/*printf("Evento %d : part %d \n",e,i+1);
printf("x beam= %f ; y beam= %f; z beam= %f \n",beam.X,beam.Y,beam.Z);
if(lay1.Flag){
printf("x lay1= %f ; y lay1= %f; z lay1= %f \n",lay1.X,lay1.Y,lay1.Z);
}else{
printf("Non urta sul layer 1 \n");
}
if(lay2.Flag){
printf("x lay2= %f ; y lay2= %f; z lay2= %f \n",lay2.X,lay2.Y,lay2.Z);
}else{
printf("Non urta sul layer 2 \n");
}*/
}
////////////////////////////////////////////////////////////////////////////
//////////////////////////RUMORE////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
InfoR.event = e;
InfoR.tipo = Rhum;
if(Rhum != 0){
//genero rumore lay 1
if(Rhum == 1){
//Nnoise= TMath::Abs(smear->Gaus(20,5));
//Nnoise = 1+(Int_t)(20*smear->Rndm());
Nnoise = 1+(Int_t)(Noise_Medio*smear->Rndm());
}else{
Nnoise= Rhum;
}
InfoR.Noiselay1 = Nnoise;
for(Int_t y =0; y < Nnoise; y++){
temp_phi = smear->Uniform(0,2*TMath::Pi());
lay1.X = R2*TMath::Cos(temp_phi);
lay1.Y = R2*TMath::Sin(temp_phi);
lay1.Z = smear->Uniform(-limit,limit);
lay1.Flag=e;
Rel_Lay1->Fill();
}
//genero rumore lay 2
if(Rhum == 1){
//Nnoise= TMath::Abs(smear->Gaus(20,5));
//Nnoise = 1+(Int_t)(20*smear->Rndm());
Nnoise = 1+(Int_t)(Noise_Medio*smear->Rndm());
}else{
Nnoise= Rhum;
}
InfoR.Noiselay2 = Nnoise;
for(Int_t w =0; w < Nnoise; w++){
temp_phi = smear->Uniform(0,2*TMath::Pi());
lay2.X = R3*TMath::Cos(temp_phi);
lay2.Y = R3*TMath::Sin(temp_phi);
lay2.Z = smear->Uniform(-limit,limit);
lay2.Flag=e;
Rel_Lay2->Fill();
}
}else{
InfoR.Noiselay1 = 0;
InfoR.Noiselay2 = 0;
}
//fill per il rumore
Noise->Fill();
}
sfile.Write();
sfile.Close();
//ho il file con tutti gli eventi
tempo.Stop();
cout<<endl<<endl<<endl<<"//////////////////////////////////////"<<endl<<endl;
cout<<"Completato!"<<endl<<endl;
cout<<"Il trasporto è durato "<<endl;
tempo.Print();
cout<<endl<<endl;
cout<<"PARAMETRI TRASPORTO: "<<endl;
cout<<"\t"<<"Scattering: "<<s;
if(s==1)cout<<" Scattering attivo"<<endl;
if(s==0)cout<<" Scattering non attivo"<<endl;
cout<<"\t"<<"Rumore: ";
if(Rhum==1)cout<<" Rumore gaussiano "<<endl;
if(Rhum==0)cout<<" Nessun rumore"<<endl;
if((Rhum!=0) & (Rhum!=1))cout<<" Rumore con molteplicita' fissa "<<Rhum<<endl;
cout<<endl<<"//////////////////////////////////////"<<endl;
}