/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
- * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt *
+ * Author: Martin Wilde, Friederike Bock, Daniel Lohner, Svein Lindal *
+ * based on previous version by Kenneth Aamodt and Ana Marin *
* Version 1.0 *
* *
* Permission to use, copy, modify and distribute this software and its *
ClassImp(AliGammaConversionAODBGHandler)
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler() :
- TObject(),
- fNEvents(10),
- fBGEventCounter(NULL),
- fBGEventENegCounter(NULL),
- fBGProbability(NULL),
- fBGEventVertex(NULL),
- fNBinsZ(0),
- fNBinsMultiplicity(0),
- fBinLimitsArrayZ(NULL),
- fBinLimitsArrayMultiplicity(NULL),
- fBGEvents(),
- fBGEventsENeg()
+ TObject(),
+ fNEvents(10),
+ fBGEventCounter(NULL),
+ fBGEventENegCounter(NULL),
+ fBGEventMesonCounter(NULL),
+ fBGProbability(NULL),
+ fBGEventVertex(NULL),
+ fNBinsZ(0),
+ fNBinsMultiplicity(0),
+ fBinLimitsArrayZ(NULL),
+ fBinLimitsArrayMultiplicity(NULL),
+ fBGEvents(),
+ fBGEventsENeg(),
+ fBGEventsMeson()
{
- // constructor
+ // constructor
}
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t binsZ,UInt_t binsMultiplicity,UInt_t nEvents) :
- TObject(),
- fNEvents(nEvents),
- fBGEventCounter(NULL),
- fBGEventENegCounter(NULL),
- fBGProbability(NULL),
- fBGEventVertex(NULL),
- fNBinsZ(binsZ),
- fNBinsMultiplicity(binsMultiplicity),
- fBinLimitsArrayZ(NULL),
- fBinLimitsArrayMultiplicity(NULL),
- fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
- fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
+ TObject(),
+ fNEvents(nEvents),
+ fBGEventCounter(NULL),
+ fBGEventENegCounter(NULL),
+ fBGEventMesonCounter(NULL),
+ fBGProbability(NULL),
+ fBGEventVertex(NULL),
+ fNBinsZ(binsZ),
+ fNBinsMultiplicity(binsMultiplicity),
+ fBinLimitsArrayZ(NULL),
+ fBinLimitsArrayMultiplicity(NULL),
+ fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
+ fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
+ fBGEventsMeson(binsZ,AliGammaConversionMotherMultipicityVector(binsMultiplicity,AliGammaConversionMotherBGEventVector(nEvents)))
{
- // constructor
+ // constructor
}
-AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t collisionSystem,UInt_t centMin,UInt_t centMax,UInt_t nEvents, Bool_t useTrackMult) :
- TObject(),
- fNEvents(nEvents),
- fBGEventCounter(NULL),
- fBGEventENegCounter(NULL),
- fBGProbability(NULL),
- fBGEventVertex(NULL),
- fNBinsZ(8),
- fNBinsMultiplicity(5),
- fBinLimitsArrayZ(NULL),
- fBinLimitsArrayMultiplicity(NULL),
- fBGEvents(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
- fBGEventsENeg(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
+//_____________________________________________________________________________________________________________________________
+AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t collisionSystem, UInt_t centMin, UInt_t centMax,
+ UInt_t nEvents, Bool_t useTrackMult, UInt_t mode, UInt_t binsZ, UInt_t binsMultiplicity) :
+ TObject(),
+ fNEvents(nEvents),
+ fBGEventCounter(NULL),
+ fBGEventENegCounter(NULL),
+ fBGEventMesonCounter(NULL),
+ fBGProbability(NULL),
+ fBGEventVertex(NULL),
+ fNBinsZ(binsZ),
+ fNBinsMultiplicity(binsMultiplicity),
+ fBinLimitsArrayZ(NULL),
+ fBinLimitsArrayMultiplicity(NULL),
+ fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
+ fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
+ fBGEventsMeson(binsZ,AliGammaConversionMotherMultipicityVector(binsMultiplicity,AliGammaConversionMotherBGEventVector(nEvents)))
{
- // constructor
-
- fBinLimitsArrayZ= new Double_t[8] ;
- if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
- fBinLimitsArrayZ[0] = -50.00;
- fBinLimitsArrayZ[1] = -5.5;
- fBinLimitsArrayZ[2] = -2.9;
- fBinLimitsArrayZ[3] = -0.65;
- fBinLimitsArrayZ[4] = 1.45;
- fBinLimitsArrayZ[5] = 3.65;
- fBinLimitsArrayZ[6] = 6.15;
- fBinLimitsArrayZ[7] = 50;
- }
- else if(collisionSystem == 0){
- fBinLimitsArrayZ[0] = -50.00;
- fBinLimitsArrayZ[1] = -3.375;
- fBinLimitsArrayZ[2] = -1.605;
- fBinLimitsArrayZ[3] = -0.225;
- fBinLimitsArrayZ[4] = 1.065;
- fBinLimitsArrayZ[5] = 2.445;
- fBinLimitsArrayZ[6] = 4.245;
- fBinLimitsArrayZ[7] = 50.00;
- }
- else{
- fBinLimitsArrayZ[0] = -50.00;
- fBinLimitsArrayZ[1] = -5.85;
- fBinLimitsArrayZ[2] = -3.35;
- fBinLimitsArrayZ[3] = -1.15;
- fBinLimitsArrayZ[4] = 0.85;
- fBinLimitsArrayZ[5] = 2.95;
- fBinLimitsArrayZ[6] = 5.55;
- fBinLimitsArrayZ[7] = 50.00;
- }
-
-
-
- fBinLimitsArrayMultiplicity= new Double_t[5];
- if(useTrackMult){ // pp
- fBinLimitsArrayMultiplicity[0] = 0;
- fBinLimitsArrayMultiplicity[1] = 8.5;
- fBinLimitsArrayMultiplicity[2] = 16.5;
- fBinLimitsArrayMultiplicity[3] = 27.5;
- fBinLimitsArrayMultiplicity[4] = 200.;
- if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
- if(centMin == 0 && centMax == 5){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 1540.;
- fBinLimitsArrayMultiplicity[2] = 1665.;
- fBinLimitsArrayMultiplicity[3] = 1780.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 0 && centMax == 10){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 1360.;
- fBinLimitsArrayMultiplicity[2] = 1520.;
- fBinLimitsArrayMultiplicity[3] = 1685.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 0 && centMax == 20){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 1110.;
- fBinLimitsArrayMultiplicity[2] = 1360.;
- fBinLimitsArrayMultiplicity[3] = 1600.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 0 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 890.;
- fBinLimitsArrayMultiplicity[2] = 1240.;
- fBinLimitsArrayMultiplicity[3] = 1540.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 5 && centMax == 10){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 1250.;
- fBinLimitsArrayMultiplicity[2] = 1345.;
- fBinLimitsArrayMultiplicity[3] = 1445.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 10 && centMax == 20){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 915.;
- fBinLimitsArrayMultiplicity[2] = 1020.;
- fBinLimitsArrayMultiplicity[3] = 1130.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 20 && centMax == 40){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 510.;
- fBinLimitsArrayMultiplicity[2] = 625.;
- fBinLimitsArrayMultiplicity[3] = 730.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 40 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 185.;
- fBinLimitsArrayMultiplicity[2] = 250.;
- fBinLimitsArrayMultiplicity[3] = 300.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else if(centMin == 60 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 55.;
- fBinLimitsArrayMultiplicity[2] = 80.;
- fBinLimitsArrayMultiplicity[3] = 100.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- else{ // Std 20-40
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 510.;
- fBinLimitsArrayMultiplicity[2] = 625.;
- fBinLimitsArrayMultiplicity[3] = 730.;
- fBinLimitsArrayMultiplicity[4] = 5000.;
- }
- }
-
- else if(collisionSystem == 8 || collisionSystem == 9){ //pPb
-
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 7.5;
- fBinLimitsArrayMultiplicity[2] = 16.5;
- fBinLimitsArrayMultiplicity[3] = 29.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
-
- if(centMin == 0 && centMax == 20){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 31.5;
- fBinLimitsArrayMultiplicity[2] = 40.5;
- fBinLimitsArrayMultiplicity[3] = 50.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
- } else if(centMin == 20 && centMax == 40){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 19.5;
- fBinLimitsArrayMultiplicity[2] = 25.5;
- fBinLimitsArrayMultiplicity[3] = 32.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
- } else if(centMin == 40 && centMax == 60){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 12.5;
- fBinLimitsArrayMultiplicity[2] = 16.5;
- fBinLimitsArrayMultiplicity[3] = 22.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
- } else if(centMin == 60 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 5.5;
- fBinLimitsArrayMultiplicity[2] = 9.5;
- fBinLimitsArrayMultiplicity[3] = 13.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
- } else if(centMin == 60 && centMax == 100){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 2.5;
- fBinLimitsArrayMultiplicity[2] = 6.5;
- fBinLimitsArrayMultiplicity[3] = 11.5;
- fBinLimitsArrayMultiplicity[4] = 500.;
- }
- }
- }
- else{// pp or pPb V0 Mult
- fBinLimitsArrayMultiplicity[0] = 2;
- fBinLimitsArrayMultiplicity[1] = 3;
- fBinLimitsArrayMultiplicity[2] = 4;
- fBinLimitsArrayMultiplicity[3] = 5;
- fBinLimitsArrayMultiplicity[4] = 9999;
- if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
- if(centMin == 0 && centMax == 5){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 27.;
- fBinLimitsArrayMultiplicity[2] = 31.;
- fBinLimitsArrayMultiplicity[3] = 36.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 0 && centMax == 10){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 25.;
- fBinLimitsArrayMultiplicity[2] = 30.;
- fBinLimitsArrayMultiplicity[3] = 36.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 0 && centMax == 20){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 22.;
- fBinLimitsArrayMultiplicity[2] = 27.;
- fBinLimitsArrayMultiplicity[3] = 33.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 0 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 18.;
- fBinLimitsArrayMultiplicity[2] = 25.;
- fBinLimitsArrayMultiplicity[3] = 32.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 5 && centMax == 10){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 23.;
- fBinLimitsArrayMultiplicity[2] = 27.;
- fBinLimitsArrayMultiplicity[3] = 32.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 10 && centMax == 20){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 18.;
- fBinLimitsArrayMultiplicity[2] = 22.;
- fBinLimitsArrayMultiplicity[3] = 27.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 20 && centMax == 40){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 11.;
- fBinLimitsArrayMultiplicity[2] = 14.;
- fBinLimitsArrayMultiplicity[3] = 18.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 40 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 5.;
- fBinLimitsArrayMultiplicity[2] = 7.;
- fBinLimitsArrayMultiplicity[3] = 11.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else if(centMin == 60 && centMax == 80){
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 2.;
- fBinLimitsArrayMultiplicity[2] = 3.;
- fBinLimitsArrayMultiplicity[3] = 5.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- else{ // Std 20-40
- fBinLimitsArrayMultiplicity[0] = 0.;
- fBinLimitsArrayMultiplicity[1] = 11.;
- fBinLimitsArrayMultiplicity[2] = 14.;
- fBinLimitsArrayMultiplicity[3] = 18.;
- fBinLimitsArrayMultiplicity[4] = 100.;
- }
- }
- }
-
- Initialize(fBinLimitsArrayZ,fBinLimitsArrayMultiplicity);
+ // constructor
+ if (fNBinsZ>8)fNBinsZ = 8;
+
+ if (mode == 0 || mode == 1){
+ if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5;
+ } else if (mode == 2 || mode == 3 || mode == 4 || mode == 5){
+ if (useTrackMult){
+ if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5;
+ } else {
+ if (fNBinsMultiplicity>7)fNBinsMultiplicity = 7;
+ }
+ } else {
+ if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5;
+ }
+ // Initializing z vertex bins
+ fBinLimitsArrayZ= new Double_t[fNBinsZ] ;
+ if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
+ Double_t fBinLimitsArrayZPbPb[8] = {-50, -5.5, -2.9, -0.65,
+ 1.45, 3.65, 6.15, 50};
+ for (Int_t i = 0; i < fNBinsZ; i++){
+ fBinLimitsArrayZ[i] = fBinLimitsArrayZPbPb[i];
+ }
+ } else if(collisionSystem == 0){ // pp
+ Double_t fBinLimitsArrayZpp[8] = {-50, -3.375, -1.605, -0.225,
+ 1.065, 2.445, 4.245, 50};
+ for (Int_t i = 0; i < fNBinsZ; i++){
+ fBinLimitsArrayZ[i] = fBinLimitsArrayZpp[i];
+ }
+ } else { // pPb
+ Double_t fBinLimitsArrayZpPb[8] = {-50, -5.85, -3.35, -1.15,
+ 0.85, 2.95, 5.55, 50};
+ for (Int_t i = 0; i < fNBinsZ; i++){
+ fBinLimitsArrayZ[i] = fBinLimitsArrayZpPb[i];
+ }
+ }
+ // Initializing multiplicity bins
+ fBinLimitsArrayMultiplicity= new Double_t[fNBinsMultiplicity];
+ if(useTrackMult){ // multiplicity binning based on number of good global tracks
+ // default pp values
+ Double_t fBinLimitsArrayMultiplicitypp[5] = {0., 8.5, 16.5, 27.5, 200.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i];
+ }
+ if(collisionSystem > 0 && collisionSystem < 8){ // PbPb values
+ if(centMin == 0 && centMax == 5){ // 0-5% central
+ Double_t fBinLimitsArrayMultiplicityPbPb0005[5] = {0., 1540., 1665., 1780., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0005[i];
+ }
+ } else if(centMin == 0 && centMax == 10){ // 0-10% central
+ Double_t fBinLimitsArrayMultiplicityPbPb0010[5] = {0., 1360., 1520., 1685., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0010[i];
+ }
+ } else if(centMin == 0 && centMax == 20){ // 0-20% central
+ Double_t fBinLimitsArrayMultiplicityPbPb0020[5] = {0., 1110., 1360., 1600., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0020[i];
+ }
+ } else if(centMin == 0 && centMax == 80){ // 0-80% central
+ Double_t fBinLimitsArrayMultiplicityPbPb0080[5] = {0., 890., 1240., 1540., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0080[i];
+ }
+ } else if(centMin == 5 && centMax == 10){ // 5-10% central
+ Double_t fBinLimitsArrayMultiplicityPbPb0510[5] = {0., 1250., 1345., 1445., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0510[i];
+ }
+ } else if(centMin == 10 && centMax == 20){ // 10-20% central
+ Double_t fBinLimitsArrayMultiplicityPbPb1020[5] = {0., 915., 1020., 1130., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb1020[i];
+ }
+ } else if(centMin == 20 && centMax == 40){ // 20-40% central
+ Double_t fBinLimitsArrayMultiplicityPbPb2040[5] = {0., 510., 625., 730., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb2040[i];
+ }
+ } else if(centMin == 40 && centMax == 80){ // 40-80% central
+ Double_t fBinLimitsArrayMultiplicityPbPb4080[5] = {0., 185., 250., 300., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb4080[i];
+ }
+ } else if(centMin == 60 && centMax == 80){ // 60-80% central
+ Double_t fBinLimitsArrayMultiplicityPbPb6080[5] = {0., 55., 80., 100., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb6080[i];
+ }
+ } else { // all other centrality classes
+ Double_t fBinLimitsArrayMultiplicityPbPb[5] = {0., 510., 625., 730., 5000};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb[i];
+ }
+ }
+ } else if(collisionSystem == 8 || collisionSystem == 9){ // pPb
+ Double_t fBinLimitsArrayMultiplicitypPb[5] = {0., 7.5, 16.5, 29.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb[i];
+ }
+ if(centMin == 0 && centMax == 20){ // pPb 0-20 %
+ Double_t fBinLimitsArrayMultiplicitypPb0020[5] = {0., 31.5, 40.5, 50.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb0020[i];
+ }
+ } else if(centMin == 20 && centMax == 40){
+ Double_t fBinLimitsArrayMultiplicitypPb2040[5] = {0., 19.5, 25.5, 32.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb2040[i];
+ }
+ } else if(centMin == 40 && centMax == 60){
+ Double_t fBinLimitsArrayMultiplicitypPb4060[5] = {0., 12.5, 16.5, 22.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb4060[i];
+ }
+ } else if(centMin == 60 && centMax == 80){
+ Double_t fBinLimitsArrayMultiplicitypPb6080[5] = {0., 5.5, 9.5, 13.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb6080[i];
+ }
+ } else if(centMin == 60 && centMax == 100){
+ Double_t fBinLimitsArrayMultiplicitypPb60100[5] = {0., 2.5, 6.5, 11.5, 500};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb60100[i];
+ }
+ }
+ }
+ } else{ // Initializing Multiplicity binning with photon Mult
+ if (mode == 0 || mode == 1) { // settings for Conv-Conv && Conv-Dalitz
+ // pp & pPb defaults
+ Double_t fBinLimitsArrayMultiplicitypp[5] = {2., 3., 4., 5., 9999.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i];
+ }
+ if(collisionSystem > 0 && collisionSystem < 8){ // settings PbPb
+ if(centMin == 0 && centMax == 5){ // 0-5%
+ Double_t fBinLimitsArrayMultiplicityPbPb0005[5] = {0., 27., 31., 36., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0005[i];
+ }
+ } else if(centMin == 0 && centMax == 10){ // 0-10%
+ Double_t fBinLimitsArrayMultiplicityPbPb0010[5] = {0., 25., 30., 36., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0010[i];
+ }
+ } else if(centMin == 0 && centMax == 20){ // 0-20%
+ Double_t fBinLimitsArrayMultiplicityPbPb0020[5] = {0., 22., 27., 33., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0020[i];
+ }
+ } else if(centMin == 0 && centMax == 80){ // 0-80%
+ Double_t fBinLimitsArrayMultiplicityPbPb0080[5] = {0., 18., 25., 32., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0080[i];
+ }
+ } else if(centMin == 5 && centMax == 10){ // 5-10%
+ Double_t fBinLimitsArrayMultiplicityPbPb0510[5] = {0., 23., 27., 32., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0510[i];
+ }
+ } else if(centMin == 10 && centMax == 20){ //10-20%
+ Double_t fBinLimitsArrayMultiplicityPbPb1020[5] = {0., 18., 22., 27., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb1020[i];
+ }
+ } else if(centMin == 20 && centMax == 40){ // 20-40%
+ Double_t fBinLimitsArrayMultiplicityPbPb2040[5] = {0., 11., 14., 18., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb2040[i];
+ }
+ } else if(centMin == 40 && centMax == 80){ // 40-80%
+ Double_t fBinLimitsArrayMultiplicityPbPb4080[5] = {0., 5., 7., 11., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb4080[i];
+ }
+ } else if(centMin == 60 && centMax == 80){ // 60-80%
+ Double_t fBinLimitsArrayMultiplicityPbPb6080[5] = {0., 2., 3., 5., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb6080[i];
+ }
+ } else{ // default PbPb
+ Double_t fBinLimitsArrayMultiplicityPbPb[5] = {0., 11., 14., 18., 100.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb[i];
+ }
+ }
+ }
+ } else if (mode == 2 || mode == 3 || mode == 4 || mode == 5){ // setting for EMCAL-Conv, PHOS-Conv, EMCAL-EMCAL, PHOS-PHOS
+ Double_t fBinLimitsArrayMultiplicitypp[7] = {0., 2., 3., 4., 8., 15., 9999.};
+ for (Int_t i = 0; i < fNBinsMultiplicity; i++){
+ fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i];
+ }
+ }
+ }
+
+ Initialize(fBinLimitsArrayZ,fBinLimitsArrayMultiplicity);
}
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(const AliGammaConversionAODBGHandler & original) :
- TObject(original),
- fNEvents(original.fNEvents),
- fBGEventCounter(original.fBGEventCounter),
- fBGEventENegCounter(original.fBGEventENegCounter),
- fBGProbability(original.fBGProbability),
- fBGEventVertex(original.fBGEventVertex),
- fNBinsZ(original.fNBinsZ),
- fNBinsMultiplicity(original.fNBinsMultiplicity),
- fBinLimitsArrayZ(original.fBinLimitsArrayZ),
- fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity),
- fBGEvents(original.fBGEvents),
- fBGEventsENeg(original.fBGEventsENeg)
+ TObject(original),
+ fNEvents(original.fNEvents),
+ fBGEventCounter(original.fBGEventCounter),
+ fBGEventENegCounter(original.fBGEventENegCounter),
+ fBGEventMesonCounter(original.fBGEventMesonCounter),
+ fBGProbability(original.fBGProbability),
+ fBGEventVertex(original.fBGEventVertex),
+ fNBinsZ(original.fNBinsZ),
+ fNBinsMultiplicity(original.fNBinsMultiplicity),
+ fBinLimitsArrayZ(original.fBinLimitsArrayZ),
+ fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity),
+ fBGEvents(original.fBGEvents),
+ fBGEventsENeg(original.fBGEventsENeg),
+ fBGEventsMeson(original.fBGEventsMeson)
{
- //copy constructor
+ //copy constructor
}
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODBGHandler & AliGammaConversionAODBGHandler::operator = (const AliGammaConversionAODBGHandler & /*source*/)
{
- // assignment operator
- return *this;
+ // assignment operator
+ return *this;
}
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODBGHandler::~AliGammaConversionAODBGHandler(){
- //Kenneth remember to clear memory!!!!!!!!!!!!!!!!!!!!!
- if(fBGEventCounter){
- for(Int_t z=0;z<fNBinsZ;z++){
- delete[] fBGEventCounter[z];
- }
- delete[] fBGEventCounter;
- fBGEventCounter = NULL;
- }
-
- if(fBGEventVertex){
- for(Int_t z=0;z<fNBinsZ;z++){
- for(Int_t m=0;m<fNBinsMultiplicity;m++){
- delete [] fBGEventVertex[z][m];
- }
- delete [] fBGEventVertex[z];
- }
- delete [] fBGEventVertex;
- }
-
- if(fBGEventENegCounter){
- for(Int_t z=0;z<fNBinsZ;z++){
- delete[] fBGEventENegCounter[z];
- }
- delete[] fBGEventENegCounter;
- fBGEventENegCounter = NULL;
- }
-
- if(fBinLimitsArrayZ){
- delete[] fBinLimitsArrayZ;
- }
-
- if(fBinLimitsArrayMultiplicity){
- delete[] fBinLimitsArrayMultiplicity;
- }
+ if(fBGEventCounter){
+ for(Int_t z=0;z<fNBinsZ;z++){
+ delete[] fBGEventCounter[z];
+ }
+ delete[] fBGEventCounter;
+ fBGEventCounter = NULL;
+ }
+
+ if(fBGEventVertex){
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity;m++){
+ delete [] fBGEventVertex[z][m];
+ }
+ delete [] fBGEventVertex[z];
+ }
+ delete [] fBGEventVertex;
+ }
+
+ if(fBGEventENegCounter){
+ for(Int_t z=0;z<fNBinsZ;z++){
+ delete[] fBGEventENegCounter[z];
+ }
+ delete[] fBGEventENegCounter;
+ fBGEventENegCounter = NULL;
+ }
+
+ if(fBGEventMesonCounter){
+ for(Int_t z=0;z<fNBinsZ;z++){
+ delete[] fBGEventMesonCounter[z];
+ }
+ delete[] fBGEventMesonCounter;
+ fBGEventMesonCounter = NULL;
+ }
+
+ if(fBinLimitsArrayZ){
+ delete[] fBinLimitsArrayZ;
+ }
+
+ if(fBinLimitsArrayMultiplicity){
+ delete[] fBinLimitsArrayMultiplicity;
+ }
}
+//_____________________________________________________________________________________________________________________________
void AliGammaConversionAODBGHandler::Initialize(Double_t * const zBinLimitsArray, Double_t * const multiplicityBinLimitsArray){
// see header file for documantation
- if(zBinLimitsArray){
- fBinLimitsArrayZ = zBinLimitsArray;
- }
- else{
- //Print warning
- }
-
- if(multiplicityBinLimitsArray){
- fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ;
- }
- else{
- //Print warning
- }
- if(fBGEventCounter == NULL){
- fBGEventCounter= new Int_t*[fNBinsZ];
- }
- for(Int_t z=0;z<fNBinsZ;z++){
- fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
- }
-
- for(Int_t z=0;z<fNBinsZ;z++){
- for(Int_t m=0;m<fNBinsMultiplicity;m++){
- fBGEventCounter[z][m]=0;
- }
- }
-
- if(fBGEventVertex == NULL){
- fBGEventVertex = new GammaConversionVertex**[fNBinsZ];
- }
- for(Int_t z=0; z < fNBinsZ; z++){
- fBGEventVertex[z]= new GammaConversionVertex*[fNBinsMultiplicity];
- }
- for(Int_t z=0;z<fNBinsZ;z++){
- for(Int_t m=0;m<fNBinsMultiplicity; m++){
- fBGEventVertex[z][m]= new GammaConversionVertex[fNEvents];
- }
- }
- if( fBGEventENegCounter == NULL){
- fBGEventENegCounter = new Int_t*[fNBinsZ];
- }
-
- for(Int_t z=0; z < fNBinsZ; z++){
- fBGEventENegCounter[z] = new Int_t[fNBinsMultiplicity];
- }
-
- for(Int_t z=0;z<fNBinsZ;z++){
- for(Int_t m=0;m<fNBinsMultiplicity; m++){
- fBGEventENegCounter[z][m] = 0;
- }
- }
-
- if(fBGProbability == NULL){
- fBGProbability = new Double_t*[fNBinsZ];
- }
- for(Int_t z=0; z < fNBinsZ; z++){
- fBGProbability[z] = new Double_t[fNBinsMultiplicity];
- }
-
- for(Int_t z=0;z<fNBinsZ;z++){
- for(Int_t m=0;m<fNBinsMultiplicity; m++){
- fBGProbability[z][m] = 0;
- }
- }
- //filling the probability
- fBGProbability[0][0] = 0.243594;
- fBGProbability[0][1] = 0.279477;
- fBGProbability[0][2] = 0.305104;
- fBGProbability[0][3] = 0.315927;
- fBGProbability[1][0] = 0.241964;
- fBGProbability[1][1] = 0.272995;
- fBGProbability[1][2] = 0.307165;
- fBGProbability[1][3] = 0.292248;
- fBGProbability[2][0] = 0.241059;
- fBGProbability[2][1] = 0.27509;
- fBGProbability[2][2] = 0.283657;
- fBGProbability[2][3] = 0.310512;
- fBGProbability[3][0] = 0.23888;
- fBGProbability[3][1] = 0.283418;
- fBGProbability[3][2] = 0.297232;
- fBGProbability[3][3] = 0.348188;
- fBGProbability[4][0] = 0.245555;
- fBGProbability[4][1] = 0.281218;
- fBGProbability[4][2] = 0.317236;
- fBGProbability[4][3] = 0.323495;
- fBGProbability[5][0] = 0.244572;
- fBGProbability[5][1] = 0.259498;
- fBGProbability[5][2] = 0.278383;
- fBGProbability[5][3] = 0.284696;
- fBGProbability[6][0] = 0.24703;
- fBGProbability[6][1] = 0.275265;
- fBGProbability[6][2] = 0.284004;
- fBGProbability[6][3] = 0.343584;
-
+ if(zBinLimitsArray){
+ fBinLimitsArrayZ = zBinLimitsArray;
+ }
+ else{
+ //Print warning
+ }
+
+ if(multiplicityBinLimitsArray){
+ fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ;
+ }
+ else{
+ //Print warning
+ }
+ if(fBGEventCounter == NULL){
+ fBGEventCounter= new Int_t*[fNBinsZ];
+ }
+ for(Int_t z=0;z<fNBinsZ;z++){
+ fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
+ }
+
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity;m++){
+ fBGEventCounter[z][m]=0;
+ }
+ }
+
+ if(fBGEventMesonCounter == NULL){
+ fBGEventMesonCounter= new Int_t*[fNBinsZ];
+ }
+ for(Int_t z=0;z<fNBinsZ;z++){
+ fBGEventMesonCounter[z]=new Int_t[fNBinsMultiplicity];
+ }
+
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity;m++){
+ fBGEventMesonCounter[z][m]=0;
+ }
+ }
+
+
+ if(fBGEventVertex == NULL){
+ fBGEventVertex = new GammaConversionVertex**[fNBinsZ];
+ }
+ for(Int_t z=0; z < fNBinsZ; z++){
+ fBGEventVertex[z]= new GammaConversionVertex*[fNBinsMultiplicity];
+ }
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity; m++){
+ fBGEventVertex[z][m]= new GammaConversionVertex[fNEvents];
+ }
+ }
+ if( fBGEventENegCounter == NULL){
+ fBGEventENegCounter = new Int_t*[fNBinsZ];
+ }
+
+ for(Int_t z=0; z < fNBinsZ; z++){
+ fBGEventENegCounter[z] = new Int_t[fNBinsMultiplicity];
+ }
+
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity; m++){
+ fBGEventENegCounter[z][m] = 0;
+ }
+ }
+
+ if(fBGProbability == NULL){
+ fBGProbability = new Double_t*[fNBinsZ];
+ }
+ for(Int_t z=0; z < fNBinsZ; z++){
+ fBGProbability[z] = new Double_t[fNBinsMultiplicity];
+ }
+
+ for(Int_t z=0;z<fNBinsZ;z++){
+ for(Int_t m=0;m<fNBinsMultiplicity; m++){
+ fBGProbability[z][m] = 0;
+ }
+ }
+ //filling the probability
+ fBGProbability[0][0] = 0.243594;
+ fBGProbability[0][1] = 0.279477;
+ fBGProbability[0][2] = 0.305104;
+ fBGProbability[0][3] = 0.315927;
+ fBGProbability[1][0] = 0.241964;
+ fBGProbability[1][1] = 0.272995;
+ fBGProbability[1][2] = 0.307165;
+ fBGProbability[1][3] = 0.292248;
+ fBGProbability[2][0] = 0.241059;
+ fBGProbability[2][1] = 0.27509;
+ fBGProbability[2][2] = 0.283657;
+ fBGProbability[2][3] = 0.310512;
+ fBGProbability[3][0] = 0.23888;
+ fBGProbability[3][1] = 0.283418;
+ fBGProbability[3][2] = 0.297232;
+ fBGProbability[3][3] = 0.348188;
+ fBGProbability[4][0] = 0.245555;
+ fBGProbability[4][1] = 0.281218;
+ fBGProbability[4][2] = 0.317236;
+ fBGProbability[4][3] = 0.323495;
+ fBGProbability[5][0] = 0.244572;
+ fBGProbability[5][1] = 0.259498;
+ fBGProbability[5][2] = 0.278383;
+ fBGProbability[5][3] = 0.284696;
+ fBGProbability[6][0] = 0.24703;
+ fBGProbability[6][1] = 0.275265;
+ fBGProbability[6][2] = 0.284004;
+ fBGProbability[6][3] = 0.343584;
+
}
+//_____________________________________________________________________________________________________________________________
Int_t AliGammaConversionAODBGHandler::GetZBinIndex(Double_t zvalue) const{
- // see header file for documantation
- if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){
- return 0;
- }
-
- for(Int_t i=0; i<fNBinsZ-1 ;i++){
- if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
- return i;
- }
- }
- return fNBinsZ-1;
+ // see header file for documantation
+ if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){
+ return 0;
+ }
+
+ for(Int_t i=0; i<fNBinsZ-1 ;i++){
+ if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
+ return i;
+ }
+ }
+ return fNBinsZ-1;
}
+//_____________________________________________________________________________________________________________________________
Int_t AliGammaConversionAODBGHandler::GetMultiplicityBinIndex(Int_t multiplicity) const{
- // see header file for documantation
- if(fNBinsMultiplicity<2){
- return 0;
- }
-
- for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){
- if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
- return i;
- }
- }
- return fNBinsMultiplicity-1;
+ // see header file for documantation
+ if(fNBinsMultiplicity<2){
+ return 0;
+ }
+
+ for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){
+ if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
+ return i;
+ }
+ }
+ return fNBinsMultiplicity-1;
}
+//_____________________________________________________________________________________________________________________________
void AliGammaConversionAODBGHandler::AddEvent(TList* const eventGammas,Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){
- // see header file for documantation
+ // see header file for documantation
+
+ // cout<<"Entering the AddEvent function"<<endl;
+
+ Int_t z = GetZBinIndex(zvalue);
+ Int_t m = GetMultiplicityBinIndex(multiplicity);
- // cout<<"Entering the AddEvent function"<<endl;
-
- Int_t z = GetZBinIndex(zvalue);
- Int_t m = GetMultiplicityBinIndex(multiplicity);
-
- if(fBGEventCounter[z][m] >= fNEvents){
- fBGEventCounter[z][m]=0;
- }
- Int_t eventCounter=fBGEventCounter[z][m];
-
- /*
- if(fBGEventVertex[z][m][eventCounter]){
- delete fBGEventVertex[z][m][eventCounter];
- }
- */
- fBGEventVertex[z][m][eventCounter].fX = xvalue;
- fBGEventVertex[z][m][eventCounter].fY = yvalue;
- fBGEventVertex[z][m][eventCounter].fZ = zvalue;
- fBGEventVertex[z][m][eventCounter].fEP = epvalue;
-
- //first clear the vector
- // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
- // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
-
- // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
- for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){
- delete (AliAODConversionPhoton*)(fBGEvents[z][m][eventCounter][d]);
- }
- fBGEvents[z][m][eventCounter].clear();
-
- // add the gammas to the vector
- for(Int_t i=0; i< eventGammas->GetEntries();i++){
- // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
- fBGEvents[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
- }
- fBGEventCounter[z][m]++;
+ if(fBGEventCounter[z][m] >= fNEvents){
+ fBGEventCounter[z][m]=0;
+ }
+ Int_t eventCounter=fBGEventCounter[z][m];
+
+ /*
+ if(fBGEventVertex[z][m][eventCounter]){
+ delete fBGEventVertex[z][m][eventCounter];
+ }
+ */
+ fBGEventVertex[z][m][eventCounter].fX = xvalue;
+ fBGEventVertex[z][m][eventCounter].fY = yvalue;
+ fBGEventVertex[z][m][eventCounter].fZ = zvalue;
+ fBGEventVertex[z][m][eventCounter].fEP = epvalue;
+
+ //first clear the vector
+ // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
+ // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
+
+ // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
+ for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){
+ delete (AliAODConversionPhoton*)(fBGEvents[z][m][eventCounter][d]);
+ }
+ fBGEvents[z][m][eventCounter].clear();
+
+ // add the gammas to the vector
+ for(Int_t i=0; i< eventGammas->GetEntries();i++){
+ // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
+ fBGEvents[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
+ }
+ fBGEventCounter[z][m]++;
}
-void AliGammaConversionAODBGHandler::AddElectronEvent(TClonesArray* const eventENeg, Double_t zvalue, Int_t multiplicity){
- Int_t z = GetZBinIndex(zvalue);
- Int_t m = GetMultiplicityBinIndex(multiplicity);
+//_____________________________________________________________________________________________________________________________
+void AliGammaConversionAODBGHandler::AddMesonEvent(TList* const eventMothers, Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){
- if(fBGEventENegCounter[z][m] >= fNEvents){
- fBGEventENegCounter[z][m]=0;
- }
-
+ // see header file for documantation
+ // cout<<"Entering the AddEvent function"<<endl;
+ Int_t z = GetZBinIndex(zvalue);
+ Int_t m = GetMultiplicityBinIndex(multiplicity);
- Int_t eventENegCounter=fBGEventENegCounter[z][m];
-
- //first clear the vector
- // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
- // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
+ if(fBGEventMesonCounter[z][m] >= fNEvents){
+ fBGEventMesonCounter[z][m]=0;
+ }
+ Int_t eventCounter=fBGEventMesonCounter[z][m];
+
+ fBGEventVertex[z][m][eventCounter].fX = xvalue;
+ fBGEventVertex[z][m][eventCounter].fY = yvalue;
+ fBGEventVertex[z][m][eventCounter].fZ = zvalue;
+ fBGEventVertex[z][m][eventCounter].fEP = epvalue;
+
+ //first clear the vector
+ for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){
+ delete (AliAODConversionMother*)(fBGEventsMeson[z][m][eventCounter][d]);
+ }
+ fBGEventsMeson[z][m][eventCounter].clear();
+
+ // add the gammas to the vector
+ for(Int_t i=0; i< eventMothers->GetEntries();i++){
+ fBGEventsMeson[z][m][eventCounter].push_back(new AliAODConversionMother(*(AliAODConversionMother*)(eventMothers->At(i))));
+ }
+ fBGEventMesonCounter[z][m]++;
+}
- // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
- for(UInt_t d=0;d<fBGEventsENeg[z][m][eventENegCounter].size();d++){
- delete (AliAODConversionPhoton*)(fBGEventsENeg[z][m][eventENegCounter][d]);
- }
- fBGEventsENeg[z][m][eventENegCounter].clear();
+//_____________________________________________________________________________________________________________________________
+void AliGammaConversionAODBGHandler::AddElectronEvent(TClonesArray* const eventENeg, Double_t zvalue, Int_t multiplicity){
- // add the electron to the vector
- for(Int_t i=0; i< eventENeg->GetEntriesFast();i++){
- // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
- fBGEventsENeg[z][m][eventENegCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventENeg->At(i))));
- }
+ Int_t z = GetZBinIndex(zvalue);
+ Int_t m = GetMultiplicityBinIndex(multiplicity);
- fBGEventENegCounter[z][m]++;
+ if(fBGEventENegCounter[z][m] >= fNEvents){
+ fBGEventENegCounter[z][m]=0;
+ }
+ Int_t eventENegCounter=fBGEventENegCounter[z][m];
+
+ //first clear the vector
+ // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
+ // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
+
+ // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
+ for(UInt_t d=0;d<fBGEventsENeg[z][m][eventENegCounter].size();d++){
+ delete (AliAODConversionPhoton*)(fBGEventsENeg[z][m][eventENegCounter][d]);
+ }
+ fBGEventsENeg[z][m][eventENegCounter].clear();
+ // add the electron to the vector
+ for(Int_t i=0; i< eventENeg->GetEntriesFast();i++){
+ // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
+ fBGEventsENeg[z][m][eventENegCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventENeg->At(i))));
+ }
+ fBGEventENegCounter[z][m]++;
}
+
+//_____________________________________________________________________________________________________________________________
AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodV0s(Int_t zbin, Int_t mbin, Int_t event){
- //see headerfile for documentation
- return &(fBGEvents[zbin][mbin][event]);
+ //see headerfile for documentation
+ return &(fBGEvents[zbin][mbin][event]);
}
-AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodENeg(Int_t event, Double_t zvalue, Int_t multiplicity){
-
-
- //see headerfile for documentation
- Int_t z = GetZBinIndex(zvalue);
- Int_t m = GetMultiplicityBinIndex(multiplicity);
- return &(fBGEventsENeg[z][m][event]);
+//_____________________________________________________________________________________________________________________________
+AliGammaConversionMotherAODVector* AliGammaConversionAODBGHandler::GetBGGoodMesons(Int_t zbin, Int_t mbin, Int_t event){
+ //see headerfile for documentation
+ return &(fBGEventsMeson[zbin][mbin][event]);
+}
+//_____________________________________________________________________________________________________________________________
+AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodENeg(Int_t event, Double_t zvalue, Int_t multiplicity){
+ //see headerfile for documentation
+ Int_t z = GetZBinIndex(zvalue);
+ Int_t m = GetMultiplicityBinIndex(multiplicity);
+ return &(fBGEventsENeg[z][m][event]);
}
+
+//_____________________________________________________________________________________________________________________________
void AliGammaConversionAODBGHandler::PrintBGArray(){
- //see headerfile for documentation
- for(Int_t z=0;z<fNBinsZ;z++){
- if(z==2){
- cout<<"Getting the data for z bin: "<<z<<endl;
- for(Int_t multiplicity=0;multiplicity<fNBinsMultiplicity;multiplicity++){
- if(multiplicity==2){
- cout<<"Getting the data for multiplicity bin: "<<multiplicity<<endl;
- for(Int_t event=0;event<fNEvents;event++){
- if(fBGEvents[z][multiplicity][event].size()>0){
- cout<<"Event: "<<event<<" has: "<<fBGEvents[z][multiplicity][event].size()<<endl;
- }
- }
- }
- }
- }
- }
+ //see headerfile for documentation
+ for(Int_t z=0;z<fNBinsZ;z++){
+ if(z==2){
+ cout<<"Getting the data for z bin: "<<z<<endl;
+ for(Int_t multiplicity=0;multiplicity<fNBinsMultiplicity;multiplicity++){
+ if(multiplicity==2){
+ cout<<"Getting the data for multiplicity bin: "<<multiplicity<<endl;
+ for(Int_t event=0;event<fNEvents;event++){
+ if(fBGEvents[z][multiplicity][event].size()>0){
+ cout<<"Event: "<<event<<" has: "<<fBGEvents[z][multiplicity][event].size()<<endl;
+ }
+ }
+ }
+ }
+ }
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff