PWG2/RESONANCES/AliRsnFunction.cxx

   1 //
   2 // Class AliRsnFunction
   3 //
   4 // This class defines a base classe to implement a function
   5 // which uses the internal RSN package event format (AliRsnEvent).
   6 // It contains some default flags which turn out to be useful:
   7 //  - a flag to select only the "true" pairs (tracks from same resonance)
   8 //  - a flag to know if the computation is done over two events (mixing)
   9 //
  10 // Any kind of analysis object should be implemented as inheriting from this
  11 // because the AliRsnAnalyzer which executes the analysis will accept a collection
  12 // of such objects, in order to have a unique format of processing method
  13 //
  14 // The user who implements a kind of computation type should inherit from
  15 // this class and override the virtual functions defined in it, which
  16 // initialize the final output histogram and define how to process data.
  17 //
  18 //
  19 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
  20 //
  21
  22 #include <TString.h>
  23 #include <TAxis.h>
  24
  25 #include "AliLog.h"
  26
  27 #include "AliRsnDaughter.h"
  28 #include "AliRsnEvent.h"
  29 #include "AliRsnPairDef.h"
  30 #include "AliRsnMother.h"
  31 #include "AliRsnValue.h"
  32
  33 #include "AliRsnFunction.h"
  34
  35 ClassImp(AliRsnFunction)
  36
  37 //________________________________________________________________________________________
  38 AliRsnFunction::AliRsnFunction(Bool_t useTH1) :
  39     TObject(),
  40     fPairDef(0x0),
  41     fAxisList("AliRsnValue", 0),
  42     fPair(0x0),
  43     fEvent(0x0),
  44     fUseTH1(useTH1),
  45     fSize(0),
  46     fH1(0x0),
  47     fHSparse(0x0)
  48 {
  49 //
  50 // Constructor.
  51 //
  52 }
  53
  54 //________________________________________________________________________________________
  55 AliRsnFunction::AliRsnFunction(const AliRsnFunction &copy) :
  56     TObject(copy),
  57     fPairDef(copy.fPairDef),
  58     fAxisList(copy.fAxisList),
  59     fPair(copy.fPair),
  60     fEvent(copy.fEvent),
  61     fUseTH1(copy.fUseTH1),
  62     fSize(copy.fSize),
  63     fH1(0x0),
  64     fHSparse(0x0)
  65 {
  66 //
  67 // Copy constructor.
  68 //
  69 }
  70
  71 //________________________________________________________________________________________
  72 const AliRsnFunction& AliRsnFunction::operator=(const AliRsnFunction& copy)
  73 {
  74 //
  75 // Assignment operator.
  76 //
  77
  78   //SetName(copy.GetName());
  79   //SetTitle(copy.GetTitle());
  80
  81   fPairDef = copy.fPairDef;
  82   fPair = copy.fPair;
  83   fEvent = copy.fEvent;
  84   fUseTH1 = copy.fUseTH1;
  85   fSize = copy.fSize;
  86
  87   if (fH1) delete fH1;
  88   fH1 = 0x0;
  89
  90   if (fHSparse) delete fHSparse;
  91   fHSparse = 0x0;
  92
  93   return (*this);
  94 }
  95
  96 //________________________________________________________________________________________
  97 const char* AliRsnFunction::GetName() const
  98 {
  99 //
 100 // Defines the name of this object according to
 101 // the function type and binning
 102 //
 103
 104   TString name("");
 105
 106   TObjArrayIter next(&fAxisList);
 107   AliRsnValue *axis = 0;
 108
 109   while ((axis = (AliRsnValue*)next())) {
 110     if (name.Length() > 1) name += '_';
 111     name += axis->GetName();
 112   }
 113
 114   return name.Data();
 115 }
 116
 117 //________________________________________________________________________________________
 118 void AliRsnFunction::AddAxis(AliRsnValue *const axis)
 119 {
 120   AliDebug(AliLog::kDebug+2,"<-");
 121   Int_t size = fAxisList.GetEntries();
 122   new(fAxisList[size]) AliRsnValue(*axis);
 123   AliDebug(AliLog::kDebug+2,"->");
 124
 125   if (fAxisList.GetEntries() > 3)
 126   {
 127     AliWarning("A TH1-type output cannot add more than 3 axes: switching to THnSparse -- THIS COULD CAUSE VERY LARGE FILES!!!");
 128     fUseTH1 = kFALSE;
 129   }
 130 }
 131
 132 //________________________________________________________________________________________
 133 TH1* AliRsnFunction::CreateHistogram(const char *histoName, const char *histoTitle)
 134 {
 135 //
 136 // Creates and returns the histogram defined using
 137 // arguments fo name and title, and the first histoDef for binning.
 138 // Variable-sized histogram binning is always called, due to use of histoDef,
 139 // even if the bins are equal, since they are defined in this class.
 140 // Eventually present histoDef's in other slots of array (1, 2) are ignored.
 141 //
 142 // This version produces a THnSparseF.
 143 //
 144
 145   fSize = fAxisList.GetEntries();
 146   if (!fSize) {
 147     AliError("No axes defined");
 148     return 0x0;
 149   }
 150   else if (fSize < 1 || fSize > 3)
 151   {
 152     AliError("Too few or too many axes defined");
 153     return 0x0;
 154   }
 155
 156   // retrieve binnings for main and secondary axes
 157   AliRsnValue *fcnAxis;
 158   TArrayD      array[3];
 159   for (Int_t i = 0; i < fSize; i++)
 160   {
 161     fcnAxis = (AliRsnValue*)fAxisList.At(i);
 162     if (!fcnAxis)
 163     {
 164       AliError("Empty axis");
 165       array[i].Set(2);
 166       array[i][0] = -1E5;
 167       array[i][1] = -1E5;
 168       continue;
 169     }
 170     else
 171     {
 172       array[i] = fcnAxis->GetArray();
 173     }
 174   }
 175
 176   // create histogram depending on the number of axes
 177   switch (fSize)
 178   {
 179     case 1:
 180       fH1 = new TH1F(histoName, histoTitle, array[0].GetSize() - 1, array[0].GetArray());
 181       break;
 182     case 2:
 183       fH1 = new TH2F(histoName, histoTitle, array[0].GetSize() - 1, array[0].GetArray(), array[1].GetSize() - 1, array[1].GetArray());
 184       break;
 185     case 3:
 186       fH1 = new TH3F(histoName, histoTitle, array[0].GetSize() - 1, array[0].GetArray(), array[1].GetSize() - 1, array[1].GetArray(), array[2].GetSize() - 1, array[2].GetArray());
 187       break;
 188   }
 189   fH1->Sumw2();
 190
 191   return fH1;
 192 }
 193
 194 //________________________________________________________________________________________
 195 THnSparseF* AliRsnFunction::CreateHistogramSparse(const char *histoName, const char *histoTitle)
 196 {
 197 //
 198 // Creates and returns the histogram defined using
 199 // arguments fo name and title, and the first histoDef for binning.
 200 // Variable-sized histogram binning is always called, due to use of histoDef,
 201 // even if the bins are equal, since they are defined in this class.
 202 // Eventually present histoDef's in other slots of array (1, 2) are ignored.
 203 //
 204 // This version produces a THnSparseF.
 205 //
 206
 207   fSize = fAxisList.GetEntries();
 208   if (!fSize) {
 209     AliError("No axes defined");
 210     return 0x0;
 211   }
 212
 213   // initialize the array of number of bins for each axis
 214   // taking it from the stored values, while for the bins
 215   // they are set as summied and defined later
 216   Double_t     dummyD;
 217   Int_t       *nbins   = new Int_t[fSize];
 218   AliRsnValue *fcnAxis = 0;
 219   for (Int_t i = 0; i < fSize; i++)
 220   {
 221     fcnAxis = (AliRsnValue*)fAxisList.At(i);
 222     if (!fcnAxis)
 223     {
 224       nbins[i] = 1;
 225       AliError("Empty axis");
 226       continue;
 227     }
 228     nbins[i] = fcnAxis->GetArray().GetSize() - 1;
 229   }
 230
 231   // create histogram
 232   fHSparse = new THnSparseF(histoName, histoTitle, fSize, nbins, &dummyD, &dummyD);
 233   fHSparse->Sumw2();
 234
 235   // update the various axes using the definitions given in the array of axes here
 236   for (Int_t i = 0; i < fSize; i++)
 237   {
 238     fcnAxis = (AliRsnValue*)fAxisList.At(i);
 239     if (!fcnAxis) {
 240       AliError("Empty axis: doing unique bin betweeen -100000 and 100000");
 241       continue;
 242     }
 243     fHSparse->SetBinEdges(i, fcnAxis->GetArray().GetArray());
 244   }
 245
 246   return fHSparse;
 247 }
 248
 249
 250 //________________________________________________________________________________________
 251 Bool_t AliRsnFunction::Fill()
 252 {
 253 //
 254 // Fill function histogram with values computed from given input object.
 255 //
 256
 257   AliDebug(AliLog::kDebug +2,"->");
 258
 259   Int_t  i;
 260   Double_t *values = new Double_t[fSize];
 261
 262   AliRsnValue *fcnAxis = 0;
 263   for (i = 0; i < fSize; i++) {
 264     fcnAxis = (AliRsnValue*)fAxisList.At(i);
 265     if (!fcnAxis)
 266     {
 267       values[i] = 0.0;
 268       continue;
 269     }
 270     if (fcnAxis->Eval(fPair, fPairDef, fEvent)) values[i] = (Double_t)((Float_t)fcnAxis->GetValue());
 271   }
 272
 273   // fill histogram
 274   if (fUseTH1)
 275   {
 276     // check presence of output histogram
 277     if (!fH1) {
 278       AliError("Required a TH1 which is not initialized");
 279       delete [] values;
 280       return kFALSE;
 281     }
 282
 283     // fill according to dimensions
 284     switch (fSize)
 285     {
 286       case 1:
 287         {
 288           TH1F *h1 = (TH1F*)fH1;
 289           h1->Fill(values[0]);
 290         }
 291         break;
 292       case 2:
 293         {
 294           TH2F *h2 = (TH2F*)fH1;
 295           h2->Fill(values[0], values[1]);
 296         }
 297         break;
 298       case 3:
 299         {
 300           TH3F *h3 = (TH3F*)fH1;
 301           h3->Fill(values[0], values[1], values[2]);
 302         }
 303         break;
 304       default:
 305         AliError(Form("Wrong size : %d", fSize));
 306         delete [] values;
 307         return kFALSE;
 308     }
 309   }
 310   else
 311   {
 312     // check presence of output histogram
 313     if (!fHSparse) {
 314       AliError("Required a THnSparseF which is not initialized");
 315       return kFALSE;
 316     }
 317
 318     fHSparse->Fill(values);
 319   }
 320
 321   delete [] values;
 322
 323   AliDebug(AliLog::kDebug +2,"->");
 324   return kTRUE;
 325 }