* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
- * Permission to use, copy, modify and distribute this software and its *
+ * Permission to usec, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
*/
-#include <vector>
-#include <iostream>
#include <Riostream.h>
+#include <TROOT.h>
+#include <TMath.h>
+#include <TBits.h>
#include <TFile.h>
#include <TCanvas.h>
-#include <TROOT.h>
#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <TH1F.h>
#include <TH2F.h>
-#include <TBits.h>
+#include <TProfile.h>
#include <TArrayF.h>
-#include "AliCdfJetFinder.h"
-#include "AliCdfJetHeader.h"
+#include <TVector2.h>
+
#include "AliJetReader.h"
#include "AliJetReaderHeader.h"
-#include "AliJet.h"
#include "AliAODJet.h"
#include "AliAODEvent.h"
-#include "TProfile.h"
+#include "AliJetFinder.h"
+#include "AliCdfJetFinder.h"
+#include "AliCdfJetHeader.h"
-ClassImp ( AliCdfJetFinder )
+ClassImp(AliCdfJetFinder)
//______________________________________________________________________________
AliCdfJetFinder::AliCdfJetFinder():
AliJetFinder(),
fHistos(0),
- fDebug(0),
fFromAod(0),
fAODwrite(0),
fAODtracksWrite(0),
+ fAnalyseJets(0),
fRefArr (NULL),
fNJets(-9999),
fNPart(-9999),
//______________________________________________________________________________
AliCdfJetFinder::~AliCdfJetFinder()
-
{
// destructor
}
//______________________________________________________________________________
-void AliCdfJetFinder::CreateOutputObjects(TList *histos)
+void AliCdfJetFinder::CreateOutputObjects(TList * const histos)
{
// Create the list of histograms. Only the list is owned.
fHistos = histos;
h22->SetMarkerStyle(kFullCircle);
fHistos->Add(h22);
- TProfile * h21_toward = new TProfile ("histo21_toward","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
- h21_toward->SetStats(kTRUE);
- h21_toward->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h21_toward->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
- h21_toward->GetXaxis()->SetTitleColor(1);
- h21_toward->SetMarkerStyle(kFullCircle);
- fHistos->Add(h21_toward);
-
- TProfile * h21_transverse = new TProfile ("histo21_transverse","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
- h21_transverse->SetStats(kTRUE);
- h21_transverse->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h21_transverse->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
- h21_transverse->GetXaxis()->SetTitleColor(1);
- h21_transverse->SetMarkerStyle(kFullCircle);
- fHistos->Add(h21_transverse);
-
- TProfile * h21_away = new TProfile ("histo21_away","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
- h21_away->SetStats(kTRUE);
- h21_away->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h21_away->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
- h21_away->GetXaxis()->SetTitleColor(1);
- h21_away->SetMarkerStyle(kFullCircle);
- fHistos->Add(h21_away);
-
- TProfile * h22_toward = new TProfile ("histo22_toward","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
- h22_toward->SetStats(kTRUE);
- h22_toward->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h22
_toward->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
- h22_toward->GetXaxis()->SetTitleColor(1);
- h22_toward->SetMarkerStyle(kFullCircle);
- fHistos->Add(h22_toward);
-
- TProfile * h22_transverse = new TProfile ("histo22_transverse","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
- h22_transverse->SetStats(kTRUE);
- h22_transverse->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h22
_transverse->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
- h22_transverse->GetXaxis()->SetTitleColor(1);
- h22_transverse->SetMarkerStyle(kFullCircle);
- fHistos->Add(h22_transverse);
-
- TProfile * h22_away = new TProfile ("histo22_away","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
- h22_away->SetStats(kTRUE);
- h22_away->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
- h22
_away->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
- h22_away->GetXaxis()->SetTitleColor(1);
- h22_away->SetMarkerStyle(kFullCircle);
- fHistos->Add(h22_away);
-
- TH1F *h23_toward = new TH1F ("histo23_toward","'Toward' Pt Distribution of charged particles", 200, 0., 14.);
- h23_toward->SetStats(kTRUE);
- h23_toward->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
- h23_toward->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
- h23_toward->GetXaxis()->SetTitleColor(1);
- h23_toward->SetMarkerStyle(kFullCircle);
- fHistos->Add(h23_toward);
-
- TH1F *h23_transverse = new TH1F ("histo23_transverse","'Transverse' Pt Distribution of charged particles", 200, 0., 14.);
- h23_transverse->SetStats(kTRUE);
- h23_transverse->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
- h23_transverse->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
- h23_transverse->GetXaxis()->SetTitleColor(1);
- h23_transverse->SetMarkerStyle(kFullCircle);
- fHistos->Add(h23_transverse);
-
- TH1F *h23_away = new TH1F ("histo23_away","'Away' Pt Distribution of charged particles", 200, 0., 14.);
- h23_away->SetStats(kTRUE);
- h23_away->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
- h23_away->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
- h23_away->GetXaxis()->SetTitleColor(1);
- h23_away->SetMarkerStyle(kFullCircle);
- fHistos->Add(h23_away);
+ TProfile * h21Toward = new TProfile ("histo21_toward","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
+ h21Toward->SetStats(kTRUE);
+ h21Toward->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h21Toward->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
+ h21Toward->GetXaxis()->SetTitleColor(1);
+ h21Toward->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h21Toward);
+
+ TProfile * h21Transverse = new TProfile ("histo21_transverse","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
+ h21Transverse->SetStats(kTRUE);
+ h21Transverse->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h21Transverse->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
+ h21Transverse->GetXaxis()->SetTitleColor(1);
+ h21Transverse->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h21Transverse);
+
+ TProfile * h21Away = new TProfile ("histo21_away","N_{chg}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0., 50. , 0., 12. ) ;
+ h21Away->SetStats(kTRUE);
+ h21Away->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h21Away->GetYaxis()->SetTitle("<N_{chg}(in the event - including jet1)> in 1 GeV/c bin");
+ h21Away->GetXaxis()->SetTitleColor(1);
+ h21Away->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h21Away);
+
+ TProfile * h22Toward = new TProfile ("histo22_toward","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
+ h22Toward->SetStats(kTRUE);
+ h22Toward->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h22
Toward->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
+ h22Toward->GetXaxis()->SetTitleColor(1);
+ h22Toward->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h22Toward);
+
+ TProfile * h22Transverse = new TProfile ("histo22_transverse","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
+ h22Transverse->SetStats(kTRUE);
+ h22Transverse->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h22
Transverse->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
+ h22Transverse->GetXaxis()->SetTitleColor(1);
+ h22Transverse->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h22Transverse);
+
+ TProfile * h22Away = new TProfile ("histo22_away","PT_{sum}(in the event - including jet1) vs P_{T}(charged jet1)", 200, 0. , 50. , 0., 50. ) ;
+ h22Away->SetStats(kTRUE);
+ h22Away->GetXaxis()->SetTitle("P_{T} (charged jet1) (GeV/c)");
+ h22
Away->GetYaxis()->SetTitle("<PT_{sum}(in the event - including jet1)> in 1 GeV/c bin");
+ h22Away->GetXaxis()->SetTitleColor(1);
+ h22Away->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h22Away);
+
+ TH1F *h23Toward = new TH1F ("histo23_toward","'Toward' Pt Distribution of charged particles", 200, 0., 14.);
+ h23Toward->SetStats(kTRUE);
+ h23Toward->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
+ h23Toward->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
+ h23Toward->GetXaxis()->SetTitleColor(1);
+ h23Toward->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h23Toward);
+
+ TH1F *h23Transverse = new TH1F ("histo23_transverse","'Transverse' Pt Distribution of charged particles", 200, 0., 14.);
+ h23Transverse->SetStats(kTRUE);
+ h23Transverse->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
+ h23Transverse->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
+ h23Transverse->GetXaxis()->SetTitleColor(1);
+ h23Transverse->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h23Transverse);
+
+ TH1F *h23Away = new TH1F ("histo23_away","'Away' Pt Distribution of charged particles", 200, 0., 14.);
+ h23Away->SetStats(kTRUE);
+ h23Away->GetXaxis()->SetTitle("P_{T} (charged) (GeV/c)");
+ h23Away->GetYaxis()->SetTitle("dN_{chg}/dP_{T} (1/GeV/c)");
+ h23Away->GetXaxis()->SetTitleColor(1);
+ h23Away->SetMarkerStyle(kFullCircle);
+ fHistos->Add(h23Away);
TProfile * h24 = new TProfile ("histo24","Jet1 Size vs P_{T}(charged jet1)", 200, 0., 50. , 0., 0.5) ;
h24->SetStats(kTRUE);
}
-
-//______________________________________________________________________________
-/*
-Jet Algorithm:
- * Order all charged particles according to their PT.
- * Start with the highest PT particle and include in the "jet" all particles within the "radius" R = 0.7
- (considering each particle in the order of decreasing PT and recalculating the centroid of the jet after
- each new particle is added to the jet).
- * Go to the next highest PT particle (not already included in a jet) and include in the "jet" all particles
- (not already included in a jet) within the radius R =0.7.
- * Continue until all particles are in a "jet".
-
-*/
-//______________________________________________________________________________
-
//______________________________________________________________________________
void AliCdfJetFinder::FindJets()
{
+// Jet Algorithm:
+// * Order all charged particles according to their PT.
+// * Start with the highest PT particle and include in the "jet" all particles within the "radius" R = 0.7
+// (considering each particle in the order of decreasing PT and recalculating the centroid of the jet after
+// each new particle is added to the jet).
+// * Go to the next highest PT particle (not already included in a jet) and include in the "jet" all particles
+// (not already included in a jet) within the radius R =0.7.
+// * Continue until all particles are in a "jet".
+ if (fDebug) { printf("AliCDJetfinder::FindJets() %d \n", __LINE__ ); }
AliCdfJetHeader *header = (AliCdfJetHeader*)fHeader;
if (header)
{
- fDebug = header->IsDebugCDF();
+ fDebug = header->GetDebug();
fAODwrite = header->IsAODwrite() ; // write jets to AOD
fAODtracksWrite = header->IsAODtracksWrite() ; // write jet tracks to AOD
fRadius = header->GetRadius(); // get Radius from jet finder header
else
{ cout << "Header not found" << endl; return; }
-// temporary until the other problems are resolved
-fAODwrite = 0 ;
-
if (fAODwrite)
{
fFromAod = !strcmp(fReader->ClassName(),"AliJetAODReader");
if (fFromAod) { fRefArr = fReader->GetReferences(); }
}
-fFromAod = 0 ; // disable for the moment ; only ESD reading for now
-
InitData();
if (!fNPart) { if (fDebug) {cout << "entries = 0 ; Event empty !!!" << endl ;} return; } // if event empty then exit
ComputeConesWeight();
-if (fAODwrite) { cout << "Writing AOD" << endl ; WriteJets(); }
+if (fAODwrite) {
+ if(fDebug)cout << "Writing AOD" << endl ;
+ WriteJets();
+ }
-AnalizeJets();
+if (fAnalyseJets) AnalizeJets();
Clean();
//______________________________________________________________________________
void AliCdfJetFinder::InitData()
{
+// initialisation of variables and data members
TClonesArray * vectArray = fReader->GetMomentumArray() ;
- if ( vectArray == 0 ) { cout << "Could not get the momentum array" << endl; return; }
+ if ( vectArray == 0 ) { cout << "Could not get the momentum array" << endl; return; }
fNPart = vectArray->GetEntries() ; // n particles in this event;
if ( fNPart == 0 ) { return ; } // if event empty then exit
- fJets->SetNinput ( fNPart ) ; // number of input objects
-
fVectParticle = new varContainer* [fNPart]; // container for Particles
- fVectJet = new varContainer* [fNPart]; // container for Jets
fPtArray = new Double_t [fNPart] ; // momentum array
fIdxArray = new Int_t [fNPart] ; // index array of sorted pts
varContainer *aParticle = new varContainer;
aParticle->pt = lv->Pt();
aParticle->eta = lv->Eta();
- aParticle->phi = DeltaPhiNorm ( lv->Phi() ); // normalize to -pi,pi
+ aParticle->phi = TVector2::Phi_mpi_pi ( lv->Phi() ); // normalize to -pi,pi
aParticle->njet = -999;
fVectParticle[i] = aParticle; // vector of Particles
//______________________________________________________________________________
void AliCdfJetFinder::FindCones()
{
- Double_t pt_seed = 0. , eta_seed = 0. , phi_seed = 0. ; // leading particle params
- Double_t pt_tmp = 0. , eta_tmp = 0. , phi_tmp = 0. ; // temporary variables to be used in various calculations
- Double_t deta = 0. , dphi = 0. , d_computed = 0. ;
- Bool_t in_jet = 0 ;
+// parsing of particles in event and estlabish jets (label them with jet index)
+
+ Double_t ptSeed = 0. , etaSeed = 0. , phiSeed = 0. ; // leading particle params
+ Double_t pttmp = 0. , etatmp = 0. , phitmp = 0. ; // temporary variables to be used in various calculations
+ Double_t deta = 0. , dphi = 0. , dcomputed = 0. ;
+ Bool_t injet = 0 ;
fNJets = -1 ; // n jets in this event
Int_t idxPtSort = -1 ; // index of array of sorted pt indexes
if (fDebug) { cout << "\n\n\n\n\n\n------------------\nBegin Event Analysis\n------------------\n\n" << endl ;}
- cout << "fNPart = " << fNPart << endl;
+ if(fDebug)cout << "fNPart = " << fNPart << endl;
- TBits lkup_table ( fNPart ) ; // bit container ; 1-to-1 corespondence with fIdxArray
+ TBits lkupTable ( fNPart ) ; // bit container ; 1-to-1 corespondence with fIdxArray
- while ( lkup_table.CountBits() != (UInt_t)fNPart )
+ while ( lkupTable.CountBits() != (UInt_t)fNPart )
{ // loop over particles in event until all flags are set
- UInt_t first_non_flagged = lkup_table.FirstNullBit() ; // set the index to the first NON flagged bit ; less conditions
+ UInt_t firstnonflagged = lkupTable.FirstNullBit() ; // set the index to the first NON flagged bit ; less conditions
- cout << "\n\nfirst_non_flagged : " << first_non_flagged << endl;
+ if(fDebug)cout << "\n\nfirst_non_flagged : " << firstnonflagged << endl;
++fNJets; // incrementing the jet counter
if (fDebug) { printf("JET %d \n", fNJets); }
- pt_seed = 0. ; eta_seed = 0. ; phi_seed = 0. ; // reseting leading particle params
+ ptSeed = 0. ; etaSeed = 0. ; phiSeed = 0. ; // reseting leading particle params
- for ( UInt_t i_part = first_non_flagged ; i_part < (UInt_t)fNPart ; i_part++ )
+ for ( UInt_t ipart = firstnonflagged ; ipart < (UInt_t)fNPart ; ipart++ )
{// iteration over particles in event
// the loop is done over sorted array of pt
- idxPtSort = fIdxArray[i_part] ; // index of particle ! fIdxArray is an index list pt sorted
+ idxPtSort = fIdxArray[ipart] ; // index of particle ! fIdxArray is an index list pt sorted
- if ( lkup_table.TestBitNumber(i_part) ) { continue; } // if 4vector is already flagged skip it
+ if ( lkupTable.TestBitNumber(ipart) ) { continue; } // if 4vector is already flagged skip it
//init computed and used vars
- pt_tmp = 0. ; eta_tmp = 0. ; phi_tmp = 0. ;
- deta = 0. ; dphi = 0. ; d_computed = 0. ; in_jet = 0 ;
+ pttmp = 0. ; etatmp = 0. ; phitmp = 0. ;
+ deta = 0. ; dphi = 0. ; dcomputed = 0. ; injet = 0 ;
//taking info from fVectParticle ;
- pt_tmp = fVectParticle[idxPtSort]->pt ;
- eta_tmp = fVectParticle[idxPtSort]->eta ;
- phi_tmp = fVectParticle[idxPtSort]->phi ;
+ pttmp = fVectParticle[idxPtSort]->pt ;
+ etatmp = fVectParticle[idxPtSort]->eta ;
+ phitmp = fVectParticle[idxPtSort]->phi ;
- if ( i_part == first_non_flagged )
+ if ( ipart == firstnonflagged )
{// this is first particle in event; leading particle
// begin the search around this particle in a fRadius
// CENTRE OF THE JET
- pt_seed = pt_tmp ; eta_seed = eta_tmp ; phi_seed = phi_tmp ; // seeding the jet with first particle idxPtSort
+ ptSeed = pttmp ; etaSeed = etatmp ; phiSeed = phitmp ; // seeding the jet with first particle idxPtSort
- lkup_table.SetBitNumber ( i_part ) ; // flag the index of particle in lkup_table
+ lkupTable.SetBitNumber ( ipart ) ; // flag the index of particle in lkup_table
fVectParticle[idxPtSort]->njet = fNJets ; // associate particle with current jet number
- if (fDebug) { printf("\nLeading particle :: particle index = %d ; at sorted index %d ; in jet %d \n", idxPtSort, i_part, fNJets); }
- if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pt_tmp, eta_tmp, phi_tmp) ; }
- if (fDebug) { lkup_table.Print() ;}
+ if (fDebug) { printf("\nLeading particle :: particle index = %d ; at sorted index %d ; in jet %d \n", idxPtSort, ipart, fNJets); }
+ if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
+ if (fDebug) { lkupTable.Print() ;}
continue ; // skip to next particle
}
// condition to be in jet
- deta = eta_tmp - eta_seed ;
- dphi = DeltaPhiNorm ( phi_tmp - phi_seed ) ; // computing dphi and normalizing to (0,2pi) interval in one step
+ deta = etatmp - etaSeed ;
+ dphi = TVector2::Phi_mpi_pi (phitmp - phiSeed) ; // computing dphi and normalizing to (0,2pi) interval in one step
- d_computed = Distance (deta, dphi) ; // Distance(fRadius) to (eta,phi) seed
+ dcomputed = TMath::Hypot(deta, dphi) ; // Distance(fRadius) to (eta,phi) seed
- in_jet = ( ( fRadius - d_computed ) >= 0.000000001 ) ? 1 : 0 ; // if r_computed is within jet_r in_jet == 1 else 0
+ injet = ( ( fRadius - dcomputed ) >= 0.000000001 ) ? 1 : 0 ; // if r_computed is within jet_r in_jet == 1 else 0
- if ( in_jet )
+ if ( injet )
{ // calculus of jet variables
- lkup_table.SetBitNumber ( i_part ) ; // flag the index of particle in lkup_table
+ lkupTable.SetBitNumber ( ipart ) ; // flag the index of particle in lkup_table
fVectParticle[idxPtSort]->njet = fNJets ; // setting in particle list the associated jet
- if (fDebug) { printf("\njet particle :: particle index = %d ; at sorted index %d ; in jet %d ; found at radius %g ; \n", idxPtSort, i_part, fNJets, d_computed); }
- if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pt_tmp, eta_tmp, phi_tmp) ; }
- if (fDebug) { lkup_table.Print() ;}
+ if (fDebug) { printf("\njet particle :: particle index = %d ; at sorted index %d ; in jet %d ; found at radius %g ; \n", idxPtSort, ipart, fNJets, dcomputed); }
+ if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
+ if (fDebug) { lkupTable.Print() ;}
continue ; // skip to next particle
}
//______________________________________________________________________________
void AliCdfJetFinder::ComputeConesWeight()
{
-/*
- CALCULUS OF JETS Pt, Eta and Phi (centre of weight in (eta,phi) plane)
-*/
- // rescan the vector of particles by identify them by asociate jet number for computing of weight centre
- // we know : fNJets = the number of jets
+// computing of jets Pt, Eta and Phi (centre of weight in (eta,phi) plane)
+// rescan the vector of particles by identify them by asociate jet number for computing of weight centre
+
+// JET CONTAINER
+fVectJet = new varContainer* [fNJets]; // container for Jets
-Double_t pt_jet , eta_jet , phi_jet ; Int_t npartJet ;
-Double_t pt_tmp = 0. , eta_tmp = 0. , phi_tmp = 0. ; // temporary variables to be used in various calculations
+Double_t ptJet, ptJet2 , etaJet , phiJet ; Int_t npartJet ;
+Double_t pttmp = 0. , etatmp = 0. , phitmp = 0. ; // temporary variables to be used in various calculations
Int_t idxPtSort = -999 ; // index of array of sorted pt indexes
for( Int_t jet = 0 ; jet < fNJets ; jet++ )
{
if (fDebug) { printf("\n\n--- Computing weight of Jet %d \n", jet ); }
- npartJet = 0 ; pt_jet = 0. ; eta_jet = 0. ; phi_jet = 0. ; // reset variables for a new computation
+ npartJet = 0 ; ptJet = 0. ; etaJet = 0. ; phiJet = 0. ; // reset variables for a new computation
- for ( Int_t i_part = 0 ; i_part < fNPart ; i_part++ )
+ for ( Int_t ipart = 0 ; ipart < fNPart ; ipart++ )
{// iteration over particles in event
// the loop is done over sorted array of pt
- idxPtSort = fIdxArray[i_part] ; // index of particle ! fIdxArray is an index list pt sorted
+ idxPtSort = fIdxArray[ipart] ; // index of particle ! fIdxArray is an index list pt sorted
if ( fVectParticle[idxPtSort]->njet == jet )
{
++npartJet; // incrementing the counter of jet particles
//taking info from fVectParticle ;
- pt_tmp = fVectParticle[idxPtSort]->pt ;
- eta_tmp = fVectParticle[idxPtSort]->eta ;
- phi_tmp = DeltaPhiNorm ( fVectParticle[idxPtSort]->phi ) ;
+ pttmp = fVectParticle[idxPtSort]->pt ;
+ etatmp = fVectParticle[idxPtSort]->eta ;
+ phitmp = TVector2::Phi_mpi_pi (fVectParticle[idxPtSort]->phi) ;
+
+// jet_new_angular_coordinate = jet_old_angular_coordinate * jet_old_pt / jet_new_pt +
+// part[i]_angular_coordinate * part[i]_pt/jet_new_pt
+
+ ptJet2 = ptJet + pttmp ;
- pt_jet += pt_tmp ;
- eta_jet = ( (pt_jet*eta_jet) + (pt_tmp*eta_tmp) )/(pt_jet + pt_tmp) ;
- phi_jet = ( (pt_jet*phi_jet) + (pt_tmp*phi_tmp) )/(pt_jet + pt_tmp) ;
+ etaJet = etaJet * ptJet / ptJet2 + etatmp * pttmp / ptJet2 ;
+ phiJet = phiJet * ptJet / ptJet2 + phitmp * pttmp / ptJet2 ;
+
+ ptJet = ptJet2 ;
}
// add a particle and recalculation of centroid
// end of 1 jet computation
varContainer *aJet = new varContainer; // Jet container
- aJet->pt = pt_jet; aJet->eta = eta_jet; aJet->phi = phi_jet; aJet->njet = npartJet; // setting jet vars in container
+ aJet->pt = ptJet; aJet->eta = etaJet; aJet->phi = phiJet; aJet->njet = npartJet; // setting jet vars in container
fVectJet[jet] = aJet; // store the number of the jet(fNJets) and increment afterwards
if (fDebug) { printf ("=== current jet %d : npartjet= %d ; pt_jet= %g ; eta_jet = %g ; phi_jet = %g \n\n\n",
- jet, npartJet, pt_jet, eta_jet, phi_jet ) ; }
+ jet, npartJet, ptJet, etaJet, phiJet ) ; }
}
//end loop over jets
//______________________________________________________________________________
-void AliCdfJetFinder::WriteJets()
-{ // Writing AOD jets and AOD tracks
-
-/* for( Int_t jet_nr = 0 ; jet_nr < fNJets ; jet_nr++ )
- {
- Double_t pt = 0., eta = 0., phi = 0., // jet variables
- px = 0., py = 0., pz = 0., en = 0.; // convert to 4-vector
- pt = fVectJet[ jet_nr ]->pt ; // pt of jet
- eta = fVectJet[ jet_nr ]->eta ; // eta of jet
- phi = fVectJet[ jet_nr ]->phi ; // phi of jet
+void AliCdfJetFinder::WriteJets()
+{
+// Writing AOD jets and AOD tracks
- px = pt * TMath::Cos ( phi ) ;
- py = pt * TMath::Sin ( phi ) ;
- pz = pt / TMath::Tan ( 2.0 * TMath::ATan ( TMath::Exp ( -eta ) ) ) ;
- en = TMath::Sqrt ( px * px + py * py + pz * pz );
+for( Int_t jetnr = 0 ; jetnr < fNJets ; jetnr++ )
+ {
+ Double_t pt = 0., eta = 0., phi = 0., // jet variables
+ px = 0., py = 0., pz = 0., en = 0.; // convert to 4-vector
+ pt = fVectJet[ jetnr ]->pt ; // pt of jet
+ eta = fVectJet[ jetnr ]->eta ; // eta of jet
+ phi = fVectJet[ jetnr ]->phi ; // phi of jet
- AliAODJet jet (px, py, pz, en);
- AddJet(jet);
+ px = pt * TMath::Cos ( phi ) ;
+ py = pt * TMath::Sin ( phi ) ;
+ pz = pt / TMath::Tan ( 2.0 * TMath::ATan ( TMath::Exp ( -eta ) ) ) ;
+ en = TMath::Sqrt ( px * px + py * py + pz * pz );
- if (fDebug) jet.Print("");
+ AliAODJet jet (px, py, pz, en);
- if (fromAod && AODtracksWrite)
- {
- for ( Int_t jet_track = 0; jet_track < fNPart; jet_track++ )
- { if ( fVectParticle[jet_track]->njet == jet_nr ) { jet.AddTrack(refs->At(jet_track)) ; } }
- }
- // tracks REFs written in AOD
- }*/
+ if (fDebug) jet.Print("");
+ if (fFromAod && fAODtracksWrite)
+ {
+ for ( Int_t jetTrack = 0; jetTrack < fNPart; jetTrack++ )
+ { if ( fVectParticle[jetTrack]->njet == jetnr ) { jet.AddTrack(fRefArr->At(jetTrack)) ; } }
+ }
+ // tracks REFs written in AOD
+ AddJet(jet);
+ }
//jets vector parsed and written to AOD
-
}
//______________________________________________________________________________
void AliCdfJetFinder::AnalizeJets()
- {
+{
+// analyzing of jets and filling of histograms
+ const Double_t kPI = TMath::Pi();
+
//persistent pointer to histo20
- TH1F *h_r = (TH1F*)fHistos->FindObject("histo20");
+ TH1F *hR = (TH1F*)fHistos->FindObject("histo20");
- Int_t *jets_pt_idx = 0; // sorted array of jets pt
- Double_t *jets_pt = 0; // array of jets pts
- Int_t leading_jet_index = -1 ; // index of leading jet from fVectJet
- Int_t part_leadjet = 0 ; // number of particles in leading jet
- Double_t pt_leadjet = 0. ; // pt of leading jet
- Double_t eta_leadjet = 0. ; // eta of leading jet
- Double_t phi_leadjet = 0. ; // phi of leading jet
+ Int_t *jetsptidx = 0; // sorted array of jets pt
+ Double_t *jetspt = 0; // array of jets pts
+ Int_t leadingjetindex = -1 ; // index of leading jet from fVectJet
+ Int_t partleadjet = 0 ; // number of particles in leading jet
+ Double_t ptleadjet = 0. ; // pt of leading jet
+ Double_t etaleadjet = 0. ; // eta of leading jet
+ Double_t phileadjet = 0. ; // phi of leading jet
- jets_pt_idx = new Int_t [fNJets] ;
- jets_pt = new Double_t [fNJets] ;
+ jetsptidx = new Int_t [fNJets] ;
+ jetspt = new Double_t [fNJets] ;
//________________________________________________________________________________________
// Jet sorting and finding the leading jet that coresponds to cuts in pt and multiplicity
if (fDebug) printf("List of unsorted jets:\n");
for( Int_t i = 0 ; i < fNJets ; i++ )
{
- jets_pt_idx [i] = 0 ;
- jets_pt [i] = fVectJet[i]->pt ;
- if (fDebug) { cout << " jet found: " << i << " npartjet=" << fVectJet[i]->njet << " ; jets_pt = " << jets_pt[i] << endl; }
+ jetsptidx [i] = 0 ;
+ jetspt [i] = fVectJet[i]->pt ;
+ if (fDebug) { cout << " jet found: " << i << " npartjet=" << fVectJet[i]->njet << " ; jets_pt = " << jetspt[i] << endl; }
}
- TMath::Sort ( fNJets, jets_pt , jets_pt_idx ) ; // sorting pt of jets
+ TMath::Sort ( fNJets, jetspt , jetsptidx ) ; // sorting pt of jets
// selection of leading jet
// looping over jets searching for __first__ one that coresponds to cuts
for( Int_t i = 0 ; i < fNJets ; i++ )
{
- if ( ( fVectJet[ jets_pt_idx[i] ]->njet >= fMinJetParticles ) && ( fVectJet[ jets_pt_idx[i] ]->pt >= fJetPtCut ) )
+ if ( ( fVectJet[ jetsptidx[i] ]->njet >= fMinJetParticles ) && ( fVectJet[ jetsptidx[i] ]->pt >= fJetPtCut ) )
{
- leading_jet_index = jets_pt_idx[i] ;
- part_leadjet = fVectJet[ leading_jet_index ]->njet ; // number of particles in leading jet
- pt_leadjet = fVectJet[ leading_jet_index ]->pt ; // pt of leading jet
- eta_leadjet = fVectJet[ leading_jet_index ]->eta ; // eta of leading jet
- phi_leadjet = fVectJet[ leading_jet_index ]->phi ; // phi of leading jet
+ leadingjetindex = jetsptidx[i] ;
+ partleadjet = fVectJet[ leadingjetindex ]->njet ; // number of particles in leading jet
+ ptleadjet = fVectJet[ leadingjetindex ]->pt ; // pt of leading jet
+ etaleadjet = fVectJet[ leadingjetindex ]->eta ; // eta of leading jet
+ phileadjet = fVectJet[ leadingjetindex ]->phi ; // phi of leading jet
if (fDebug)
- { printf("Leading jet %d : npart= %d ; pt= %g ; eta = %g ; phi = %g \n", leading_jet_index, part_leadjet, pt_leadjet, eta_leadjet, phi_leadjet ); }
+ { printf("Leading jet %d : npart= %d ; pt= %g ; eta = %g ; phi = %g \n", leadingjetindex, partleadjet, ptleadjet, etaleadjet, phileadjet ); }
break ;
}
// pt_sum of all particles in event
//___________________________________________________________________________
cout << "Computing sum of pt in event" << endl ;
-Double_t pt_sum_event = 0.;
-for ( Int_t i = 0 ; i< fNPart ; i++ ) { pt_sum_event += fVectParticle[i]->pt ; }
-printf ("Sum of all Pt in event : pt_sum_event = %g", pt_sum_event) ;
+Double_t ptsumevent = 0.;
+for ( Int_t i = 0 ; i< fNPart ; i++ ) { ptsumevent += fVectParticle[i]->pt ; }
+printf ("Sum of all Pt in event : pt_sum_event = %g", ptsumevent) ;
//___________________________________________________________________________
// Filling an array with indexes of leading jet particles
//___________________________________________________________________________
-Int_t * idx_leadjet_part = new Int_t [part_leadjet] ;
-Int_t counter_part_lead_jet = 0;
+Int_t * idxpartLJ = new Int_t [partleadjet] ;
+Int_t counterpartleadjet = 0;
cout << "Filling an array with indexes of leading jet particles" << endl;
for( Int_t i = 0 ; i < fNPart ; i++ )
{
- if ( fVectParticle[i]->njet == leading_jet_index )
- { idx_leadjet_part[counter_part_lead_jet++] = i ; }
+ if ( fVectParticle[i]->njet == leadingjetindex )
+ { idxpartLJ[counterpartleadjet++] = i ; }
}
-if ( (counter_part_lead_jet-1) > part_leadjet ) { cout << " Counter_part_lead_jet > part_leadjet !!!!" << endl;}
+if ( (counterpartleadjet-1) > partleadjet ) { cout << " Counter_part_lead_jet > part_leadjet !!!!" << endl;}
//___________________________________________________________________________
// Calculus of part distribution in leading jet
//___________________________________________________________________________
Double_t z = 0. ;
-Double_t *z_part_ljet = new Double_t [ part_leadjet ] ; // array of z of particles in leading jet
+Double_t *zpartljet = new Double_t [ partleadjet ] ; // array of z of particles in leading jet
cout << "Entering loop of calculus of part distribution in leading jet" << endl ;
-for( Int_t j = 0 ; j < part_leadjet ; j++ )
+for( Int_t j = 0 ; j < partleadjet ; j++ )
{
- Double_t z_j = fVectParticle[idx_leadjet_part[j]]->pt ;
- z = z_j / pt_leadjet ;
- z_part_ljet [j] = z ;
- cout << "idx_leadjet_part[j] = " << idx_leadjet_part[j]
- << " p of particle = " << z_j
- << " pt lead jet = " << pt_leadjet
+ Double_t zj = fVectParticle[idxpartLJ[j]]->pt ;
+ z = zj / ptleadjet ;
+ zpartljet [j] = z ;
+ cout << "idx_leadjet_part[j] = " << idxpartLJ[j]
+ << " p of particle = " << zj
+ << " pt lead jet = " << ptleadjet
<< " Z = " << z << endl;
}
// array of delta phi's between phi of particles and leading jet phi
//___________________________________________________________________________
cout << "array of delta phi's between phi of particles and leading jet phi" << endl;
-Double_t dphi_partLJ = 0. ;
-Double_t *dphi_part_ljet = new Double_t [fNPart];
+Double_t dphipartLJ = 0. ;
+Double_t *dphipartljet = new Double_t [fNPart];
for( Int_t part = 0 ; part < fNPart ; part++ )
{
- dphi_partLJ = fVectParticle[part]->phi - phi_leadjet ;
- dphi_partLJ = DeltaPhiNorm (dphi_partLJ) ; // restrict the delta phi to (0,pi) interval
- dphi_part_ljet [part] = dphi_partLJ ;
- printf("part= %d ; dphi_partLJ = %g \n", part, dphi_partLJ );
+ dphipartLJ = fVectParticle[part]->phi - phileadjet ;
+ dphipartLJ = TVector2::Phi_mpi_pi (dphipartLJ) ; // restrict the delta phi to (-pi,pi) interval
+ dphipartljet [part] = dphipartLJ ;
+ printf("part= %d ; dphi_partLJ = %g \n", part, dphipartLJ );
}
//______________________________________________________________________________
// Pt distribution for all particles
//______________________________________________________________________________
-TH1F * h_pt = (TH1F*)fHistos->FindObject("histo11");
-if ( h_pt ) { for ( Int_t i = 0 ; i < fNPart ; i++ ) { h_pt->Fill( fVectParticle[i]->pt ); } }
+TH1F * hpt = (TH1F*)fHistos->FindObject("histo11");
+if ( hpt ) { for ( Int_t i = 0 ; i < fNPart ; i++ ) { hpt->Fill( fVectParticle[i]->pt ); } }
//___________________________________________________________________________
// Recomputing of radius of particles in leading jet
//___________________________________________________________________________
-if (fDebug) { printf(" Searching particles with jet index %d\n", leading_jet_index); }
+if (fDebug) { printf(" Searching particles with jet index %d\n", leadingjetindex); }
-Double_t ddeta = 0. , ddphi = 0. , r_part = 0. ;
+Double_t ddeta = 0. , ddphi = 0. , rpart = 0. ;
-for( Int_t j = 0 ; j < part_leadjet ; j++ )
+for( Int_t j = 0 ; j < partleadjet ; j++ )
{
- ddeta = eta_leadjet - fVectParticle[idx_leadjet_part[j]]->eta;
+ ddeta = etaleadjet - fVectParticle[idxpartLJ[j]]->eta;
- Double_t phi_tmp = fVectParticle[idx_leadjet_part[j]]->phi ;
- phi_tmp = DeltaPhiNorm (phi_tmp);
+ Double_t phitmp = fVectParticle[idxpartLJ[j]]->phi ;
- ddphi = DeltaPhiNorm ( phi_leadjet - phi_tmp ) ; // restrict the delta phi to (-pi,pi) interval
+ ddphi = TVector2::Phi_mpi_pi ( phileadjet - phitmp ) ; // restrict the delta phi to (-pi,pi) interval
- r_part = Distance (ddeta, ddphi) ;
+ rpart = TMath::Hypot (ddeta, ddphi) ;
- printf ("Particle %d with Re-Computed radius = %f ", idx_leadjet_part[j], r_part) ;
- if ( (r_part - fRadius) >= 0.00000001 )
+ printf ("Particle %d with Re-Computed radius = %f ", idxpartLJ[j], rpart) ;
+ if ( (rpart - fRadius) >= 0.00000001 )
{ printf (" bigger than selected radius of %f\n", fRadius ); }
else
{ printf ("\n") ; }
- if (h_r) h_r->Fill(r_part);
+ if (hR) hR->Fill(rpart);
}
//_______________________________________________________________________
// Computing of radius that contain 80% of Leading Jet ( PT and multiplicity )
//_______________________________________________________________________
-Double_t core_part_leadjet = 0.8 * part_leadjet ;
-Double_t core_pt_leadjet = 0.8 * pt_leadjet ;
-Int_t counter_core_part = 0 ;
-Double_t counter_core_pt = 0. ;
-Int_t sorted_index = -1 ;
+Double_t corepartleadjet = 0.8 * partleadjet ;
+Double_t coreptleadjet = 0.8 * ptleadjet ;
+Int_t countercorepart = 0 ;
+Double_t countercorept = 0. ;
+Int_t sortedindex = -1 ;
-TProfile * h_prof_24 = (TProfile*)fHistos->FindObject("histo24");
-TProfile * h_prof_25 = (TProfile*)fHistos->FindObject("histo25");
+TProfile * hprof24 = (TProfile*)fHistos->FindObject("histo24");
+TProfile * hprof25 = (TProfile*)fHistos->FindObject("histo25");
-TProfile * h_prof_26 = (TProfile*)fHistos->FindObject("histo26");
-TProfile * h_prof_27 = (TProfile*)fHistos->FindObject("histo27");
-TProfile * h_prof_28 = (TProfile*)fHistos->FindObject("histo28");
-TProfile * h_prof_29 = (TProfile*)fHistos->FindObject("histo29");
+TProfile * hprof26 = (TProfile*)fHistos->FindObject("histo26");
+TProfile * hprof27 = (TProfile*)fHistos->FindObject("histo27");
+TProfile * hprof28 = (TProfile*)fHistos->FindObject("histo28");
+TProfile * hprof29 = (TProfile*)fHistos->FindObject("histo29");
-if ((h_prof_24) && (h_prof_25) && (h_prof_26) && (h_prof_27) && (h_prof_28) && (h_prof_29) )
+if ((hprof24) && (hprof25) && (hprof26) && (hprof27) && (hprof28) && (hprof29) )
{
for( Int_t part = 0 ; part < fNPart ; part++ )
{
- Double_t pt_tmp = 0. ; Double_t eta_tmp = 0. ; Double_t phi_tmp = 0. ; // temporary variables
- Double_t d_part = 0. ;
- sorted_index = fIdxArray[part] ;
+ Double_t pttmp = 0. ; Double_t etatmp = 0. ; Double_t phitmp = 0. ; // temporary variables
+ Double_t dpart = 0. ;
+ sortedindex = fIdxArray[part] ;
- if ( fVectParticle [ sorted_index ]->njet == leading_jet_index )
+ if ( fVectParticle [ sortedindex ]->njet == leadingjetindex )
{
- pt_tmp = fVectParticle[sorted_index]->pt ;
- eta_tmp = fVectParticle[sorted_index]->eta ;
- phi_tmp = fVectParticle[sorted_index]->phi ;
+ pttmp = fVectParticle[sortedindex]->pt ;
+ etatmp = fVectParticle[sortedindex]->eta ;
+ phitmp = fVectParticle[sortedindex]->phi ;
- ++counter_core_part ;
- counter_core_pt += pt_tmp ;
+ ++countercorepart ;
+ countercorept += pttmp ;
- d_part = Distance ( eta_leadjet - eta_tmp, phi_leadjet - phi_tmp ) ;
+ dpart = TMath::Hypot ( etaleadjet - etatmp, TVector2::Phi_mpi_pi (phileadjet - phitmp) ) ;
- if ( counter_core_part <= core_part_leadjet ) { h_prof_24->Fill(pt_leadjet, d_part); }
- if ( counter_core_pt <= core_pt_leadjet ) { h_prof_25->Fill(pt_leadjet, d_part); }
+ if ( countercorepart <= corepartleadjet ) { hprof24->Fill(ptleadjet, dpart); }
+ if ( countercorept <= coreptleadjet ) { hprof25->Fill(ptleadjet, dpart); }
- if (pt_leadjet > 5.) { h_prof_26->Fill(d_part, counter_core_part); h_prof_28->Fill(d_part, counter_core_pt); }
- if (pt_leadjet > 30.) { h_prof_27->Fill(d_part, counter_core_part); h_prof_29->Fill(d_part, counter_core_pt); }
+ if (ptleadjet > 5.) { hprof26->Fill(dpart, countercorepart); hprof28->Fill(dpart, countercorept); }
+ if (ptleadjet > 30.) { hprof27->Fill(dpart, countercorepart); hprof29->Fill(dpart, countercorept); }
}
}
}
-
-
-
-
-
-
-
-
-
- TH1F *h_jet_pt = (TH1F*)fHistos->FindObject("histo1");
- TH1F *h_jet_eta = (TH1F*)fHistos->FindObject("histo2");
- TH1F *h_jet_phi = (TH1F*)fHistos->FindObject("histo3");
- TH1F *h_jet_njet = (TH1F*)fHistos->FindObject("histo4");
+ TH1F *hjetpt = (TH1F*)fHistos->FindObject("histo1");
+ TH1F *hjeteta = (TH1F*)fHistos->FindObject("histo2");
+ TH1F *hjetphi = (TH1F*)fHistos->FindObject("histo3");
+ TH1F *hjetnjet = (TH1F*)fHistos->FindObject("histo4");
for( Int_t jet = 0 ; jet < fNJets ; jet++ )
{
- if (h_jet_pt) h_jet_pt ->Fill ( fVectJet[ jet ]->pt ) ;
- if (h_jet_eta) h_jet_eta ->Fill ( fVectJet[ jet ]->eta ) ;
- if (h_jet_phi) h_jet_phi ->Fill ( fVectJet[ jet ]->phi ) ;
- if (h_jet_njet) h_jet_njet ->Fill ( fVectJet[ jet ]->njet ) ;
+ if (hjetpt) hjetpt ->Fill ( fVectJet[jet]->pt ) ;
+ if (hjeteta) hjeteta ->Fill ( fVectJet[jet]->eta ) ;
+ if (hjetphi) hjetphi ->Fill ( fVectJet[jet]->phi ) ;
+ if (hjetnjet) hjetnjet ->Fill ( fVectJet[jet]->njet ) ;
}
- TH1F *h_jets = (TH1F*)fHistos->FindObject("histo5");
- if (h_jets) h_jets->Fill(fNJets);
+ TH1F *hjets = (TH1F*)fHistos->FindObject("histo5");
+ if (hjets) hjets->Fill(fNJets);
- TH1F *h_leadpart = (TH1F*)fHistos->FindObject("histo6");
- if (h_leadpart) h_leadpart->Fill(part_leadjet);
+ TH1F *hleadpart = (TH1F*)fHistos->FindObject("histo6");
+ if (hleadpart) hleadpart->Fill(partleadjet);
- TProfile * h_prof = (TProfile*)fHistos->FindObject("histo7");
- if (h_prof) h_prof->Fill(pt_leadjet,part_leadjet);
+ TProfile * hprof = (TProfile*)fHistos->FindObject("histo7");
+ if (hprof) hprof->Fill(ptleadjet,partleadjet);
- TH1F *h_MD = (TH1F*)fHistos->FindObject("histo8");
- for( Int_t k = 0 ; k < part_leadjet ; k++)
- { h_MD->Fill( z_part_ljet[k] ); }
+ TH1F *hMD = (TH1F*)fHistos->FindObject("histo8");
+ for( Int_t k = 0 ; k < partleadjet ; k++)
+ { hMD->Fill( zpartljet[k] ); }
- TProfile * h_phi = (TProfile*)fHistos->FindObject("histo9");
- for( Int_t k = 0 ; k < part_leadjet ; k++)
- { h_phi->Fill( TMath::RadToDeg() * dphi_part_ljet [k] , fNPart ) ; }
+ TProfile * hphi = (TProfile*)fHistos->FindObject("histo9");
+ for( Int_t k = 0 ; k < partleadjet ; k++)
+ { hphi->Fill( TMath::RadToDeg() * dphipartljet [k] , fNPart ) ; }
- TProfile * h_tpd = (TProfile*)fHistos->FindObject("histo10");
+ TProfile * htpd = (TProfile*)fHistos->FindObject("histo10");
for( Int_t k = 0 ; k < fNPart ; k++)
- { h_tpd->Fill( TMath::RadToDeg() * dphi_part_ljet [k] , pt_sum_event ) ; }
+ { htpd->Fill( TMath::RadToDeg() * dphipartljet [k] , ptsumevent ) ; }
- TProfile * h_prof1 = (TProfile*)fHistos->FindObject("histo21");
- if (h_prof1) h_prof1->Fill(pt_leadjet, fNPart);
+ TProfile * hprof1 = (TProfile*)fHistos->FindObject("histo21");
+ if (hprof1) hprof1->Fill(ptleadjet, fNPart);
- TProfile * h_prof2 = (TProfile*)fHistos->FindObject("histo22");
- if (h_prof2) h_prof2->Fill(pt_leadjet, pt_sum_event);
+ TProfile * hprof2 = (TProfile*)fHistos->FindObject("histo22");
+ if (hprof2) hprof2->Fill(ptleadjet, ptsumevent);
- TProfile * h_prof1_toward = (TProfile*)fHistos->FindObject("histo21_toward");
- TProfile * h_prof1_transverse = (TProfile*)fHistos->FindObject("histo21_transverse");
- TProfile * h_prof1_away = (TProfile*)fHistos->FindObject("histo21_away");
- TProfile * h_prof2_toward = (TProfile*)fHistos->FindObject("histo22_toward");
- TProfile * h_prof2_transverse = (TProfile*)fHistos->FindObject("histo22_transverse");
- TProfile * h_prof2_away = (TProfile*)fHistos->FindObject("histo22_away");
- TH1F * h_pt_toward = (TH1F*)fHistos->FindObject("histo23_toward");
- TH1F * h_pt_transverse = (TH1F*)fHistos->FindObject("histo23_transverse");
- TH1F * h_pt_away = (TH1F*)fHistos->FindObject("histo23_away");
+ TProfile * hprof1toward = (TProfile*)fHistos->FindObject("histo21_toward");
+ TProfile * hprof1transverse = (TProfile*)fHistos->FindObject("histo21_transverse");
+ TProfile * hprof1away = (TProfile*)fHistos->FindObject("histo21_away");
+ TProfile * hprof2toward = (TProfile*)fHistos->FindObject("histo22_toward");
+ TProfile * hprof2transverse = (TProfile*)fHistos->FindObject("histo22_transverse");
+ TProfile * hprof2away = (TProfile*)fHistos->FindObject("histo22_away");
+ TH1F * hpttoward = (TH1F*)fHistos->FindObject("histo23_toward");
+ TH1F * hpttransverse = (TH1F*)fHistos->FindObject("histo23_transverse");
+ TH1F * hptaway = (TH1F*)fHistos->FindObject("histo23_away");
-
-
- if ( (h_prof1_toward) && (h_prof1_transverse) && (h_prof1_away) && (h_prof2_toward) && (h_prof2_transverse) && (h_prof2_away) )
+ if ( (hprof1toward) && (hprof1transverse) && (hprof1away) && (hprof2toward) && (hprof2transverse) && (hprof2away) )
{
for( Int_t part = 0 ; part < fNPart ; part++)
{
- Double_t pt_part = fVectParticle[part]->pt ; // pt of particle
- if ( ( dphi_part_ljet[part] >=0.) && ( dphi_part_ljet[part] < pi/3. ) )
+ Double_t ptpart = fVectParticle[part]->pt ; // pt of particle
+ if ( ( dphipartljet[part] >=0.) && ( dphipartljet[part] < kPI/3. ) )
{
- h_prof1_toward->Fill( pt_leadjet, fNPart );
- h_prof2_toward->Fill( pt_leadjet, pt_sum_event);
- h_pt_toward->Fill( pt_part );
+ hprof1toward->Fill( ptleadjet, fNPart );
+ hprof2toward->Fill( ptleadjet, ptsumevent);
+ hpttoward->Fill( ptpart );
}
else
- if ( ( dphi_part_ljet[part] >= (pi/3.)) && ( dphi_part_ljet[part] < (2.*pi/3.)) )
+ if ( ( dphipartljet[part] >= (kPI/3.)) && ( dphipartljet[part] < (2.*kPI/3.)) )
{
- h_prof1_transverse->Fill( pt_leadjet, fNPart );
- h_prof2_transverse->Fill( pt_leadjet, pt_sum_event);
- h_pt_transverse->Fill( pt_part );
+ hprof1transverse->Fill( ptleadjet, fNPart );
+ hprof2transverse->Fill( ptleadjet, ptsumevent);
+ hpttransverse->Fill( ptpart );
}
else
- if ( ( dphi_part_ljet[part] >= ( 2.*pi/3.)) && ( dphi_part_ljet[part] < pi ) )
+ if ( ( dphipartljet[part] >= ( 2.*kPI/3.)) && ( dphipartljet[part] < kPI ) )
{
- h_prof1_away->Fill( pt_leadjet, fNPart );
- h_prof2_away->Fill( pt_leadjet, pt_sum_event);
- h_pt_away->Fill( pt_part );
+ hprof1away->Fill( ptleadjet, fNPart );
+ hprof2away->Fill( ptleadjet, ptsumevent);
+ hptaway->Fill( ptpart );
}
}
}
-
-
-
-
-
-
}
//______________________________________________________________________________
void AliCdfJetFinder::Clean()
{
-
-
- // CLEANING SECTION
+// CLEANING SECTION
delete [] fVectParticle;
delete [] fVectJet;
delete [] fPtArray;
delete [] fIdxArray;
-// if (z_part_ljet) delete [] z_part_ljet;
-// if (idx_leadjet_part) delete [] idx_leadjet_part;
-// if (jets_pt_idx) delete [] jets_pt_idx ;
-// if (jets_pt) delete [] jets_pt ;
-
-// vectArray->Delete() ; // TClonesArray of lorentz vectors
-
Reset();
-
-
-
}
-
-
-
//______________________________________________________________________________
void AliCdfJetFinder::FinishRun()
-{}
-
+{
+// do i need this?
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff