Sumw2 called by default
[u/mrichter/AliRoot.git] / HBTAN / AliHBTMonitorFunction.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 /* $Id$ */
17
18 #include "AliLog.h"
19 #include "AliHBTMonitorFunction.h"
20
21 //__________________________________________________________________
22 ////////////////////////////////////////////////////////////////////
23 //
24 // class AliHBTMonitorFunction
25 //
26 // class AliHBTMonOneParticleFctn
27 // class AliHBTMonTwoParticleFctn
28 //
29 // class AliHBTMonOneParticleFctn1D
30 // class AliHBTMonOneParticleFctn2D
31 // class AliHBTMonOneParticleFctn3D
32 //
33 // class AliHBTMonTwoParticleFctn1D
34 // class AliHBTMonTwoParticleFctn2D
35 // class AliHBTMonTwoParticleFctn3D
36 //
37 // Base Classes for monitoring functions
38 // author: chajecki@if.pw.edu.pl
39 //
40 /******************************************************************/
41 /*
42 Base classes for monitor functions
43
44           monitor function
45                /    \
46               /      \
47              /        \
48             /          \
49            /            \
50           /              \
51          /                \
52    one particle     two particle  
53      /  |  \            /  |  \
54     /   |   \          /   |   \
55    1D  2D   3D        1D  2D   3D
56
57 Zbigniew.Chajecki@cern.ch
58
59 */
60 ///////////////////////////////////////////////////////////////////////
61
62
63 ClassImp( AliHBTMonitorFunction )
64
65 AliHBTMonitorFunction::AliHBTMonitorFunction():
66  fParticleCut(new AliAODParticleEmptyCut())
67 {
68   //ctor
69 }
70 /******************************************************************/
71 AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):
72  TNamed(name,title),
73  fParticleCut(new AliAODParticleEmptyCut())
74 {
75   //ctor
76 }
77 /******************************************************************/
78 AliHBTMonitorFunction::AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/):
79  TNamed(),
80  fParticleCut(new AliAODParticleEmptyCut())
81 {
82   //cpy ctor
83   // We cannot copy because it is a mess with names (histogram and functions)
84   MayNotUse("AliHBTMonitorFunction(const AliHBTMonitorFunction&");
85 }
86 /******************************************************************/
87 AliHBTMonitorFunction& AliHBTMonitorFunction::operator=(const AliHBTMonitorFunction& /*in*/)
88 {
89   //assigment operator 
90   // We cannot copy because it is a mess with names (histogram and functions)
91   MayNotUse("operator=");
92   return *this;
93 }
94 /******************************************************************/
95
96 AliHBTMonitorFunction::~AliHBTMonitorFunction()
97  {
98   //dtor
99   delete fParticleCut;
100  }
101 /******************************************************************/
102
103 void AliHBTMonitorFunction::Write()
104  {
105    //Writes an function to disk
106    if (GetResult()) GetResult()->Write();
107  }
108 /******************************************************************/
109
110 void AliHBTMonitorFunction::Init()
111  {
112    //Writes an function to disk
113    AliDebug(1,"Entering");
114    
115    if (GetResult() == 0x0)
116     {
117       Warning("Init","Function has NULL result histogram!");
118       return;
119     }
120    GetResult()->Reset();
121    GetResult()->SetDirectory(0x0);
122    AliDebug(1,"Done");
123  }
124 /******************************************************************/
125
126 void AliHBTMonitorFunction::SetParticleCut(AliAODParticleCut* cut)
127 {
128 //Sets new Particle Cut. Old one is deleted
129 //Note that it is created new object instead of simple pointer set
130 //I do not want to have pointer 
131 //to object created somewhere else
132 //because in that case I could not believe that 
133 //it would always exist (sb could delete it)
134 //so we have always own copy
135
136  if(!cut) 
137    {
138      Error("AliHBTMonitorFunction::SetParticleCut","argument is NULL");
139      return;
140    }
141  delete fParticleCut;
142  fParticleCut = (AliAODParticleCut*)cut->Clone();
143  
144 }
145 /******************************************************************/
146
147 void AliHBTMonitorFunction::Rename(const Char_t * name)
148  {
149  //renames the function and histograms
150   SetName(name);
151   SetTitle(name);
152   
153   TString numstr = fName + " Result";  //title and name of the 
154                                            //result histogram
155   GetResult()->SetName(numstr.Data());
156   GetResult()->SetTitle(numstr.Data());
157  }
158 /******************************************************************/
159
160 void AliHBTMonitorFunction::Rename(const Char_t * name, const Char_t * title)
161  {
162  //renames and retitle the function and histograms
163  
164   SetName(name);
165   SetTitle(title);
166   
167   TString numstrn = fName + " Result";  //name of the 
168                                            //result histogram
169
170   TString numstrt = fTitle + " Result";  //title of the 
171                                            //result histogram
172                    
173
174   GetResult()->SetName(numstrn.Data());
175   GetResult()->SetTitle(numstrt.Data());
176
177  }
178
179 /******************************************************************/
180 /******************************************************************/
181 /******************************************************************/
182 ClassImp( AliHBTMonOneParticleFctn )  //z.ch.
183 /******************************************************************/
184 /******************************************************************/
185 ClassImp( AliHBTMonTwoParticleFctn )  //z.ch.
186 /******************************************************************/
187 /******************************************************************/
188 /******************************************************************/
189 ClassImp( AliHBTMonOneParticleFctn1D )
190 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D():
191  fResult(0x0)
192  {
193    //ctor
194  }
195 /******************************************************************/
196
197 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
198  {
199    //ctor
200    TString numstr = fName + " Result";  //title and name of the 
201                                            //result histogram
202    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
203    fResult->Sumw2();
204  }
205
206 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
207                     Int_t nbins, Double_t maxXval, Double_t minXval)
208         :AliHBTMonOneParticleFctn(name,title)
209 {
210   //ctor
211    TString numstr = fName + " Result";  //title and name of the 
212                                            //result histogram
213          
214    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
215    fResult->Sumw2();
216    fResult->SetDirectory(0x0);
217    
218 }
219 /******************************************************************/
220 AliHBTMonOneParticleFctn1D::~AliHBTMonOneParticleFctn1D()
221 {
222  //dtor
223  delete fResult;
224 }
225 /******************************************************************/
226
227 void AliHBTMonOneParticleFctn1D::Process(AliVAODParticle* particle)
228 {
229  //Fills the result
230    particle = CheckParticle(particle);
231    if(particle) fResult->Fill(GetValue(particle));
232 }
233 /******************************************************************/
234 /******************************************************************/
235  
236 ClassImp( AliHBTMonOneParticleFctn2D )
237
238 AliHBTMonOneParticleFctn2D::AliHBTMonOneParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval , 
239                     Int_t nYbins, Double_t maxYval, Double_t minYval)
240
241 {
242   //ctor
243    TString numstr = fName + " Result";  //title and name of the 
244                                            //result histogram
245         
246    fResult   = new TH2D(numstr.Data(),numstr.Data(),
247                            nXbins,minXval,maxXval,
248                nYbins,minYval,maxYval);
249    fResult->Sumw2();
250    fResult->SetDirectory(0x0);
251 }         
252 /******************************************************************/
253
254 AliHBTMonOneParticleFctn2D::~AliHBTMonOneParticleFctn2D()
255 {
256   //dtor
257   delete fResult;
258 }
259 void AliHBTMonOneParticleFctn2D::Process(AliVAODParticle* particle)
260 {
261   //fills the function for one particle
262   particle = CheckParticle(particle);
263   if(particle) 
264    { 
265      Double_t x,y;
266      GetValues(particle,x,y);
267      fResult->Fill(x,y);
268    }
269 }
270
271 /******************************************************************/
272 /******************************************************************/
273 /******************************************************************/
274
275 ClassImp( AliHBTMonOneParticleFctn3D)
276
277 AliHBTMonOneParticleFctn3D::
278 AliHBTMonOneParticleFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
279                     Int_t nYbins, Double_t maxYval, Double_t minYval, 
280                     Int_t nZbins, Double_t maxZval, Double_t minZval)
281
282 {
283   //ctor
284    TString numstr = fName + " Result";  //title and name of the 
285                                            //result histogram
286  
287    fResult   = new TH3D(numstr.Data(),numstr.Data(),
288                            nXbins,minXval,maxXval,
289                nYbins,minYval,maxYval,
290                nZbins,minZval,maxZval);
291    fResult->Sumw2();
292    fResult->SetDirectory(0x0);
293
294 }         
295 /******************************************************************/
296
297 AliHBTMonOneParticleFctn3D::~AliHBTMonOneParticleFctn3D()
298 {
299   //dtor
300   delete fResult;
301 }
302 /******************************************************************/
303
304
305 /******************************************************************/
306 /******************************************************************/
307 /******************************************************************/
308 ClassImp( AliHBTMonTwoParticleFctn1D)
309
310 AliHBTMonTwoParticleFctn1D::
311 AliHBTMonTwoParticleFctn1D(Int_t nbins, Double_t maxval, Double_t minval)
312  {
313    //ctor
314    TString numstr = fName + " Result";  //title and name of the 
315                                            //result histogram
316          
317    fResult   = new TH1D(numstr.Data(),numstr.Data(),
318                            nbins,minval,maxval);
319    fResult->Sumw2();
320    fResult->SetDirectory(0x0);
321  }
322
323 AliHBTMonTwoParticleFctn1D::
324 AliHBTMonTwoParticleFctn1D(const Char_t* name, const Char_t* title,
325                     Int_t nbins, Double_t maxval, Double_t minval)
326         :AliHBTMonTwoParticleFctn(name,title)
327  {
328    //ctor
329    TString numstr = fName + " Result";  //title and name of the 
330                                            //result histogram
331
332    fResult   = new TH1D(numstr.Data(),numstr.Data(),
333                            nbins,minval,maxval);
334    fResult->Sumw2();
335    fResult->SetDirectory(0x0);
336  }
337
338
339 /******************************************************************/
340 AliHBTMonTwoParticleFctn1D::~AliHBTMonTwoParticleFctn1D()
341 {
342   //dtor
343   delete fResult;
344 }
345 /******************************************************************/
346 void AliHBTMonTwoParticleFctn1D::
347 Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle)
348 {
349   //fills the function for one particle
350   partparticle  = CheckParticle(partparticle);
351   trackparticle = CheckParticle(trackparticle);
352   if( partparticle && trackparticle) 
353    { 
354      Double_t x = GetValue(trackparticle,partparticle);
355      fResult->Fill(x);
356    }
357 }
358 /******************************************************************/
359 /******************************************************************/
360 /******************************************************************/
361 ClassImp( AliHBTMonTwoParticleFctn2D)
362
363
364 AliHBTMonTwoParticleFctn2D::
365 AliHBTMonTwoParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval , 
366                     Int_t nYbins, Double_t maxYval, Double_t minYval)
367
368 {
369   //ctor
370    TString numstr = fName + " Result";  //title and name of the 
371                                            //result histogram
372          
373    fResult   = new TH2D(numstr.Data(),numstr.Data(),
374                            nXbins,minXval,maxXval,
375                nYbins,minYval,maxYval);
376    fResult->Sumw2();
377    fResult->SetDirectory(0x0);
378 }         
379 /******************************************************************/
380 AliHBTMonTwoParticleFctn2D::~AliHBTMonTwoParticleFctn2D()
381 {
382   //dtor
383   delete fResult;
384 }
385 /******************************************************************/
386 void AliHBTMonTwoParticleFctn2D::
387 Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle)
388 {
389   //fills the function for one particle
390   partparticle  = CheckParticle(partparticle);
391   trackparticle = CheckParticle(trackparticle);
392   if( partparticle && trackparticle) 
393    { 
394      Double_t x,y;
395      GetValues(trackparticle,partparticle,x,y);
396      fResult->Fill(x,y);
397    }
398 }
399 /******************************************************************/
400 /******************************************************************/
401 /******************************************************************/
402 ClassImp(AliHBTMonTwoParticleFctn3D)
403
404 void AliHBTMonTwoParticleFctn3D::
405 Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle)
406 {
407   //fills the function for one particle
408   partparticle  = CheckParticle(partparticle);
409   trackparticle = CheckParticle(trackparticle);
410   if( partparticle && trackparticle) 
411    { 
412      Double_t x,y,z;
413      GetValues(trackparticle,partparticle,x,y,z);
414      fResult->Fill(x,y,z);
415    }
416 }
417 /******************************************************************/
418 /******************************************************************/
419 /******************************************************************/
420 /******************************************************************/
421