fix for memory leak after using selections
[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommonHist.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 #include "Riostream.h"              //needed as include
17 #include "AliFlowCommonConstants.h" //needed as include
18 #include "AliFlowCommonHist.h"
19 #include "AliFlowEventSimple.h"
20 #include "AliFlowTrackSimple.h"
21
22 #include "TString.h" 
23 #include "TProfile.h"
24 #include "TMath.h"   //needed as include
25 #include "TList.h"
26 #include "AliFlowVector.h"
27 #include "TBrowser.h"
28
29 class TH1F;
30 class TH1D;
31
32 // AliFlowCommonHist:
33 //
34 // Description: Class to organise common histograms for Flow Analysis
35
36 // authors: N. van der Kolk (kolk@nikhef.nl), A. Bilandzic (anteb@nikhef.nl), RS
37
38
39 ClassImp(AliFlowCommonHist)
40
41 //-----------------------------------------------------------------------
42
43 AliFlowCommonHist::AliFlowCommonHist():TNamed(),
44   fHistMultOrig(NULL),
45   fHistMultInt(NULL),
46   fHistMultDiff(NULL),
47   fHistPtInt(NULL),
48   fHistPtDiff(NULL),
49   fHistPhiInt(NULL),
50   fHistPhiDiff(NULL),
51   fHistEtaInt(NULL),
52   fHistEtaDiff(NULL),
53   fHistProMeanPtperBin(NULL),
54   fHistQ(NULL),
55   fHistList(NULL)
56 {
57   
58   //default constructor
59   
60 }
61
62 AliFlowCommonHist::AliFlowCommonHist(const AliFlowCommonHist& a):
63   TNamed(),
64   fHistMultOrig(new TH1F(*a.fHistMultOrig)),
65   fHistMultInt(new TH1F(*a.fHistMultInt)),
66   fHistMultDiff(new TH1F(*a.fHistMultDiff)),
67   fHistPtInt(new TH1F(*a.fHistPtInt)),
68   fHistPtDiff(new TH1F(*a.fHistPtDiff)),
69   fHistPhiInt(new TH1F(*a.fHistPhiInt)),
70   fHistPhiDiff(new TH1F(*a.fHistPhiDiff)),
71   fHistEtaInt(new TH1F(*a.fHistEtaInt)),
72   fHistEtaDiff(new TH1F(*a.fHistEtaDiff)),
73   fHistProMeanPtperBin(new TProfile(*a.fHistProMeanPtperBin)),
74   fHistQ(new TH1F(*a.fHistQ)),
75   fHistList(NULL)
76 {
77   // copy constructor
78
79   fHistList = new TList();
80   fHistList-> Add(fHistMultOrig);        
81   fHistList-> Add(fHistMultInt);        
82   fHistList-> Add(fHistMultDiff);       
83   fHistList-> Add(fHistPtInt);          
84   fHistList-> Add(fHistPtDiff);         
85   fHistList-> Add(fHistPhiInt);          
86   fHistList-> Add(fHistPhiDiff);         
87   fHistList-> Add(fHistEtaInt);          
88   fHistList-> Add(fHistEtaDiff);         
89   fHistList-> Add(fHistProMeanPtperBin); 
90   fHistList-> Add(fHistQ);           
91   //  TListIter next = TListIter(a.fHistList);
92
93 }
94
95 // AliFlowCommonHist& AliFlowCommonHist::operator=(const AliFlowCommonHist& a) 
96 // {
97 //   *fHistMultOrig = *a.fHistMultOrig;
98 //   *fHistMultInt = *a.fHistMultInt;
99 //   *fHistMultDiff = *a.fHistMultDiff;
100 //   *fHistPtInt = *a.fHistPtInt;
101 //   *fHistPtDiff = *a.fHistPtDiff;
102 //   *fHistPhiInt = *a.fHistPhiInt;
103 //   *fHistPhiDiff = *a.fHistPhiDiff;
104 //   *fHistEtaInt = *a.fHistEtaInt;
105 //   *fHistEtaDiff = *a.fHistEtaDiff;
106 //   *fHistProMeanPtperBin = *a.fHistProMeanPtperBin;
107 //   *fHistQ = *a.fHistQ;
108 //   //  *fHistList = *a.fHistList;
109 //   fHistList = NULL;
110  
111 //   return *this;
112 // }
113
114 //-----------------------------------------------------------------------
115
116   AliFlowCommonHist::AliFlowCommonHist(const char *anInput,const char *title):TNamed(anInput,title),
117    fHistMultOrig(NULL),
118    fHistMultInt(NULL),
119    fHistMultDiff(NULL),
120    fHistPtInt(NULL),
121    fHistPtDiff(NULL),
122    fHistPhiInt(NULL),
123    fHistPhiDiff(NULL),
124    fHistEtaInt(NULL),
125    fHistEtaDiff(NULL),
126    fHistProMeanPtperBin(NULL),
127    fHistQ(NULL),
128    fHistList(NULL)
129  {
130
131   //constructor creating histograms 
132   Int_t iNbinsMult = AliFlowCommonConstants::GetNbinsMult();
133   Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
134   Int_t iNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
135   Int_t iNbinsEta = AliFlowCommonConstants::GetNbinsEta();
136   Int_t iNbinsQ = AliFlowCommonConstants::GetNbinsQ();
137   TString sName;
138
139   Double_t  dMultMin = AliFlowCommonConstants::GetMultMin();            
140   Double_t  dMultMax = AliFlowCommonConstants::GetMultMax();
141   Double_t  dPtMin = AliFlowCommonConstants::GetPtMin();             
142   Double_t  dPtMax = AliFlowCommonConstants::GetPtMax();
143   Double_t  dPhiMin = AliFlowCommonConstants::GetPhiMin();           
144   Double_t  dPhiMax = AliFlowCommonConstants::GetPhiMax();
145   Double_t  dEtaMin = AliFlowCommonConstants::GetEtaMin();           
146   Double_t  dEtaMax = AliFlowCommonConstants::GetEtaMax();           
147   Double_t  dQMin = AliFlowCommonConstants::GetQMin();       
148   Double_t  dQMax = AliFlowCommonConstants::GetQMax();  
149   
150   cout<<"The settings for the common histograms are as follows:"<<endl;
151   cout<<"Multiplicity: "<<iNbinsMult<<" bins between "<<dMultMin<<" and "<<dMultMax<<endl;
152   cout<<"Pt: "<<iNbinsPt<<" bins between "<<dPtMin<<" and "<<dPtMax<<endl;
153   cout<<"Phi: "<<iNbinsPhi<<" bins between "<<dPhiMin<<" and "<<dPhiMax<<endl;
154   cout<<"Eta: "<<iNbinsEta<<" bins between "<<dEtaMin<<" and "<<dEtaMax<<endl;
155   cout<<"Q: "<<iNbinsQ<<" bins between "<<dQMin<<" and "<<dQMax<<endl;
156
157   //Multiplicity
158   sName = "Control_Flow_OrigMult_";
159   sName +=anInput;
160   fHistMultOrig = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
161   fHistMultOrig ->SetXTitle("Original Multiplicity");
162   fHistMultOrig ->SetYTitle("Counts");
163
164   sName = "Control_Flow_MultInt_";
165   sName +=anInput;
166   fHistMultInt = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
167   fHistMultInt ->SetXTitle("Multiplicity for integrated flow");
168   fHistMultInt ->SetYTitle("Counts");
169
170   sName = "Control_Flow_MultDiff_";
171   sName +=anInput;
172   fHistMultDiff = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
173   fHistMultDiff ->SetXTitle("Multiplicity for differential flow");
174   fHistMultDiff ->SetYTitle("Counts");
175
176   //Pt
177   sName = "Control_Flow_PtInt_";
178   sName +=anInput;
179   fHistPtInt = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax); 
180   fHistPtInt ->SetXTitle("Pt (GeV/c) for integrated flow");
181   fHistPtInt ->SetYTitle("Counts");
182
183   sName = "Control_Flow_PtDiff_";
184   sName +=anInput;
185   fHistPtDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax); 
186   //binning has to be the same as for fHistProVPt! use to get Nprime!
187   fHistPtDiff ->SetXTitle("Pt (GeV/c) for differential flow");
188   fHistPtDiff ->SetYTitle("Counts");
189
190   //Phi
191   sName = "Control_Flow_PhiInt_";
192   sName +=anInput;
193   fHistPhiInt = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
194   fHistPhiInt ->SetXTitle("Phi for integrated flow");
195   fHistPhiInt ->SetYTitle("Counts");
196
197   sName = "Control_Flow_PhiDiff_";
198   sName +=anInput;
199   fHistPhiDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
200   fHistPhiDiff ->SetXTitle("Phi for differential flow");
201   fHistPhiDiff ->SetYTitle("Counts");
202
203   //Eta
204   sName = "Control_Flow_EtaInt_";
205   sName +=anInput;
206   fHistEtaInt = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
207   fHistEtaInt ->SetXTitle("Eta for integrated flow");
208   fHistEtaInt ->SetYTitle("Counts");
209
210   sName = "Control_Flow_EtaDiff_";
211   sName +=anInput;
212   fHistEtaDiff = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
213   fHistEtaDiff ->SetXTitle("Eta for differential flow");
214   fHistEtaDiff ->SetYTitle("Counts");
215
216   //Mean Pt per pt bin 
217   sName = "Control_FlowPro_MeanPtperBin_";
218   sName +=anInput;
219   fHistProMeanPtperBin = new TProfile(sName.Data(), sName.Data(),iNbinsPt,dPtMin,dPtMax);
220   fHistProMeanPtperBin ->SetXTitle("Pt");
221   fHistProMeanPtperBin ->SetYTitle("<Pt>");
222
223   //Q vector
224   sName = "Control_Flow_Q_";
225   sName +=anInput;
226   fHistQ = new TH1F(sName.Data(), sName.Data(),iNbinsQ, dQMin, dQMax);
227   fHistQ ->SetXTitle("Qvector/Mult");
228   fHistQ ->SetYTitle("Counts");  
229
230   //list of histograms if added here also add in copy constructor
231   fHistList = new TList();
232   fHistList-> Add(fHistMultOrig);        
233   fHistList-> Add(fHistMultInt);        
234   fHistList-> Add(fHistMultDiff);       
235   fHistList-> Add(fHistPtInt);          
236   fHistList-> Add(fHistPtDiff);         
237   fHistList-> Add(fHistPhiInt);          
238   fHistList-> Add(fHistPhiDiff);         
239   fHistList-> Add(fHistEtaInt);          
240   fHistList-> Add(fHistEtaDiff);         
241   fHistList-> Add(fHistProMeanPtperBin); 
242   fHistList-> Add(fHistQ);           
243
244
245
246 }
247
248
249 //----------------------------------------------------------------------- 
250
251 AliFlowCommonHist::~AliFlowCommonHist()
252 {
253   //deletes histograms
254   delete fHistMultOrig;      
255   delete fHistMultInt;       
256   delete fHistMultDiff;      
257   delete fHistPtInt;         
258   delete fHistPtDiff;       
259   delete fHistPhiInt;        
260   delete fHistPhiDiff;       
261   delete fHistEtaInt;        
262   delete fHistEtaDiff;
263   delete fHistProMeanPtperBin;
264   delete fHistQ;
265   delete fHistList;
266 }
267
268
269 //----------------------------------------------------------------------- 
270
271 Bool_t AliFlowCommonHist::FillControlHistograms(AliFlowEventSimple* anEvent)
272 {
273   //Fills the control histograms
274   if (!anEvent){
275     cout<<"##### FillControlHistograms: FlowEvent pointer null"<<endl;
276     return kFALSE;
277   }
278
279   Double_t dPt, dPhi, dEta;
280
281
282   //fill the histograms
283   Int_t iNumberOfTracks = anEvent->NumberOfTracks();
284   fHistMultOrig->Fill(iNumberOfTracks);
285
286   AliFlowVector vQ = anEvent->GetQ(); 
287   //weight by the Multiplicity
288   Double_t dQX = 0.;
289   Double_t dQY = 0.;
290   if (vQ.GetMult()!=0) {
291     dQX = vQ.X()/vQ.GetMult();
292     dQY = vQ.Y()/vQ.GetMult();
293   }
294   vQ.Set(dQX,dQY);
295   fHistQ->Fill(vQ.Mod());
296
297   Int_t iMultInt = 0;
298   Int_t iMultDiff = 0;
299   
300   AliFlowTrackSimple* pTrack = NULL;     
301
302   for (Int_t i=0;i<iNumberOfTracks;i++) {
303     pTrack = anEvent->GetTrack(i);
304     if (pTrack ) {
305       if (pTrack->UseForIntegratedFlow()){
306         dPt = pTrack->Pt();
307         fHistPtInt->Fill(dPt);
308         dPhi = pTrack->Phi();
309         if (dPhi<0.) dPhi+=2*TMath::Pi();
310         fHistPhiInt->Fill(dPhi);
311         dEta = pTrack->Eta();
312         fHistEtaInt->Fill(dEta);
313         iMultInt++;
314       }
315       if (pTrack->UseForDifferentialFlow()){
316         dPt = pTrack->Pt();
317         fHistPtDiff->Fill(dPt);
318         dPhi = pTrack->Phi();
319         if (dPhi<0.) dPhi+=2*TMath::Pi();
320         fHistPhiDiff->Fill(dPhi);
321         dEta = pTrack->Eta();
322         fHistEtaDiff->Fill(dEta);
323         fHistProMeanPtperBin->Fill(dPt,dPt);
324         iMultDiff++;
325       }
326     } //track
327   } //loop over tracks
328   
329   fHistMultInt->Fill(iMultInt);
330   fHistMultDiff->Fill(iMultDiff);
331
332   return kTRUE; 
333 }
334
335 //----------------------------------------------------------------------- 
336
337 Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t aBin)
338 {
339   //get entries in bin aBin from fHistPtDiff
340   Double_t dEntries = fHistPtDiff->GetBinContent(aBin);
341
342   return dEntries;
343
344 }
345
346 //----------------------------------------------------------------------- 
347
348 Double_t AliFlowCommonHist::GetMeanPt(Int_t aBin)
349 {  
350   //Get entry from bin aBin from fHistProMeanPtperBin
351   Double_t dMeanPt = fHistProMeanPtperBin->GetBinContent(aBin);
352
353   return dMeanPt;
354   
355 }
356
357
358 //----------------------------------------------------------------------- 
359  Double_t AliFlowCommonHist::Merge(TCollection *aList)
360 {
361   //merge fuction
362   cout<<"entering merge function"<<endl;
363   if (!aList) return 0;
364   if (aList->IsEmpty()) return 0; //no merging is needed
365
366   Int_t iCount = 0;
367   TIter next(aList); // list is supposed to contain only objects of the same type as this
368   AliFlowCommonHist *toMerge;
369   // make a temporary list
370   TList *pTemp = new TList();
371   while ((toMerge=(AliFlowCommonHist*)next())) {
372     pTemp->Add(toMerge->GetHistList()); 
373     iCount++;
374   }
375   // Now call merge for fHistList providing temp list
376   fHistList->Merge(pTemp);
377   // Cleanup
378   delete pTemp;
379     
380   cout<<"Merged"<<endl;
381   return (double)iCount;
382     
383 }
384
385 void AliFlowCommonHist::Print(Option_t *option) const
386 {
387   //   -*-*-*-*-*Print some global quantities for this histogram collection class *-*-*-*-*-*-*-*
388   //             ===============================================
389   //   printf( "TH1.Print Name  = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
390   printf( "Class.Print Name = %s, Histogram list:\n",GetName());
391
392   if (fHistList) {  
393     fHistList->Print(option);
394   }
395   else
396     {
397       printf( "Empty histogram list \n");
398     }
399 }
400
401 //----------------------------------------------------------------------- 
402  void AliFlowCommonHist::Browse(TBrowser *b)
403 {
404
405   if (!b) return;
406   if (fHistList) b->Add(fHistList,"AliFlowCommonHistList");
407 }
408
409
410
411