1 #if !defined( __CINT__) || defined(__MAKECINT__)
6 #include "AliConversionAODBGHandlerRP.h"
11 // Author Daniel Lohner (Daniel.Lohner@cern.ch)
14 ClassImp(AliConversionAODBGHandlerRP);
16 //________________________________________________________________________
17 AliConversionAODBGHandlerRP::AliConversionAODBGHandlerRP(Bool_t IsHeavyIon,Bool_t UseChargedTrackMult,Int_t NEvents) : TObject(),
18 fIsHeavyIon(IsHeavyIon),
19 fUseChargedTrackMult(UseChargedTrackMult),
21 fBGEventCounter(NULL),
24 fNBinsMultiplicity(5+Int_t(fUseChargedTrackMult)),
25 fBinLimitsArrayZ(NULL),
26 fBinLimitsArrayMultiplicity(NULL),
27 fBGPool(fNBinsZ,AliGammaConversionMultiplicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(fNEvents)))
31 fBinLimitsArrayZ = new Double_t[fNBinsZ+1];
32 fBinLimitsArrayZ[0] = -50.00;
33 fBinLimitsArrayZ[1] = -3.375;
34 fBinLimitsArrayZ[2] = -1.605;
35 fBinLimitsArrayZ[3] = -0.225;
36 fBinLimitsArrayZ[4] = 1.065;
37 fBinLimitsArrayZ[5] = 2.445;
38 fBinLimitsArrayZ[6] = 4.245;
39 fBinLimitsArrayZ[7] = 50.00;
43 fBinLimitsArrayMultiplicity= new Double_t[fNBinsMultiplicity+1];
45 if(fUseChargedTrackMult){
46 // Use Charged Particle Multiplicity
48 fBinLimitsArrayMultiplicity[0] = 0;
49 fBinLimitsArrayMultiplicity[1] = 8.5;
50 fBinLimitsArrayMultiplicity[2] = 16.5;
51 fBinLimitsArrayMultiplicity[3] = 27.5;
52 fBinLimitsArrayMultiplicity[4] = 41.5;
53 fBinLimitsArrayMultiplicity[5] = 200.;
56 fBinLimitsArrayMultiplicity[0] = 0;
57 fBinLimitsArrayMultiplicity[1] = 200.;
58 fBinLimitsArrayMultiplicity[2] = 500.;
59 fBinLimitsArrayMultiplicity[3] = 1000.;
60 fBinLimitsArrayMultiplicity[4] = 1500.;
61 fBinLimitsArrayMultiplicity[5] = 5000.;
65 // Use V0 Multiplicity
67 fBinLimitsArrayMultiplicity[0] = 2;
68 fBinLimitsArrayMultiplicity[1] = 3;
69 fBinLimitsArrayMultiplicity[2] = 4;
70 fBinLimitsArrayMultiplicity[3] = 5;
71 fBinLimitsArrayMultiplicity[4] = 9999;
74 fBinLimitsArrayMultiplicity[0] = 2;
75 fBinLimitsArrayMultiplicity[1] = 10;
76 fBinLimitsArrayMultiplicity[2] = 30;
77 fBinLimitsArrayMultiplicity[3] = 50;
78 fBinLimitsArrayMultiplicity[4] = 9999;
84 //________________________________________________________________________
85 AliConversionAODBGHandlerRP::~AliConversionAODBGHandlerRP()
88 delete[] fBinLimitsArrayZ;
89 fBinLimitsArrayZ=0x0;}
90 if(fBinLimitsArrayMultiplicity){
91 delete[] fBinLimitsArrayMultiplicity;
92 fBinLimitsArrayMultiplicity=0x0;}
96 for(Int_t z=0;z<fNBinsZ;z++){
97 delete[] fBGEventCounter[z];
99 delete[] fBGEventCounter;
100 fBGEventCounter = NULL;
105 for(Int_t z=0;z<fNBinsZ;z++){
106 for(Int_t m=0;m<fNBinsMultiplicity;m++){
107 for(Int_t eventCounter=0;eventCounter<fNBGEvents[z][m]&&eventCounter<fNEvents;eventCounter++){
109 for(UInt_t d=0;d<fBGPool[z][m][eventCounter].size();d++){
110 delete (AliAODConversionPhoton*)(fBGPool[z][m][eventCounter][d]);
117 for(Int_t z=0;z<fNBinsZ;z++){
118 delete[] fNBGEvents[z];
126 //________________________________________________________________________
127 void AliConversionAODBGHandlerRP::Initialize(){
131 if(fBGEventCounter == NULL){
132 fBGEventCounter= new Int_t*[fNBinsZ];
134 for(Int_t z=0;z<fNBinsZ;z++){
135 fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
138 for(Int_t z=0;z<fNBinsZ;z++){
139 for(Int_t m=0;m<fNBinsMultiplicity;m++){
140 fBGEventCounter[z][m]=0;
144 if(fNBGEvents == NULL){
145 fNBGEvents= new Int_t*[fNBinsZ];
147 for(Int_t z=0;z<fNBinsZ;z++){
148 fNBGEvents[z]=new Int_t[fNBinsMultiplicity];
150 for(Int_t z=0;z<fNBinsZ;z++){
151 for(Int_t m=0;m<fNBinsMultiplicity;m++){
157 //-------------------------------------------------------------
159 Int_t AliConversionAODBGHandlerRP::GetZBinIndex(Double_t zvalue) const{
161 if(zvalue<=fBinLimitsArrayZ[0]){
165 if(fNBinsZ<2){return 0;}
167 for(Int_t i=0; i<fNBinsZ ;i++){
168 if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
174 //-------------------------------------------------------------
175 Int_t AliConversionAODBGHandlerRP::GetMultiplicityBinIndex(Int_t multiplicity) const{
176 if(fNBinsMultiplicity<2){
180 for(Int_t i=0; i<fNBinsMultiplicity ;i++){
181 if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
188 //-------------------------------------------------------------
189 Bool_t AliConversionAODBGHandlerRP::FindBins(TObjArray * const eventGammas,AliVEvent *fInputEvent,Int_t &zbin,Int_t &mbin){
190 Double_t vertexz=fInputEvent->GetPrimaryVertex()->GetZ();
191 zbin = GetZBinIndex(vertexz);
193 Int_t multiplicity=0;
194 if(fUseChargedTrackMult){
195 multiplicity=fInputEvent->GetNumberOfTracks();
198 multiplicity=eventGammas->GetEntries();
200 mbin = GetMultiplicityBinIndex(multiplicity);
202 if(zbin<fNBinsZ&&mbin<fNBinsMultiplicity){
203 if(zbin>=0&&mbin>=0){
207 //cout<<Form("Requested BG pool does not exist: z %i m %i",zbin,mbin)<<endl;
210 //-------------------------------------------------------------
211 Bool_t AliConversionAODBGHandlerRP::FindBins(TList * const eventGammas,AliVEvent *fInputEvent,Int_t &zbin,Int_t &mbin){
212 Double_t vertexz=fInputEvent->GetPrimaryVertex()->GetZ();
213 zbin = GetZBinIndex(vertexz);
215 Int_t multiplicity=0;
216 if(fUseChargedTrackMult){
217 multiplicity=fInputEvent->GetNumberOfTracks();
220 multiplicity=eventGammas->GetEntries();
222 mbin = GetMultiplicityBinIndex(multiplicity);
224 if(zbin<fNBinsZ&&mbin<fNBinsMultiplicity){
225 if(zbin>=0&&mbin>=0){
229 //cout<<Form("Requested BG pool does not exist: z %i m %i",zbin,mbin)<<endl;
234 //-------------------------------------------------------------
235 void AliConversionAODBGHandlerRP::AddEvent(TObjArray * const eventGammas,AliVEvent *fInputEvent){
237 if(eventGammas->GetEntriesFast()==0)return;
241 if(FindBins(eventGammas,fInputEvent,z,m)){
244 // If Event Stack is full, replace the first entry (First in first out)
245 if(fBGEventCounter[z][m] >= fNEvents){
246 fBGEventCounter[z][m]=0;
249 // Update number of Events stored
250 if(fNBGEvents[z][m] < fNEvents){
254 Int_t eventCounter=fBGEventCounter[z][m];
256 //clear the vector for old gammas
257 for(UInt_t d=0;d<fBGPool[z][m][eventCounter].size();d++){
258 delete (AliAODConversionPhoton*)(fBGPool[z][m][eventCounter][d]);
261 fBGPool[z][m][eventCounter].clear();
263 // add the gammas to the vector
265 for(Int_t i=0; i< eventGammas->GetEntriesFast();i++){
266 fBGPool[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
269 fBGEventCounter[z][m]++;
272 //-------------------------------------------------------------
273 void AliConversionAODBGHandlerRP::AddEvent(TList * const eventGammas,AliVEvent *fInputEvent){
274 if(eventGammas->GetEntries()==0)return;
278 if(FindBins(eventGammas,fInputEvent,z,m)){
281 // If Event Stack is full, replace the first entry (First in first out)
282 if(fBGEventCounter[z][m] >= fNEvents){
283 fBGEventCounter[z][m]=0;
286 // Update number of Events stored
287 if(fNBGEvents[z][m] < fNEvents){
291 Int_t eventCounter=fBGEventCounter[z][m];
293 //clear the vector for old gammas
294 for(UInt_t d=0;d<fBGPool[z][m][eventCounter].size();d++){
295 delete (AliAODConversionPhoton*)(fBGPool[z][m][eventCounter][d]);
298 fBGPool[z][m][eventCounter].clear();
300 // add the gammas to the vector
302 for(Int_t i=0; i< eventGammas->GetEntries();i++){
303 fBGPool[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
306 fBGEventCounter[z][m]++;
310 //-------------------------------------------------------------
311 AliGammaConversionPhotonVector* AliConversionAODBGHandlerRP::GetBGGoodGammas(TObjArray * const eventGammas,AliVEvent *fInputEvent,Int_t event){
314 if(FindBins(eventGammas,fInputEvent,zbin,mbin)){
315 return &(fBGPool[zbin][mbin][event]);
319 //-------------------------------------------------------------
320 AliGammaConversionPhotonVector* AliConversionAODBGHandlerRP::GetBGGoodGammas(TList * const eventGammas,AliVEvent *fInputEvent,Int_t event){
323 if(FindBins(eventGammas,fInputEvent,zbin,mbin)){
324 return &(fBGPool[zbin][mbin][event]);
329 //-------------------------------------------------------------
330 Int_t AliConversionAODBGHandlerRP::GetNBGEvents(TObjArray * const eventGammas,AliVEvent *fInputEvent){
333 if(FindBins(eventGammas,fInputEvent,zbin,mbin)){
334 return fNBGEvents[zbin][mbin];
338 //-------------------------------------------------------------
339 Int_t AliConversionAODBGHandlerRP::GetNBGEvents(TList * const eventGammas,AliVEvent *fInputEvent){
342 if(FindBins(eventGammas,fInputEvent,zbin,mbin)){
343 return fNBGEvents[zbin][mbin];