Added new background scheeme, did some cleanup. added new bethe block parameters...
[u/mrichter/AliRoot.git] / PWG4 / GammaConv / AliGammaConversionBGHandler.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt                        *
5  * Version 1.0                                                            *
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 ////////////////////////////////////////////////
17 //--------------------------------------------- 
18 // Class for handling of background calculation
19 //---------------------------------------------
20 ////////////////////////////////////////////////
21
22 #include "AliGammaConversionBGHandler.h"
23 #include "AliKFParticle.h"
24 #include "AliAnalysisTaskGammaConversion.h"
25
26 using namespace std;
27
28 ClassImp(AliGammaConversionBGHandler)
29
30 AliGammaConversionBGHandler::AliGammaConversionBGHandler() :
31   TObject(),
32   fNEvents(10),
33   fBGEventCounter(NULL),
34   fNBinsZ(0),
35   fNBinsMultiplicity(0),
36   fBinLimitsArrayZ(NULL),
37   fBinLimitsArrayMultiplicity(NULL),
38   fBGEvents()
39 {
40   // constructor
41 }
42
43 AliGammaConversionBGHandler::AliGammaConversionBGHandler(UInt_t binsZ,UInt_t binsMultiplicity,UInt_t nEvents) :
44   TObject(),
45   fNEvents(nEvents),
46   fBGEventCounter(NULL),
47   fNBinsZ(binsZ),
48   fNBinsMultiplicity(binsMultiplicity),
49   fBinLimitsArrayZ(NULL),
50   fBinLimitsArrayMultiplicity(NULL),
51   fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
52 {
53   // constructor
54 }
55
56 AliGammaConversionBGHandler::AliGammaConversionBGHandler(const AliGammaConversionBGHandler & original) :
57   TObject(original),
58   fNEvents(original.fNEvents),
59   fBGEventCounter(original.fBGEventCounter),
60   fNBinsZ(original.fNBinsZ),
61   fNBinsMultiplicity(original.fNBinsMultiplicity),
62   fBinLimitsArrayZ(original.fBinLimitsArrayZ),
63   fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity),
64   fBGEvents(original.fBGEvents)
65 {
66   //copy constructor    
67 }
68
69 AliGammaConversionBGHandler & AliGammaConversionBGHandler::operator = (const AliGammaConversionBGHandler & /*source*/)
70 {
71   // assignment operator
72   return *this;
73 }
74
75 AliGammaConversionBGHandler::~AliGammaConversionBGHandler(){
76
77   //Kenneth remember to clear memory!!!!!!!!!!!!!!!!!!!!!
78   if(fBGEventCounter){
79     for(Int_t z=0;z<fNBinsZ;z++){
80       delete[] fBGEventCounter[z];
81     }
82     delete[] fBGEventCounter;
83     fBGEventCounter = NULL;
84   }
85   
86   if(fBinLimitsArrayZ){
87     delete[] fBinLimitsArrayZ;
88   }
89
90   if(fBinLimitsArrayMultiplicity){
91     delete[] fBinLimitsArrayMultiplicity;
92   }
93 }
94
95 void AliGammaConversionBGHandler::Initialize(Double_t *zBinLimitsArray, Double_t *multiplicityBinLimitsArray){
96   // see header file for documantation  
97
98   if(zBinLimitsArray){
99     fBinLimitsArrayZ = zBinLimitsArray;
100   }
101   else{
102     //Print warning
103   }
104   
105   if(multiplicityBinLimitsArray){
106     fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ;
107   }
108   else{
109     //Print warning
110   }
111   fBGEventCounter= new Int_t*[fNBinsZ];
112   for(Int_t z=0;z<fNBinsZ;z++){
113     fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
114   }
115 }
116
117 Int_t AliGammaConversionBGHandler::GetZBinIndex(Double_t zvalue){
118   // see header file for documantation
119   if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){
120     return 0;
121   }
122
123   for(Int_t i=0; i<fNBinsZ-1 ;i++){
124     if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
125       return i;
126     }
127   }
128   return fNBinsZ-1;
129 }
130
131 Int_t AliGammaConversionBGHandler::GetMultiplicityBinIndex(Int_t multiplicity){
132   // see header file for documantation  
133   if(fNBinsMultiplicity<2){
134     return 0;
135   }
136
137   for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){
138     if(multiplicity > fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
139       return i;
140     }
141   }
142   return fNBinsMultiplicity-1;
143 }
144
145 void AliGammaConversionBGHandler::AddEvent(TClonesArray * eventGammas, Double_t zvalue, Int_t multiplicity){
146   // see header file for documantation  
147
148   Int_t z = GetZBinIndex(zvalue);
149   Int_t m = GetMultiplicityBinIndex(multiplicity);
150
151   if(fBGEventCounter[z][m] >= fNEvents -1){
152     fBGEventCounter[z][m]=0;
153   }
154   Int_t eventCounter=fBGEventCounter[z][m];
155
156   //first clear the vector which is present for any gammas
157   fBGEvents[z][m][eventCounter].fReconstructedGammas.clear();
158
159   // add the gammas to the vector
160   for(Int_t i=0; i< eventGammas->GetEntriesFast();i++){
161
162     fBGEvents[z][m][eventCounter].fReconstructedGammas.push_back((AliKFParticle*)(eventGammas->At(i)));
163   }
164
165   //set the z and multiplicity numbers
166   fBGEvents[z][m][eventCounter].fZVertexPosition = zvalue;
167   fBGEvents[z][m][eventCounter].fChargedTrackMultiplicity = multiplicity;
168 }
169
170 AliGammaConversionKFVector* AliGammaConversionBGHandler::GetBGGoodV0s(Int_t event, Double_t zvalue, Int_t multiplicity){
171
172   Int_t z = GetZBinIndex(zvalue);
173   Int_t m = GetMultiplicityBinIndex(multiplicity);
174
175   return &(fBGEvents[z][m][event].fReconstructedGammas);
176 }