Major update of the HFE package (comments inside the code
[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEvarManager.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 // Class AliHFEvarManager:
17 // Contains definition of the variables which are filled into the 
18 // Correction framework container. The class handles both AliCFContainer and
19 // AliHFEcontainer.
20 // Defining a new variable which has to be monitored can be done via the
21 // function AddVariable. This function also defines a new dimension for the
22 // particle container and appends it to the list of variables. For a new
23 // track the function NewTrack caches the values to be filled into the 
24 // correction framework container. With FillContainer the specified 
25 // correction framework container is filled. The VarManager also handles
26 // the filling of the correlation matrices
27 //
28 // Author:
29 //   Markus Fasel <M.Fasel@gsi.de>
30 //
31 #include <TClass.h>
32 #include <TH3.h>
33 #include <TF3.h>
34 #include <TMath.h>
35 #include <THnSparse.h>
36 #include <TString.h>
37
38 #include "AliCFContainer.h"
39 #include "AliLog.h"
40 #include "AliVParticle.h"
41
42 #include "AliHFEcontainer.h"
43 #include "AliHFEsignalCuts.h"
44 #include "AliHFEvarManager.h"
45
46 ClassImp(AliHFEvarManager)
47 ClassImp(AliHFEvarManager::AliHFEvariable);
48
49 //____________________________________________________________
50 AliHFEvarManager::AliHFEvarManager():
51   TNamed(),
52   fVariables(NULL),
53   fContent(NULL),
54   fContentMC(NULL),
55   fWeightFactor(1.),
56   fSignalTrack(kTRUE),
57         fWeighting(kFALSE),
58   fSignal(NULL),
59         fWeightFactors(NULL),
60         fWeightFactorsFunction(NULL)
61 {
62         //
63         // Dummy constructor
64   //
65   SetOwner();
66 }
67
68 //____________________________________________________________
69 AliHFEvarManager::AliHFEvarManager(const Char_t *name):
70   TNamed(name, ""),
71   fVariables(NULL),
72   fContent(NULL),
73   fContentMC(NULL),
74   fWeightFactor(1.),
75   fSignalTrack(kTRUE),
76         fWeighting(kFALSE),
77   fSignal(NULL),
78         fWeightFactors(NULL),
79         fWeightFactorsFunction(NULL)
80 {
81         //
82         // Default constructor
83   //
84   fVariables = new TObjArray;
85   SetOwner();
86 }
87
88 //____________________________________________________________
89 AliHFEvarManager::AliHFEvarManager(const AliHFEvarManager &ref):
90   TNamed(ref),
91   fVariables(NULL),
92   fContent(NULL),
93   fContentMC(NULL),
94   fWeightFactor(ref.fWeightFactor),
95   fSignalTrack(ref.fSignalTrack),
96         fWeighting(ref.fWeighting),
97   fSignal(NULL),
98         fWeightFactors(NULL),
99         fWeightFactorsFunction(NULL)
100 {
101   //
102   // Copy Constructor
103   //
104   ref.Copy(*this);
105 }
106
107 //____________________________________________________________
108 AliHFEvarManager &AliHFEvarManager::operator=(const AliHFEvarManager &ref){
109   //
110   // Assignment operator
111   //
112   if(&ref != this){ 
113     this->~AliHFEvarManager();
114     ref.Copy(*this);
115   }
116   return *this;
117 }
118
119 //____________________________________________________________
120 AliHFEvarManager::~AliHFEvarManager(){
121         //
122         // Destructor
123         //
124   if(IsOwner()){
125     if(fVariables) delete fVariables;
126   }
127   if(fContent) delete[] fContent;
128   if(fContentMC) delete[] fContentMC;
129 }
130
131 //____________________________________________________________
132 void AliHFEvarManager::Copy(TObject &o) const{
133   //
134   // Make Copy
135   //
136   AliHFEvarManager &target = dynamic_cast<AliHFEvarManager &>(o);
137   target.fVariables = fVariables;
138   target.fContent = new Double_t[sizeof(fContent)/sizeof(Double_t)]; 
139   target.fContentMC = new Double_t[sizeof(fContentMC)/sizeof(Double_t)];
140   target.fWeightFactor = fWeightFactor;
141   target.fSignalTrack = fSignalTrack;
142         target.fWeighting = fWeighting;
143   target.fSignal = fSignal;
144         target.fWeightFactors = fWeightFactors;
145   target.fWeightFactorsFunction = fWeightFactorsFunction; 
146   target.SetOwner(kFALSE);
147 }
148
149 //____________________________________________________________
150 void AliHFEvarManager::AddVariable(TString name){
151   //
152   // Add new variable to the var manager
153   // Value derived via GetValue()
154   //
155    AliDebug(1, Form("Var Name: %s", name.Data()));
156
157   if(!name.CompareTo("pt")) 
158     fVariables->AddLast(new AliHFEvariable("pt", "pt", kPt, 44, 0.1, 20, kTRUE));
159   else if(!name.CompareTo("eta"))
160     fVariables->AddLast(new AliHFEvariable("eta", "eta", kEta, 8, -0.8, 0.8));
161   else if(!name.CompareTo("phi"))
162     fVariables->AddLast(new AliHFEvariable("phi", "phi", kPhi, 18, -0, 2*TMath::Pi()));
163   else if(!name.CompareTo("charge"))
164     fVariables->AddLast(new AliHFEvariable("charge", "charge", kCharge, 2, -1.1, 1.1));
165   else if(!name.CompareTo("source"))
166     fVariables->AddLast(new AliHFEvariable("source", "source", kSource, 4, 0, 4));
167   else if(!name.CompareTo("centrality"))
168     fVariables->AddLast(new AliHFEvariable("centrality", "centrality", kCentrality, 20, 0.0, 100.0));
169   else if(!name.CompareTo("species"))
170     fVariables->AddLast(new AliHFEvariable("species", "species", kSpecies, 6, -1, 5));
171
172   // More to come ...
173 }
174
175 //____________________________________________________________
176 void AliHFEvarManager::DefineVariables(AliHFEcontainer *cont){
177         //
178         // Define Variables
179         //
180   Int_t nVars = fVariables->GetEntriesFast();
181   cont->SetNumberOfVariables(nVars);
182   TIter vars(fVariables);
183   AliHFEvariable *var;
184   Int_t counter = 0;
185   while((var = dynamic_cast<AliHFEvariable *>(vars()))){
186     cont->SetVariableName(counter, var->GetName());
187     if(var->IsLogarithmic())
188       cont->MakeLogarithmicBinning(counter, var->GetNumberOfBins(), var->GetMinimum(), var->GetMaximum());
189     else
190       cont->MakeLinearBinning(counter, var->GetNumberOfBins(), var->GetMinimum(), var->GetMaximum());
191     counter++;
192   }
193         fContent = new Double_t[nVars]; 
194   memset(fContent, 0, sizeof(Double_t) * nVars);
195   fContentMC = new Double_t[nVars]; 
196   memset(fContentMC, 0, sizeof(Double_t) * nVars);
197 }
198
199 //____________________________________________________________
200 void AliHFEvarManager::NewTrack(AliVParticle *recTrack, AliVParticle *mcTrack, Float_t centrality, Int_t aprioriPID, Bool_t signal){
201   //
202   // Cache information for new track pair
203   //
204   AliDebug(1, "Filling new Track");
205   fSignalTrack = signal;
206   FillArray(recTrack, fContent, centrality, aprioriPID);
207   if(mcTrack) FillArray(mcTrack, fContentMC, centrality, aprioriPID);
208   if(fWeighting){
209     Int_t indexpt = -1, indexeta = -1, indexphi = -1, counter = 0;
210     AliHFEvariable *var = NULL;
211     TIter vars(fVariables);
212     while((var = dynamic_cast<AliHFEvariable *>(vars()))){
213       switch(var->GetVarCode()){
214         case kPt:   indexpt = counter;  break;
215         case kEta:  indexeta = counter; break;
216         case kPhi:  indexphi = counter; break;
217       };
218       if(indexpt >= 0 && indexeta >= 0 && indexphi >= 0) // all dimensions found
219         break;
220       counter++;
221     }
222     if(indexpt >= 0 && indexeta >= 0 && indexphi >= 0)
223       fWeightFactor = FindWeight(fContent[indexpt], fContent[indexeta], fContent[indexphi]);
224   }
225 }
226
227 //____________________________________________________________
228 Double_t AliHFEvarManager::GetValue(AliVParticle *track, UInt_t code, Float_t centrality, Int_t aprioriPID) const {
229   //
230   // Definition of the variables
231   //
232   if(!track) return 0.;
233   Double_t value = 0.;
234   switch(code){
235     case kPt:       value = track->Pt();  break;
236     case kEta:      value = track->Eta(); break;
237     case kPhi:      value = track->Phi(); break;
238     case kCharge:{
239       value = track->Charge();
240       if(TString(track->IsA()->GetName()).Contains("MC")) value /= 3;
241       break;
242     }
243     case kSource:{
244       if(fSignal){
245               if(fSignal->IsCharmElectron(track)) value = 0;
246               else if(fSignal->IsBeautyElectron(track)) value = 1;
247               else if(fSignal->IsGammaElectron(track)) value = 2;
248               else value = 3;
249       }
250       break;
251     }
252     case kSpecies:  value = aprioriPID; break; 
253     case kCentrality:  value = centrality; break;  
254   };
255   return value;
256 }
257
258 //____________________________________________________________
259 void AliHFEvarManager::FillArray(AliVParticle *track, Double_t* container, Float_t centrality, Int_t aprioriPID) const{
260         //
261         // Fill array with variables
262         //
263   TIter vars(fVariables);
264   AliHFEvariable *var = NULL;
265   Int_t counter = 0;
266   while((var = dynamic_cast<AliHFEvariable *>(vars())))
267     container[counter++] = GetValue(track , var->GetVarCode(), centrality, aprioriPID);
268 }
269
270 //____________________________________________________________
271 void AliHFEvarManager::FillContainer(AliCFContainer *cont, Int_t step, Bool_t useMC) const{
272         //
273         // Fill CF container with defined content
274         //
275
276         // Do reweighting if necessary
277   Double_t *content = fContent;
278   if(useMC) content = fContentMC;
279         cont->Fill(content, step, fWeightFactor);
280 }
281
282 //____________________________________________________________
283 void AliHFEvarManager::FillContainer(AliHFEcontainer *cont, const Char_t *contname, UInt_t step, Bool_t useMC, Double_t externalWeight) const {
284         //
285         // Fill CF container with defined content
286         //
287
288   // Do reweighting if necessary
289   Double_t *content = fContent;
290   if(useMC) content = fContentMC;
291         cont->FillCFContainer(contname, step, content, fWeightFactor * externalWeight);
292 }  
293
294 //____________________________________________________________
295 void AliHFEvarManager::FillContainerStepname(AliHFEcontainer *cont, const Char_t *contname, const Char_t *step, Bool_t useMC, Double_t externalWeight) const {
296         //
297         // Fill CF container with defined content
298         //
299
300   // Do reweighting if necessary
301   Double_t *content = fContent;
302   if(useMC) content = fContentMC;
303         cont->FillCFContainerStepname(contname, step, content, fWeightFactor * externalWeight);
304 }  
305
306 //____________________________________________________________
307 void AliHFEvarManager::FillCorrelationMatrix(THnSparseF *matrix) const {
308         //
309         // Fill Correlation Matrix
310         //
311
312         // Do reweighting if necessary
313   Double_t content[10];
314   memcpy(content, fContent, sizeof(Double_t) * 5);
315   memcpy(&content[5], fContentMC, sizeof(Double_t) * 5);
316         matrix->Fill(content, fWeightFactor);
317 }
318
319 //_______________________________________________
320 void AliHFEvarManager::SetWeightFactors(TH3F *weightFactors){
321         //
322         // Set the histos with the weights for the efficiency maps
323         //
324         fWeighting = kTRUE;
325         fWeightFactors = weightFactors;
326 }
327
328 //_______________________________________________
329 void AliHFEvarManager::SetWeightFactorsFunction(TF3 *weightFactorsFunction){
330         //
331         // Set the histos with the weights for the efficiency maps
332         //
333         fWeighting = kTRUE;
334         fWeightFactorsFunction = weightFactorsFunction;
335 }
336
337 //_______________________________________________
338 Double_t AliHFEvarManager::FindWeight(Double_t pt, Double_t eta, Double_t phi) const {
339         //
340         // Find the weight corresponding to pt eta and phi in the TH3D
341         //
342         Double_t weight = 1.0;
343         if(fWeightFactors) {
344
345                 TAxis *ptaxis = fWeightFactors->GetXaxis();
346                 TAxis *etaaxis = fWeightFactors->GetYaxis();
347                 TAxis *phiaxis = fWeightFactors->GetZaxis();
348
349                 Int_t ptbin = ptaxis->FindBin(pt);
350                 Int_t etabin = etaaxis->FindBin(eta);
351                 Int_t phibin = phiaxis->FindBin(phi);
352
353
354                 weight = fWeightFactors->GetBinContent(ptbin,etabin,phibin);
355         }
356         else if(fWeightFactorsFunction) {
357
358                 weight = fWeightFactorsFunction->Eval(pt,eta,phi);
359
360         }
361
362         AliDebug(2, Form("pt %f, eta %f, phi %f, weight %f",pt,eta,phi,weight));
363
364         return weight;
365 }
366
367 //_______________________________________________
368 AliHFEvarManager::AliHFEvariable::AliHFEvariable():
369     TNamed()
370   , fCode(0)
371   , fNBins(0)
372   , fMin(0)
373   , fMax(0)
374   , fIsLogarithmic(kFALSE)
375 {
376   // 
377   // Dummy constructor
378   //
379 }
380
381 //_______________________________________________
382 AliHFEvarManager::AliHFEvariable::AliHFEvariable(const Char_t *name, const Char_t *title, UInt_t code, UInt_t nBins, Double_t min, Double_t max, Bool_t isLogarithmic):
383     TNamed(name, title)
384   , fCode(code)
385   , fNBins(nBins)
386   , fMin(min)
387   , fMax(max)
388   , fIsLogarithmic(isLogarithmic)
389 {
390   // 
391   // Default constructor
392   //
393 }
394
395 //_______________________________________________
396 AliHFEvarManager::AliHFEvariable::AliHFEvariable(const AliHFEvarManager::AliHFEvariable &ref):
397     TNamed(ref)
398   , fCode(ref.fCode)
399   , fNBins(ref.fNBins)
400   , fMin(ref.fMin)
401   , fMax(ref.fMax)
402   , fIsLogarithmic(ref.fIsLogarithmic)
403 {
404   // 
405   // Copy constructor
406   //
407 }
408
409 //_______________________________________________
410 AliHFEvarManager::AliHFEvariable& AliHFEvarManager::AliHFEvariable::operator=(const AliHFEvarManager::AliHFEvariable &ref){
411   //
412   // Assignment operator
413   //
414   
415   if(&ref != this){
416     TNamed::operator=(ref);
417     fCode = ref.fCode;
418     fNBins = ref.fNBins;
419     fMax = ref.fMax;
420     fMin = ref.fMin;
421     fIsLogarithmic = ref.fIsLogarithmic;
422   }
423   return *this;
424 }
425