if (fSP->GetHistList()) {
- fSP->GetHistList()->Print();
-// fListHistos = new TList(fSP->GetHistList());
- fListHistos = fSP->GetHistList();
- fListHistos->Print();
+ // fSP->GetHistList()->Print();
+ fListHistos = fSP->GetHistList();
+ // fListHistos->Print();
}
else {Printf("ERROR: Could not retrieve histogram list"); }
}
delete fEvent;
}
- fListHistos->Print();
+ // fListHistos->Print();
PostData(0,fListHistos);
}
void AliAnalysisTaskScalarProduct::Terminate(Option_t *)
{
// Called once at the end of the query
-// fSP->Finish();
+ // fSP->Finish();
// PostData(0,fListHistos);
fListHistos = (TList*)GetOutputData(0);
cout << "histgram list in Terminate" << endl;
{
cout << "histgram list pointer is empty" << endl;
}
-// delete fSP;
-// delete fEventMaker;
+ // delete fSP;
+ // delete fEventMaker;
}
//-----------------------------------------------------------------------
AliFlowAnalysisWithScalarProduct::AliFlowAnalysisWithScalarProduct():
- fQ(NULL),
- fU(NULL),
- fEventNumber(0),
- fDebug(kFALSE),
- fHistList(NULL),
- fHistProUQ(NULL),
- fCommonHists(NULL)
+ fEventNumber(0),
+ fDebug(kFALSE),
+ fHistList(NULL),
+ fHistProUQ(NULL),
+ fCommonHists(NULL)
{
// Constructor.
- fU = new TVector2;
- fQ = new AliFlowVector;
- fHistList = new TList();
- // fQ.Set(0.,0.); // flow vector
- // fU.Set(0.,0.); // particle unit vector
+ fHistList = new TList();
}
//-----------------------------------------------------------------------
AliFlowAnalysisWithScalarProduct::~AliFlowAnalysisWithScalarProduct()
{
- delete fU;
- delete fQ;
- delete fHistList;
//destructor
-
+ delete fHistList;
}
//Define all histograms
cout<<"---Analysis with the Scalar Product Method--- Init"<<endl;
- Int_t fNbinsPt = AliFlowCommonConstants::GetNbinsPt();
- Double_t fPtMin = AliFlowCommonConstants::GetPtMin();
- Double_t fPtMax = AliFlowCommonConstants::GetPtMax();
-
- // analysis file (output)
+ Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
+ Double_t dPtMin = AliFlowCommonConstants::GetPtMin();
+ Double_t dPtMax = AliFlowCommonConstants::GetPtMax();
- fHistProUQ = new TProfile("Flow_UQ_SP","Flow_UQ_SP",fNbinsPt,fPtMin,fPtMax);
+ fHistProUQ = new TProfile("Flow_UQ_SP","Flow_UQ_SP",iNbinsPt,dPtMin,dPtMax);
fHistProUQ->SetXTitle("p_t (GeV)");
fHistProUQ->SetYTitle("<uQ>");
fHistList->Add(fHistProUQ);
fCommonHists = new AliFlowCommonHist("SP");
+ fHistList->Add(fCommonHists->GetHistList());
//fCommonHistsRes = new AliFlowCommonHistResults("SP");
- // fHistList->Add(fCommonHists);
-
+
fEventNumber = 0; //set number of events to zero
}
fCommonHists->FillControlHistograms(anEvent);
//get the Q vector from the FlowEvent
- *fQ = anEvent->GetQ();
- //Double_t fMult = fQ.GetMult();
-
+ AliFlowVector vQ = anEvent->GetQ();
+
//loop over the tracks of the event
- AliFlowTrackSimple* fTrack = NULL;
- Int_t fNumberOfTracks = anEvent->NumberOfTracks();
- for (Int_t i=0;i<fNumberOfTracks;i++)
+ AliFlowTrackSimple* pTrack = NULL;
+ Int_t iNumberOfTracks = anEvent->NumberOfTracks();
+ for (Int_t i=0;i<iNumberOfTracks;i++)
{
-
- fTrack = anEvent->GetTrack(i) ;
- if (fTrack){
- if (fTrack->UseForDifferentialFlow()) {
- Double_t fPhi = fTrack->Phi();
-
- //calculate fU
- Double_t fUX = TMath::Cos(2*fPhi);
- Double_t fUY = TMath::Sin(2*fPhi);
- // fU.Set(fUX,fUY);
- fU->Set(fUX,fUY);
- // Double_t fModulus = fU.Mod();
- Double_t fModulus = fU->Mod();
- // if (fModulus!=0.) fU.Set(fUX/fModulus,fUY/fModulus); // make length 1
- if (fModulus!=0.) fU->Set(fUX/fModulus,fUY/fModulus); // make length 1
- else cerr<<"fModulus is zero!"<<endl;
-
- TVector2 fQm = *fQ;
+ pTrack = anEvent->GetTrack(i) ;
+ if (pTrack){
+ if (pTrack->UseForDifferentialFlow()) {
+ Double_t dPhi = pTrack->Phi();
+
+ //calculate vU
+ TVector2 vU;
+ Double_t dUX = TMath::Cos(2*dPhi);
+ Double_t dUY = TMath::Sin(2*dPhi);
+ vU.Set(dUX,dUY);
+ Double_t dModulus = vU.Mod();
+ if (dModulus!=0.) vU.Set(dUX/dModulus,dUY/dModulus); // make length 1
+ else cerr<<"dModulus is zero!"<<endl;
+
+ TVector2 vQm = vQ;
//subtrackt particle from the flowvector if used to define it
- if (fTrack->UseForIntegratedFlow()) {
- Double_t fQmX = fQm.X() - fUX;
- Double_t fQmY = fQm.Y() - fUY;
- fQm.Set(fQmX,fQmY);
+ if (pTrack->UseForIntegratedFlow()) {
+ Double_t dQmX = vQm.X() - dUX;
+ Double_t dQmY = vQm.Y() - dUY;
+ vQm.Set(dQmX,dQmY);
}
- //Double_t fUQ = scalar product of fU and fQm
- // Double_t fUQ = fU*fQm;
- Double_t fUQ = *fU * fQm;
- Double_t fPt = fTrack->Pt();
+ //dUQ = scalar product of vU and vQm
+ Double_t dUQ = vU * vQm;
+ Double_t dPt = pTrack->Pt();
//fill the profile histogram
- fHistProUQ->Fill(fPt,fUQ);
+ fHistProUQ->Fill(dPt,dUQ);
}
}//track selected
}//loop over tracks
if (fDebug) cout<<"AliFlowAnalysisWithScalarProduct::Terminate()"<<endl;
fHistProUQ->Draw();
-
- // write to file
-// fHistFile->Write();
-
+
cout<<".....finished"<<endl;
}
#ifndef AliFlowAnalysisWithScalarProduct_H
#define AliFlowAnalysisWithScalarProduct_H
-#include "TVector2.h" //called explicitly
#include "TString.h"
-#include "AliFlowVector.h"
-
class AliFlowTrackSimple;
class AliFlowEventSimple;
class AliFlowCommonHist;
public:
- AliFlowAnalysisWithScalarProduct(); //default constructor
+ AliFlowAnalysisWithScalarProduct(); //default constructor
virtual ~AliFlowAnalysisWithScalarProduct(); //destructor
- void Init(); //defines variables and histograms
- void Make(AliFlowEventSimple* anEvent); //calculates variables and fills histograms
- void Finish(); //saves histograms
+ void Init(); //defines variables and histograms
+ void Make(AliFlowEventSimple* anEvent); //calculates variables and fills histograms
+ void Finish(); //saves histograms
void SetDebug(Bool_t kt) { this->fDebug = kt ; }
Bool_t GetDebug() const { return this->fDebug ; }
-
// Output
- TList* GetHistList() const { return this->fHistList ; } // Gets output histogram list
+ TList* GetHistList() const { return this->fHistList ; } // Gets output histogram list
private:
- AliFlowAnalysisWithScalarProduct(const AliFlowAnalysisWithScalarProduct& aAnalysis);
- AliFlowAnalysisWithScalarProduct& operator=(const AliFlowAnalysisWithScalarProduct& aAnalysis);
-
- AliFlowVector *fQ; // flow vector
- TVector2 *fU; // particle unit vector
-
- Int_t fEventNumber; // event counter
-
- Bool_t fDebug ; // flag for lyz analysis: more print statements
-
- TList* fHistList;
- TProfile* fHistProUQ;
-
- AliFlowCommonHist* fCommonHists;
-
- ClassDef(AliFlowAnalysisWithScalarProduct,0) // macro for rootcint
- };
+ AliFlowAnalysisWithScalarProduct(const AliFlowAnalysisWithScalarProduct& anAnalysis); //copy constructor
+ AliFlowAnalysisWithScalarProduct& operator=(const AliFlowAnalysisWithScalarProduct& anAnalysis); //assignment operator
+
+ Int_t fEventNumber; // event counter
+ Bool_t fDebug ; // flag for analysis: more print statements
+
+ TList* fHistList; //list to hold all output histograms
+ TProfile* fHistProUQ; //uQ(pt)
+ AliFlowCommonHist* fCommonHists; //control histograms
+
+ ClassDef(AliFlowAnalysisWithScalarProduct,0) // macro for rootcint
+ };
#endif
#include "TString.h"
#include "TProfile.h"
#include "TMath.h" //needed as include
+#include "TList.h"
#include "AliFlowVector.h"
class TH1F;
//-----------------------------------------------------------------------
- AliFlowCommonHist::AliFlowCommonHist(TString input):TObject(),
+ AliFlowCommonHist::AliFlowCommonHist():TObject(),
fHistMultOrig(NULL),
fHistMultInt(NULL),
fHistMultDiff(NULL),
fHistEtaInt(NULL),
fHistEtaDiff(NULL),
fHistProMeanPtperBin(NULL),
- fHistQ(NULL)
+ fHistQ(NULL),
+ fHistList(NULL)
{
+
+ //default constructor
+
+ }
+
+//-----------------------------------------------------------------------
+
+ AliFlowCommonHist::AliFlowCommonHist(TString anInput):TObject(),
+ fHistMultOrig(NULL),
+ fHistMultInt(NULL),
+ fHistMultDiff(NULL),
+ fHistPtInt(NULL),
+ fHistPtDiff(NULL),
+ fHistPhiInt(NULL),
+ fHistPhiDiff(NULL),
+ fHistEtaInt(NULL),
+ fHistEtaDiff(NULL),
+ fHistProMeanPtperBin(NULL),
+ fHistQ(NULL),
+ fHistList(NULL)
+ {
+
//constructor creating histograms
- Int_t fNbinsMult = AliFlowCommonConstants::GetNbinsMult();
- Int_t fNbinsPt = AliFlowCommonConstants::GetNbinsPt();
- Int_t fNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
- Int_t fNbinsEta = AliFlowCommonConstants::GetNbinsEta();
- Int_t fNbinsQ = AliFlowCommonConstants::GetNbinsQ();
- TString name;
-
- Double_t fMultMin = AliFlowCommonConstants::GetMultMin();
- Double_t fMultMax = AliFlowCommonConstants::GetMultMax();
- Double_t fPtMin = AliFlowCommonConstants::GetPtMin();
- Double_t fPtMax = AliFlowCommonConstants::GetPtMax();
- Double_t fPhiMin = AliFlowCommonConstants::GetPhiMin();
- Double_t fPhiMax = AliFlowCommonConstants::GetPhiMax();
- Double_t fEtaMin = AliFlowCommonConstants::GetEtaMin();
- Double_t fEtaMax = AliFlowCommonConstants::GetEtaMax();
- Double_t fQMin = AliFlowCommonConstants::GetQMin();
- Double_t fQMax = AliFlowCommonConstants::GetQMax();
+ Int_t iNbinsMult = AliFlowCommonConstants::GetNbinsMult();
+ Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
+ Int_t iNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
+ Int_t iNbinsEta = AliFlowCommonConstants::GetNbinsEta();
+ Int_t iNbinsQ = AliFlowCommonConstants::GetNbinsQ();
+ TString sName;
+
+ Double_t dMultMin = AliFlowCommonConstants::GetMultMin();
+ Double_t dMultMax = AliFlowCommonConstants::GetMultMax();
+ Double_t dPtMin = AliFlowCommonConstants::GetPtMin();
+ Double_t dPtMax = AliFlowCommonConstants::GetPtMax();
+ Double_t dPhiMin = AliFlowCommonConstants::GetPhiMin();
+ Double_t dPhiMax = AliFlowCommonConstants::GetPhiMax();
+ Double_t dEtaMin = AliFlowCommonConstants::GetEtaMin();
+ Double_t dEtaMax = AliFlowCommonConstants::GetEtaMax();
+ Double_t dQMin = AliFlowCommonConstants::GetQMin();
+ Double_t dQMax = AliFlowCommonConstants::GetQMax();
cout<<"The settings for the common histograms are as follows:"<<endl;
- cout<<"Multiplicity: "<<fNbinsMult<<" bins between "<<fMultMin<<" and "<<fMultMax<<endl;
- cout<<"Pt: "<<fNbinsPt<<" bins between "<<fPtMin<<" and "<<fPtMax<<endl;
- cout<<"Phi: "<<fNbinsPhi<<" bins between "<<fPhiMin<<" and "<<fPhiMax<<endl;
- cout<<"Eta: "<<fNbinsEta<<" bins between "<<fEtaMin<<" and "<<fEtaMax<<endl;
- cout<<"Q: "<<fNbinsQ<<" bins between "<<fQMin<<" and "<<fQMax<<endl;
+ cout<<"Multiplicity: "<<iNbinsMult<<" bins between "<<dMultMin<<" and "<<dMultMax<<endl;
+ cout<<"Pt: "<<iNbinsPt<<" bins between "<<dPtMin<<" and "<<dPtMax<<endl;
+ cout<<"Phi: "<<iNbinsPhi<<" bins between "<<dPhiMin<<" and "<<dPhiMax<<endl;
+ cout<<"Eta: "<<iNbinsEta<<" bins between "<<dEtaMin<<" and "<<dEtaMax<<endl;
+ cout<<"Q: "<<iNbinsQ<<" bins between "<<dQMin<<" and "<<dQMax<<endl;
//Multiplicity
- name = "Control_Flow_OrigMult_";
- name +=input;
- fHistMultOrig = new TH1F(name.Data(), name.Data(),fNbinsMult, fMultMin, fMultMax);
+ sName = "Control_Flow_OrigMult_";
+ sName +=anInput;
+ fHistMultOrig = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
fHistMultOrig ->SetXTitle("Original Multiplicity");
fHistMultOrig ->SetYTitle("Counts");
- name = "Control_Flow_MultInt_";
- name +=input;
- fHistMultInt = new TH1F(name.Data(), name.Data(),fNbinsMult, fMultMin, fMultMax);
+ sName = "Control_Flow_MultInt_";
+ sName +=anInput;
+ fHistMultInt = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
fHistMultInt ->SetXTitle("Multiplicity for integrated flow");
fHistMultInt ->SetYTitle("Counts");
- name = "Control_Flow_MultDiff_";
- name +=input;
- fHistMultDiff = new TH1F(name.Data(), name.Data(),fNbinsMult, fMultMin, fMultMax);
+ sName = "Control_Flow_MultDiff_";
+ sName +=anInput;
+ fHistMultDiff = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
fHistMultDiff ->SetXTitle("Multiplicity for differential flow");
fHistMultDiff ->SetYTitle("Counts");
//Pt
- name = "Control_Flow_PtInt_";
- name +=input;
- fHistPtInt = new TH1F(name.Data(), name.Data(),fNbinsPt, fPtMin, fPtMax);
+ sName = "Control_Flow_PtInt_";
+ sName +=anInput;
+ fHistPtInt = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
fHistPtInt ->SetXTitle("Pt (GeV/c) for integrated flow");
fHistPtInt ->SetYTitle("Counts");
- name = "Control_Flow_PtDiff_";
- name +=input;
- fHistPtDiff = new TH1F(name.Data(), name.Data(),fNbinsPt, fPtMin, fPtMax);
+ sName = "Control_Flow_PtDiff_";
+ sName +=anInput;
+ fHistPtDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
//binning has to be the same as for fHistProVPt! use to get Nprime!
fHistPtDiff ->SetXTitle("Pt (GeV/c) for differential flow");
fHistPtDiff ->SetYTitle("Counts");
//Phi
- name = "Control_Flow_PhiInt_";
- name +=input;
- fHistPhiInt = new TH1F(name.Data(), name.Data(),fNbinsPhi, fPhiMin, fPhiMax);
+ sName = "Control_Flow_PhiInt_";
+ sName +=anInput;
+ fHistPhiInt = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
fHistPhiInt ->SetXTitle("Phi for integrated flow");
fHistPhiInt ->SetYTitle("Counts");
- name = "Control_Flow_PhiDiff_";
- name +=input;
- fHistPhiDiff = new TH1F(name.Data(), name.Data(),fNbinsPhi, fPhiMin, fPhiMax);
+ sName = "Control_Flow_PhiDiff_";
+ sName +=anInput;
+ fHistPhiDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
fHistPhiDiff ->SetXTitle("Phi for differential flow");
fHistPhiDiff ->SetYTitle("Counts");
//Eta
- name = "Control_Flow_EtaInt_";
- name +=input;
- fHistEtaInt = new TH1F(name.Data(), name.Data(),fNbinsEta, fEtaMin, fEtaMax);
+ sName = "Control_Flow_EtaInt_";
+ sName +=anInput;
+ fHistEtaInt = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
fHistEtaInt ->SetXTitle("Eta for integrated flow");
fHistEtaInt ->SetYTitle("Counts");
- name = "Control_Flow_EtaDiff_";
- name +=input;
- fHistEtaDiff = new TH1F(name.Data(), name.Data(),fNbinsEta, fEtaMin, fEtaMax);
+ sName = "Control_Flow_EtaDiff_";
+ sName +=anInput;
+ fHistEtaDiff = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
fHistEtaDiff ->SetXTitle("Eta for differential flow");
fHistEtaDiff ->SetYTitle("Counts");
//Mean Pt per pt bin
- name = "Control_FlowPro_MeanPtperBin_";
- name +=input;
- fHistProMeanPtperBin = new TProfile(name.Data(), name.Data(),fNbinsPt,fPtMin,fPtMax);
+ sName = "Control_FlowPro_MeanPtperBin_";
+ sName +=anInput;
+ fHistProMeanPtperBin = new TProfile(sName.Data(), sName.Data(),iNbinsPt,dPtMin,dPtMax);
fHistProMeanPtperBin ->SetXTitle("Pt");
fHistProMeanPtperBin ->SetYTitle("<Pt>");
//Q vector
- name = "Control_Flow_Q_";
- name +=input;
- fHistQ = new TH1F(name.Data(), name.Data(),fNbinsQ, fQMin, fQMax);
+ sName = "Control_Flow_Q_";
+ sName +=anInput;
+ fHistQ = new TH1F(sName.Data(), sName.Data(),iNbinsQ, dQMin, dQMax);
fHistQ ->SetXTitle("Qvector/Mult");
fHistQ ->SetYTitle("Counts");
+
+ //list of histograms
+ fHistList = new TList();
+ fHistList-> Add(fHistMultOrig);
+ fHistList-> Add(fHistMultInt);
+ fHistList-> Add(fHistMultDiff);
+ fHistList-> Add(fHistPtInt);
+ fHistList-> Add(fHistPtDiff);
+ fHistList-> Add(fHistPhiInt);
+ fHistList-> Add(fHistPhiDiff);
+ fHistList-> Add(fHistEtaInt);
+ fHistList-> Add(fHistEtaDiff);
+ fHistList-> Add(fHistProMeanPtperBin);
+ fHistList-> Add(fHistQ);
+
+
+
}
delete fHistEtaDiff;
delete fHistProMeanPtperBin;
delete fHistQ;
+ delete fHistList;
}
//-----------------------------------------------------------------------
-Bool_t AliFlowCommonHist::FillControlHistograms(AliFlowEventSimple* Event)
+Bool_t AliFlowCommonHist::FillControlHistograms(AliFlowEventSimple* anEvent)
{
//Fills the control histograms
- if (!Event){
+ if (!anEvent){
cout<<"##### FillControlHistograms: FlowEvent pointer null"<<endl;
return kFALSE;
}
- Double_t fPt, fPhi, fEta;
+ Double_t dPt, dPhi, dEta;
//fill the histograms
- Int_t fNumberOfTracks = Event->NumberOfTracks();
- fHistMultOrig->Fill(fNumberOfTracks);
+ Int_t iNumberOfTracks = anEvent->NumberOfTracks();
+ fHistMultOrig->Fill(iNumberOfTracks);
- AliFlowVector fQ = Event->GetQ();
+ AliFlowVector vQ = anEvent->GetQ();
//weight by the Multiplicity
- Double_t fQX = fQ.X()/fQ.GetMult();
- Double_t fQY = fQ.Y()/fQ.GetMult();
- fQ.Set(fQX,fQY);
- fHistQ->Fill(fQ.Mod());
+ Double_t dQX = vQ.X()/vQ.GetMult();
+ Double_t dQY = vQ.Y()/vQ.GetMult();
+ vQ.Set(dQX,dQY);
+ fHistQ->Fill(vQ.Mod());
- Int_t fMultInt = 0;
- Int_t fMultDiff = 0;
+ Int_t iMultInt = 0;
+ Int_t iMultDiff = 0;
- AliFlowTrackSimple* fTrack = NULL;
-
- for (Int_t i=0;i<fNumberOfTracks;i++) {
- fTrack = Event->GetTrack(i);
- if (fTrack ) {
- if (fTrack->UseForIntegratedFlow()){
- fPt = fTrack->Pt();
- fHistPtInt->Fill(fPt);
- fPhi = fTrack->Phi();
- if (fPhi<0.) fPhi+=2*TMath::Pi();
- fHistPhiInt->Fill(fPhi);
- fEta = fTrack->Eta();
- fHistEtaInt->Fill(fEta);
- fMultInt++;
+ AliFlowTrackSimple* pTrack = NULL;
+
+ for (Int_t i=0;i<iNumberOfTracks;i++) {
+ pTrack = anEvent->GetTrack(i);
+ if (pTrack ) {
+ if (pTrack->UseForIntegratedFlow()){
+ dPt = pTrack->Pt();
+ fHistPtInt->Fill(dPt);
+ dPhi = pTrack->Phi();
+ if (dPhi<0.) dPhi+=2*TMath::Pi();
+ fHistPhiInt->Fill(dPhi);
+ dEta = pTrack->Eta();
+ fHistEtaInt->Fill(dEta);
+ iMultInt++;
}
- if (fTrack->UseForDifferentialFlow()){
- fPt = fTrack->Pt();
- fHistPtDiff->Fill(fPt);
- fPhi = fTrack->Phi();
- if (fPhi<0.) fPhi+=2*TMath::Pi();
- fHistPhiDiff->Fill(fPhi);
- fEta = fTrack->Eta();
- fHistEtaDiff->Fill(fEta);
- fHistProMeanPtperBin->Fill(fPt,fPt);
- fMultDiff++;
+ if (pTrack->UseForDifferentialFlow()){
+ dPt = pTrack->Pt();
+ fHistPtDiff->Fill(dPt);
+ dPhi = pTrack->Phi();
+ if (dPhi<0.) dPhi+=2*TMath::Pi();
+ fHistPhiDiff->Fill(dPhi);
+ dEta = pTrack->Eta();
+ fHistEtaDiff->Fill(dEta);
+ fHistProMeanPtperBin->Fill(dPt,dPt);
+ iMultDiff++;
}
} //track
} //loop over tracks
- fHistMultInt->Fill(fMultInt);
- fHistMultDiff->Fill(fMultDiff);
+ fHistMultInt->Fill(iMultInt);
+ fHistMultDiff->Fill(iMultDiff);
return kTRUE;
}
//-----------------------------------------------------------------------
-Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t fBin)
+Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t aBin)
{
- //get entries in bin fBin from fHistPtDiff
- Double_t fEntries = fHistPtDiff->GetBinContent(fBin);
+ //get entries in bin aBin from fHistPtDiff
+ Double_t dEntries = fHistPtDiff->GetBinContent(aBin);
- return fEntries;
+ return dEntries;
}
//-----------------------------------------------------------------------
-Double_t AliFlowCommonHist::GetMeanPt(Int_t fBin)
+Double_t AliFlowCommonHist::GetMeanPt(Int_t aBin)
{
- //Get entry from bin fBin from fHistProMeanPtperBin
- Double_t fMeanPt = fHistProMeanPtperBin->GetBinContent(fBin);
+ //Get entry from bin aBin from fHistProMeanPtperBin
+ Double_t dMeanPt = fHistProMeanPtperBin->GetBinContent(aBin);
- return fMeanPt;
+ return dMeanPt;
}
+//-----------------------------------------------------------------------
+ Double_t AliFlowCommonHist::Merge(TCollection *aList)
+{
+ //merge fuction
+ cout<<"entering merge function"<<endl;
+ if (!aList) return 0;
+ if (aList->IsEmpty()) return 0; //no merging is needed
+
+ Int_t iCount = 0;
+ TIter next(aList); // list is supposed to contain only objects of the same type as this
+ AliFlowCommonHist *toMerge;
+ // make a temporary list
+ TList *pTemp = new TList();
+ while ((toMerge=(AliFlowCommonHist*)next())) {
+ pTemp->Add(toMerge->GetHistList());
+ iCount++;
+ }
+ // Now call merge for fHistList providing temp list
+ fHistList->Merge(pTemp);
+ // Cleanup
+ delete pTemp;
+
+ cout<<"Merged"<<endl;
+ return (double)iCount;
+
+}
+
+
+
+
class TH1F;
class TH1D;
class TProfile;
+class TCollection;
+class TList;
class AliFlowCommonHist: public TObject {
public:
- AliFlowCommonHist(TString input);
+ AliFlowCommonHist();
+ AliFlowCommonHist(TString anInput);
virtual ~AliFlowCommonHist();
//make fill methods here
- Bool_t FillControlHistograms(AliFlowEventSimple* Event);
+ Bool_t FillControlHistograms(AliFlowEventSimple* anEvent);
//make get methods here
- Double_t GetEntriesInPtBin(Int_t fBin); //gets entries from fHistPtDiff
- Double_t GetMeanPt(Int_t fBin); //gets the mean pt for this bin from fHistProMeanPtperBin
+ Double_t GetEntriesInPtBin(Int_t iBin); //gets entries from fHistPtDiff
+ Double_t GetMeanPt(Int_t iBin); //gets the mean pt for this bin from fHistProMeanPtperBin
TH1F* GetfHistMultOrig() {return fHistMultOrig; } ;
TH1F* GetfHistMultInt() {return fHistMultInt; } ;
TH1F* GetfHistEtaDiff() {return fHistEtaDiff; } ;
TProfile* GetfHistProMeanPtperBin() {return fHistProMeanPtperBin; } ;
TH1F* GetfHistQ() {return fHistQ; } ;
-
- // virtual Long64_t Merge(TCollection *list);
+ TList* GetHistList() {return fHistList;} ;
+
+ virtual Double_t Merge(TCollection *aList); //merge function
private:
//define histograms here
//control histograms
- TH1F* fHistMultOrig;
- TH1F* fHistMultInt;
- TH1F* fHistMultDiff;
- TH1F* fHistPtInt;
- TH1F* fHistPtDiff;
- TH1F* fHistPhiInt;
- TH1F* fHistPhiDiff;
- TH1F* fHistEtaInt;
- TH1F* fHistEtaDiff;
- TProfile* fHistProMeanPtperBin;
- TH1F* fHistQ;
-
- ClassDef(AliFlowCommonHist,0); // macro for rootcint
+ TH1F* fHistMultOrig; //multiplicity before selection
+ TH1F* fHistMultInt; //multiplicity for integrated flow
+ TH1F* fHistMultDiff; //multiplicity for differential flow
+ TH1F* fHistPtInt; //pt distribution for integrated flow
+ TH1F* fHistPtDiff; //pt distribution for differential flow
+ TH1F* fHistPhiInt; //phi distribution for integrated flow
+ TH1F* fHistPhiDiff; //phi distribution for differential flow
+ TH1F* fHistEtaInt; //eta distribution for integrated flow
+ TH1F* fHistEtaDiff; //eta distribution for differential flow
+ TProfile* fHistProMeanPtperBin; //mean pt for each pt bin (for differential flow)
+ TH1F* fHistQ; //Qvector distribution
+
+ TList* fHistList; //list to hold all histograms
+
+ ClassDef(AliFlowCommonHist,0); // macro for rootcint
};
#endif
//-----------------------------------------------------------------------
- AliFlowEventSimple::AliFlowEventSimple(Int_t lenght):
+ AliFlowEventSimple::AliFlowEventSimple(Int_t aLenght):
fTrackCollection(0),
- fTrack(0),
fNumberOfTracks(0),
fEventNSelTracksIntFlow(0)
{
//constructor
- fTrackCollection = new TObjArray(lenght) ;
-
-
+ fTrackCollection = new TObjArray(aLenght) ;
}
//-----------------------------------------------------------------------
-AliFlowEventSimple::AliFlowEventSimple(const AliFlowEventSimple& event):
+AliFlowEventSimple::AliFlowEventSimple(const AliFlowEventSimple& anEvent):
TObject(),
- fTrackCollection(event.fTrackCollection),
- fTrack(event.fTrack),
- fNumberOfTracks(event.fNumberOfTracks),
- fEventNSelTracksIntFlow(event.fEventNSelTracksIntFlow)
+ fTrackCollection(anEvent.fTrackCollection),
+ fNumberOfTracks(anEvent.fNumberOfTracks),
+ fEventNSelTracksIntFlow(anEvent.fEventNSelTracksIntFlow)
{
//copy constructor
- // *fTrack = *event.fTrack;
- // *fTrackCollection = *event.fTrackCollection ;
-
}
//-----------------------------------------------------------------------
-AliFlowEventSimple& AliFlowEventSimple::operator=(const AliFlowEventSimple& event)
+AliFlowEventSimple& AliFlowEventSimple::operator=(const AliFlowEventSimple& anEvent)
{
- *fTrack = *event.fTrack;
- *fTrackCollection = *event.fTrackCollection ;
- fNumberOfTracks = event.fNumberOfTracks;
- fEventNSelTracksIntFlow = event.fEventNSelTracksIntFlow;
+ *fTrackCollection = *anEvent.fTrackCollection ;
+ fNumberOfTracks = anEvent.fNumberOfTracks;
+ fEventNSelTracksIntFlow = anEvent.fEventNSelTracksIntFlow;
return *this;
AliFlowTrackSimple* AliFlowEventSimple::GetTrack(Int_t i)
{
//get track i from collection
- fTrack = (AliFlowTrackSimple*)TrackCollection()->At(i) ;
- return fTrack;
+ AliFlowTrackSimple* pTrack = (AliFlowTrackSimple*)TrackCollection()->At(i) ;
+ return pTrack;
}
//-----------------------------------------------------------------------
{
//calculate Q.
- Double_t fQX = 0.;
- Double_t fQY = 0.;
- AliFlowVector fQ;
- fQ.Set(0.,0.);
- Double_t fOrder = 2.;
- Int_t fUsedTracks = 0;
+ Double_t dQX = 0.;
+ Double_t dQY = 0.;
+ AliFlowVector vQ;
+ vQ.Set(0.,0.);
+ Double_t dOrder = 2.;
+ Int_t iUsedTracks = 0;
for (Int_t i=0;i<fNumberOfTracks;i++)
{
- fTrack = (AliFlowTrackSimple*)TrackCollection()->At(i) ;
- if (fTrack){
- if (fTrack->UseForIntegratedFlow()) {
- Double_t fPhi = fTrack->Phi();
- fQX += TMath::Cos(fOrder*fPhi);
- fQY += TMath::Sin(fOrder*fPhi);
- fUsedTracks++;
+ AliFlowTrackSimple* pTrack = (AliFlowTrackSimple*)TrackCollection()->At(i) ;
+ if (pTrack){
+ if (pTrack->UseForIntegratedFlow()) {
+ Double_t dPhi = pTrack->Phi();
+ dQX += TMath::Cos(dOrder*dPhi);
+ dQY += TMath::Sin(dOrder*dPhi);
+ iUsedTracks++;
}
} //if particle
else {cerr << "no particle!!!"<<endl;}
}//loop over particles
- fQ.Set(fQX,fQY);
- fQ.SetMult(fUsedTracks);
+ vQ.Set(dQX,dQY);
+ vQ.SetMult(iUsedTracks);
- return fQ;
+ return vQ;
}
class AliFlowEventSimple: public TObject {
public:
- AliFlowEventSimple(Int_t lenght);
- AliFlowEventSimple(const AliFlowEventSimple& event);
- AliFlowEventSimple& operator=(const AliFlowEventSimple& event);
+ AliFlowEventSimple(Int_t aLenght);
+ AliFlowEventSimple(const AliFlowEventSimple& anEvent);
+ AliFlowEventSimple& operator=(const AliFlowEventSimple& anEvent);
virtual ~AliFlowEventSimple();
Int_t NumberOfTracks() const { return this->fNumberOfTracks; }
private:
TObjArray* fTrackCollection; // collection of tracks
- AliFlowTrackSimple* fTrack; // track object
Int_t fNumberOfTracks; // number of tracks
Int_t fEventNSelTracksIntFlow; // number of tracks selected for integrated flow calculation
ClassImp(AliFlowEventSimpleMaker)
//-----------------------------------------------------------------------
-AliFlowEventSimpleMaker::AliFlowEventSimpleMaker():
- fEvent(0),
- fTrack(0),
- fParticle(0)
+AliFlowEventSimpleMaker::AliFlowEventSimpleMaker()
{
-
//constructor
-
}
-
//-----------------------------------------------------------------------
AliFlowEventSimpleMaker::~AliFlowEventSimpleMaker()
{
- //desstructor
+ //destructor
}
-
//-----------------------------------------------------------------------
-AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* fInput)
+AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* anInput)
{
//fills the event from a TTree of kinematic.root files
- Bool_t fDoubleLoop = kFALSE;
-
- Int_t fNumberOfInputTracks = fInput->GetEntries() ;
- //cerr<<"fNumberOfInputTracks = "<<fNumberOfInputTracks<<endl;
- fParticle = new TParticle();
- fInput->SetBranchAddress("Particles",&fParticle);
- // fEvent = new AliFlowEventSimple(fNumberOfInputTracks);
- fEvent = new AliFlowEventSimple(10);
- //cerr<<fEvent<<" fEvent "<<endl;
+ Bool_t bDoubleLoop = kFALSE;
+
+ Int_t iNumberOfInputTracks = anInput->GetEntries() ;
+ //cerr<<"iNumberOfInputTracks = "<<iNumberOfInputTracks<<endl;
+ TParticle* pParticle = new TParticle();
+ anInput->SetBranchAddress("Particles",&pParticle);
+ // AliFlowEventSimple* pEvent = new AliFlowEventSimple(iNumberOfInputTracks);
+ AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
+ //cerr<<pEvent<<" pEvent "<<endl;
- Int_t fN = fNumberOfInputTracks;
- // Int_t fN = 576; //multiplicity for chi=1.5
- // Int_t fN = 256; //multiplicity for chi=1
- // Int_t fN = 164; //multiplicity for chi=0.8
- Int_t fGoodTracks = 0;
- Int_t ftrkN = 0;
- Int_t fSelParticlesDiff = 0;
- Int_t fSelParticlesInt = 0;
+ Int_t iN = iNumberOfInputTracks;
+ // Int_t iN = 576; //multiplicity for chi=1.5
+ // Int_t iN = 256; //multiplicity for chi=1
+ // Int_t iN = 164; //multiplicity for chi=0.8
+ Int_t iGoodTracks = 0;
+ Int_t itrkN = 0;
+ Int_t iSelParticlesDiff = 0;
+ Int_t iSelParticlesInt = 0;
- if (fDoubleLoop)
+ if (bDoubleLoop)
{ //double loop
- while (fGoodTracks < fN*2 && ftrkN < fNumberOfInputTracks)
+ while (iGoodTracks < iN*2 && itrkN < iNumberOfInputTracks)
{
- fInput->GetEntry(ftrkN); //get input particle
+ anInput->GetEntry(itrkN); //get input particle
//cut on tracks
- if(TMath::Abs(fParticle->Eta()) < 0.9)
+ if(TMath::Abs(pParticle->Eta()) < 0.9)
{
// Int_t fLoop = floor(2.*fParticle->Pt())+2;
// for(Int_t d=0;d<fLoop;d++)
for(Int_t d=0;d<2;d++)
{
if(
- TMath::Abs(fParticle->GetPdgCode()) == 211
- // TMath::Abs(fParticle->GetPdgCode()) == 211 ||
- // TMath::Abs(fParticle->GetPdgCode()) == 321 ||
- // TMath::Abs(fParticle->GetPdgCode()) == 2212
+ TMath::Abs(pParticle->GetPdgCode()) == 211
+ // TMath::Abs(pParticle->GetPdgCode()) == 211 ||
+ // TMath::Abs(pParticle->GetPdgCode()) == 321 ||
+ // TMath::Abs(pParticle->GetPdgCode()) == 2212
)
{
- fTrack = new AliFlowTrackSimple();
- fTrack->SetPt(fParticle->Pt() );
- fTrack->SetEta(fParticle->Eta() );
- fTrack->SetPhi(fParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack);
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack);
}
/*
else if(
- TMath::Abs(fParticle->GetPdgCode()) == 2212
+ TMath::Abs(pParticle->GetPdgCode()) == 2212
)
{
- fTrack = new AliFlowTrackSimple();
- fTrack->SetPt(fParticle->Pt() );
- fTrack->SetEta(fParticle->Eta() );
- fTrack->SetPhi(fParticle->Phi() );
- fTrack->SetForIntegratedFlow(kFALSE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack);
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kFALSE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack);
}
*/
}
}
- ftrkN++;
+ itrkN++;
}
}
else { //normal loop
- while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
- fInput->GetEntry(ftrkN); //get input particle
+ while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
+ anInput->GetEntry(itrkN); //get input particle
//cut on tracks
- if (TMath::Abs(fParticle->Eta()) < 0.2)
+ if (TMath::Abs(pParticle->Eta()) < 0.2)
{
if(
- TMath::Abs(fParticle->GetPdgCode()) == 211
- // TMath::Abs(fParticle->GetPdgCode()) == 211 ||
- // TMath::Abs(fParticle->GetPdgCode()) == 321 ||
- // TMath::Abs(fParticle->GetPdgCode()) == 2212
+ TMath::Abs(pParticle->GetPdgCode()) == 211
+ // TMath::Abs(pParticle->GetPdgCode()) == 211 ||
+ // TMath::Abs(pParticle->GetPdgCode()) == 321 ||
+ // TMath::Abs(pParticle->GetPdgCode()) == 2212
)
{
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(fParticle->Pt() );
- fTrack->SetEta(fParticle->Eta() );
- fTrack->SetPhi(fParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack) ;
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack) ;
}
/* else if(
- TMath::Abs(fParticle->GetPdgCode()) == 211
+ TMath::Abs(pParticle->GetPdgCode()) == 211
)
{
- fTrack = new AliFlowTrackSimple();
- fTrack->SetPt(fParticle->Pt() );
- fTrack->SetEta(fParticle->Eta() );
- fTrack->SetPhi(fParticle->Phi() );
- fTrack->SetForIntegratedFlow(kFALSE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack);
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kFALSE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack);
}
*/
}
- ftrkN++;
+ itrkN++;
}
}
- fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
- fEvent->SetNumberOfTracks(fGoodTracks);
- cout<<" fGoodTracks = "<<fGoodTracks<<endl;
- cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
- return fEvent;
+ pEvent-> SetEventNSelTracksIntFlow(iSelParticlesInt);
+ pEvent->SetNumberOfTracks(iGoodTracks);
+ cout<<" iGoodTracks = "<<iGoodTracks<<endl;
+ cout << " iSelectedTracksInt = " << iSelParticlesInt << endl;
+ return pEvent;
}
//-----------------------------------------------------------------------
-AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* fInput)
+AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* anInput)
{
//Fills the event from the MC kinematic information
- Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
- cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
+ Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
+ cerr<<"anInput->GetNumberOfTracks() = "<<iNumberOfInputTracks<<endl;
- fEvent = new AliFlowEventSimple(10);
+ AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
- //Int_t fN = 256; //multiplicity for chi=1
- Int_t fN = fNumberOfInputTracks;
- Int_t fGoodTracks = 0;
- Int_t ftrkN = 0;
- Int_t fSelParticlesDiff = 0;
- Int_t fSelParticlesInt = 0;
+ //Int_t iN = 256; //multiplicity for chi=1
+ Int_t iN = iNumberOfInputTracks;
+ Int_t iGoodTracks = 0;
+ Int_t itrkN = 0;
+ Int_t iSelParticlesDiff = 0;
+ Int_t iSelParticlesInt = 0;
//normal loop
- while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
- AliMCParticle* myParticle = fInput->GetTrack(ftrkN); //get input particle
+ while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
+ AliMCParticle* pParticle = anInput->GetTrack(itrkN); //get input particle
//cut on tracks
- if (TMath::Abs(myParticle->Eta()) < 0.2)
+ if (TMath::Abs(pParticle->Eta()) < 0.2)
{
if(
- TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
- // TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211 ||
- // TMath::Abs(myParticle->Particle()->GetPdgCode()) == 321 ||
- // TMath::Abs(myParticle->Particle()->GetPdgCode()) == 2212
+ TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211
+ // TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211 ||
+ // TMath::Abs(pParticle->Particle()->GetPdgCode()) == 321 ||
+ // TMath::Abs(pParticle->Particle()->GetPdgCode()) == 2212
)
{
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(myParticle->Pt() );
- fTrack->SetEta(myParticle->Eta() );
- fTrack->SetPhi(myParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack) ;
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack) ;
}
/* else if(
- TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
+ TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211
)
{
- fTrack = new AliFlowTrackSimple();
- fTrack->SetPt(myParticle->Pt() );
- fTrack->SetEta(myParticle->Eta() );
- fTrack->SetPhi(myParticle->Phi() );
- fTrack->SetForIntegratedFlow(kFALSE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack);
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kFALSE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack);
}
*/
}
- ftrkN++;
+ itrkN++;
}
- fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
- fEvent->SetNumberOfTracks(fGoodTracks);
- cout<<" fGoodTracks = "<<fGoodTracks<<endl;
- cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
- return fEvent;
-
+ pEvent-> SetEventNSelTracksIntFlow(iSelParticlesInt);
+ pEvent->SetNumberOfTracks(iGoodTracks);
+ cout<<" iGoodTracks = "<<iGoodTracks<<endl;
+ cout << " iSelectedTracksInt = " << iSelParticlesInt << endl;
+ return pEvent;
}
-
//-----------------------------------------------------------------------
-AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput)
+AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput)
{
//Fills the event from the ESD
- Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
- cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
+ Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
+ cerr<<"anInput->GetNumberOfTracks() = "<<iNumberOfInputTracks<<endl;
- fEvent = new AliFlowEventSimple(10);
+ AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
- //Int_t fN = 256; //multiplicity for chi=1
- Int_t fN = fNumberOfInputTracks;
- Int_t fGoodTracks = 0;
- Int_t ftrkN = 0;
- Int_t fSelParticlesDiff = 0;
- Int_t fSelParticlesInt = 0;
+ //Int_t iN = 256; //multiplicity for chi=1
+ Int_t iN = iNumberOfInputTracks;
+ Int_t iGoodTracks = 0;
+ Int_t itrkN = 0;
+ Int_t iSelParticlesDiff = 0;
+ Int_t iSelParticlesInt = 0;
//normal loop
- while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
- AliESDtrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
+ while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
+ AliESDtrack* pParticle = anInput->GetTrack(itrkN); //get input particle
//cut on tracks
- if (TMath::Abs(myParticle->Eta()) < 0.2)
+ if (TMath::Abs(pParticle->Eta()) < 0.2)
{
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(myParticle->Pt() );
- fTrack->SetEta(myParticle->Eta() );
- fTrack->SetPhi(myParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack) ;
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack) ;
}
- ftrkN++;
+ itrkN++;
}
- fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
- fEvent->SetNumberOfTracks(fGoodTracks);
- cout<<" fGoodTracks = "<<fGoodTracks<<endl;
- cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
- return fEvent;
+ pEvent-> SetEventNSelTracksIntFlow(iSelParticlesInt);
+ pEvent->SetNumberOfTracks(iGoodTracks);
+ cout<<" iGoodTracks = "<<iGoodTracks<<endl;
+ cout << " iSelectedTracksInt = " << iSelParticlesInt << endl;
+ return pEvent;
}
//-----------------------------------------------------------------------
-AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* fInput)
+AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* anInput)
{
//Fills the event from the AOD
- Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
- cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
+ Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
+ cerr<<"anInput->GetNumberOfTracks() = "<<iNumberOfInputTracks<<endl;
- fEvent = new AliFlowEventSimple(10);
+ AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
- //Int_t fN = 256; //multiplicity for chi=1
- Int_t fN = fNumberOfInputTracks;
- Int_t fGoodTracks = 0;
- Int_t ftrkN = 0;
- Int_t fSelParticlesDiff = 0;
- Int_t fSelParticlesInt = 0;
+ //Int_t iN = 256; //multiplicity for chi=1
+ Int_t iN = iNumberOfInputTracks;
+ Int_t iGoodTracks = 0;
+ Int_t itrkN = 0;
+ Int_t iSelParticlesDiff = 0;
+ Int_t iSelParticlesInt = 0;
//normal loop
- while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
- AliAODTrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
+ while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
+ AliAODTrack* pParticle = anInput->GetTrack(itrkN); //get input particle
//cut on tracks
- if (TMath::Abs(myParticle->Eta()) < 0.2)
+ if (TMath::Abs(pParticle->Eta()) < 0.2)
{
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(myParticle->Pt() );
- fTrack->SetEta(myParticle->Eta() );
- fTrack->SetPhi(myParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
-
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack) ;
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
+
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack) ;
}
- ftrkN++;
+ itrkN++;
}
- fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
- fEvent->SetNumberOfTracks(fGoodTracks);
- cout<<" fGoodTracks = "<<fGoodTracks<<endl;
- cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
- return fEvent;
+ pEvent-> SetEventNSelTracksIntFlow(iSelParticlesInt);
+ pEvent->SetNumberOfTracks(iGoodTracks);
+ cout<<" iGoodTracks = "<<iGoodTracks<<endl;
+ cout << " iSelectedTracksInt = " << iSelParticlesInt << endl;
+ return pEvent;
}
//-----------------------------------------------------------------------
-AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)
+AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, AliMCEvent* anInputMc, Int_t anOption)
{
//fills the event with tracks from the ESD and kinematics from the MC info via the track label
- if (!(fOption ==0 || fOption ==1)) {
- cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)"<<endl;
+ if (!(anOption ==0 || anOption ==1)) {
+ cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, AliMCEvent* anInputMc, Int_t anOption)"<<endl;
exit(1);
}
- Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
- cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
+ Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
+ cerr<<"anInput->GetNumberOfTracks() = "<<iNumberOfInputTracks<<endl;
- fEvent = new AliFlowEventSimple(10);
+ AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
- //Int_t fN = 256; //multiplicity for chi=1
- Int_t fN = fNumberOfInputTracks;
- Int_t fGoodTracks = 0;
- Int_t ftrkN = 0;
- Int_t fSelParticlesDiff = 0;
- Int_t fSelParticlesInt = 0;
+ //Int_t iN = 256; //multiplicity for chi=1
+ Int_t iN = iNumberOfInputTracks;
+ Int_t iGoodTracks = 0;
+ Int_t itrkN = 0;
+ Int_t iSelParticlesDiff = 0;
+ Int_t iSelParticlesInt = 0;
//normal loop
- while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
- AliESDtrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
+ while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
+ AliESDtrack* pParticle = anInput->GetTrack(itrkN); //get input particle
//get Label
- Int_t fLabel = myParticle->GetLabel();
+ Int_t iLabel = pParticle->GetLabel();
//match to mc particle
- AliMCParticle* fMcParticle = fInputMc->GetTrack(TMath::Abs(fLabel));
+ AliMCParticle* pMcParticle = anInputMc->GetTrack(TMath::Abs(iLabel));
//check
- if (TMath::Abs(myParticle->GetLabel())!=fMcParticle->Label()) cout<<"myParticle->GetLabel()!=fMcParticle->Label() "<<myParticle->GetLabel()<<" "<<fMcParticle->Label()<<endl;
+ if (TMath::Abs(pParticle->GetLabel())!=pMcParticle->Label()) cout<<"pParticle->GetLabel()!=pMcParticle->Label() "<<pParticle->GetLabel()<<" "<<pMcParticle->Label()<<endl;
//cut on tracks
- if (TMath::Abs(myParticle->Eta()) < 0.2)
+ if (TMath::Abs(pParticle->Eta()) < 0.2)
{
if(
- TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 //pions
- // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 ||
- // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 321 ||
- // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 2212
+ TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 211 //pions
+ // TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 211 ||
+ // TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 321 ||
+ // TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 2212
)
{
- if(fOption == 0) { //take the PID from the MC & the kinematics from the ESD
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(myParticle->Pt() );
- fTrack->SetEta(myParticle->Eta() );
- fTrack->SetPhi(myParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
+ AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
+ if(anOption == 0) { //take the PID from the MC & the kinematics from the ESD
+ pTrack->SetPt(pParticle->Pt() );
+ pTrack->SetEta(pParticle->Eta() );
+ pTrack->SetPhi(pParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
}
- else if (fOption == 1) { //take the PID and kinematics from the MC
- fTrack = new AliFlowTrackSimple() ;
- fTrack->SetPt(fMcParticle->Pt() );
- fTrack->SetEta(fMcParticle->Eta() );
- fTrack->SetPhi(fMcParticle->Phi() );
- fTrack->SetForIntegratedFlow(kTRUE);
- fTrack->SetForDifferentialFlow(kTRUE);
+ else if (anOption == 1) { //take the PID and kinematics from the MC
+ pTrack->SetPt(pMcParticle->Pt() );
+ pTrack->SetEta(pMcParticle->Eta() );
+ pTrack->SetPhi(pMcParticle->Phi() );
+ pTrack->SetForIntegratedFlow(kTRUE);
+ pTrack->SetForDifferentialFlow(kTRUE);
}
else { cout<<"Not a valid option"<<endl; }
- if (fTrack->UseForIntegratedFlow())
- { fSelParticlesInt++; }
- if (fTrack->UseForDifferentialFlow())
- { fSelParticlesDiff++; }
- fGoodTracks++;
- fEvent->TrackCollection()->Add(fTrack) ;
+ if (pTrack->UseForIntegratedFlow())
+ { iSelParticlesInt++; }
+ if (pTrack->UseForDifferentialFlow())
+ { iSelParticlesDiff++; }
+ iGoodTracks++;
+ pEvent->TrackCollection()->Add(pTrack) ;
}
}
- ftrkN++;
+ itrkN++;
}
- fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
- fEvent->SetNumberOfTracks(fGoodTracks);
- cout<<" fGoodTracks = "<<fGoodTracks<<endl;
- cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
- return fEvent;
+ pEvent-> SetEventNSelTracksIntFlow(iSelParticlesInt);
+ pEvent->SetNumberOfTracks(iGoodTracks);
+ cout<<" iGoodTracks = "<<iGoodTracks<<endl;
+ cout << " iSelectedTracksInt = " << iSelParticlesInt << endl;
+ return pEvent;
}
#ifndef AliFlowEventSimpleMaker_H
#define AliFlowEventSimpleMaker_H
-#include "AliFlowTrackSimple.h" //needed as include
#include "AliFlowEventSimple.h" //needed as include
-
-//class AliFlowTrackSimple; //does not compile
//class AliFlowEventSimple; //does not compile
class TTree;
-class TParticle;
class AliMCEvent;
class AliESDEvent;
class AliAODEvent;
AliFlowEventSimpleMaker(); //constructor
virtual ~AliFlowEventSimpleMaker(); //destructor
- AliFlowEventSimple* FillTracks(TTree* fInput);
- AliFlowEventSimple* FillTracks(AliMCEvent* fInput);
- AliFlowEventSimple* FillTracks(AliESDEvent* fInput);
- AliFlowEventSimple* FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption);
- // fOption = 0 : kine from ESD
- // fOption = 1 : kine from MC
- AliFlowEventSimple* FillTracks(AliAODEvent* fInput);
+ AliFlowEventSimple* FillTracks(TTree* anInput);
+ AliFlowEventSimple* FillTracks(AliMCEvent* anInput);
+ AliFlowEventSimple* FillTracks(AliESDEvent* anInput);
+ AliFlowEventSimple* FillTracks(AliESDEvent* anInput, AliMCEvent* anInputMc, Int_t anOption);
+ // anOption = 0 : kine from ESD
+ // anOption = 1 : kine from MC
+ AliFlowEventSimple* FillTracks(AliAODEvent* anInput);
private:
-
- AliFlowEventSimpleMaker(const AliFlowEventSimpleMaker& aAnalysis);
- AliFlowEventSimpleMaker& operator=(const AliFlowEventSimpleMaker& aAnalysis);
-
- AliFlowEventSimple* fEvent; //!
- AliFlowTrackSimple* fTrack; //!
- TParticle* fParticle; //!
-
+ AliFlowEventSimpleMaker(const AliFlowEventSimpleMaker& anAnalysis); //copy constructor
+ AliFlowEventSimpleMaker& operator=(const AliFlowEventSimpleMaker& anAnalysis); //assignment operator
+
ClassDef(AliFlowEventSimpleMaker,0) // macro for rootcint
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff