CORRFW/AliCFContainer.cxx

   1 /* $Id$ */
   2 /**************************************************************************
   3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Author: The ALICE Off-line Project.                                    *
   6  * Contributors are mentioned in the code where appropriate.              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16 //--------------------------------------------------------------------//
  17 //                                                                    //
  18 // AliCFContainer Class                                               //
  19 // Class to accumulate data on an N-dimensional grids, at different   //
  20 // selection stages. To be used as an input to get corrections for    //
  21 // Reconstruction & Trigger efficiency                                //
  22 //                                                                    //
  23 // -- Author : S.Arcelli                                              //
  24 //--------------------------------------------------------------------//
  25 //
  26 //
  27 #include <AliLog.h>
  28 #include "AliCFGrid.h"
  29 #include "AliCFGridSparse.h"
  30 #include "AliCFContainer.h"
  31 #include "TAxis.h"
  32 //____________________________________________________________________
  33 ClassImp(AliCFContainer)
  34
  35 //____________________________________________________________________
  36 AliCFContainer::AliCFContainer() :
  37   AliCFFrame(),
  38   fNStep(0),
  39   fGrid(0x0)
  40 {
  41   //
  42   // default constructor
  43   //
  44 }
  45 //____________________________________________________________________
  46 AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) :
  47   AliCFFrame(name,title),
  48   fNStep(0),
  49   fGrid(0x0)
  50 {
  51   // default constructor
  52 }
  53
  54 //____________________________________________________________________
  55 AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelSteps, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn, const Bool_t useSparse) :
  56   AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
  57   fNStep(0),
  58   fGrid(0x0)
  59 {
  60   //
  61   // main constructor
  62   //
  63
  64   // The selection steps
  65   fNStep=nSelSteps;
  66
  67   // The grids
  68   fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps
  69   char gname[30];
  70   for(Int_t istep=0;istep<fNStep;istep++){
  71     sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep);
  72     if(!useSparse){
  73       fGrid[istep] = new AliCFGrid(gname,title,nVarIn,nBinIn,binLimitsIn);
  74       }
  75     else{
  76       fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn,binLimitsIn);
  77     }
  78     fGrid[istep]->SumW2();
  79   }
  80 }
  81 //____________________________________________________________________
  82 AliCFContainer::AliCFContainer(const AliCFContainer& c) :
  83   AliCFFrame(),
  84   fNStep(c.fNStep),
  85   fGrid(c.fGrid)
  86 {
  87   //
  88   // copy constructor
  89   //
  90   ((AliCFContainer &)c).Copy(*this);
  91 }
  92 //____________________________________________________________________
  93 AliCFContainer::~AliCFContainer()
  94 {
  95   //
  96   // destructor
  97   //
  98   if(fGrid)delete [] fGrid;
  99
 100 }
 101 //____________________________________________________________________
 102 AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
 103 {
 104   //
 105   // assigment operator
 106   //
 107   if (this != &c)
 108     ((AliCFContainer &) c).Copy(*this);
 109   return *this;
 110 }
 111 //____________________________________________________________________
 112 void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array)
 113 {
 114   //
 115   // setting the arrays containing the bin limits
 116   //
 117   Int_t nbins=fNVarBins[varindex]+1;
 118   for(Int_t i=0;i<nbins;i++){
 119     fVarBinLimits[fOffset[varindex]+i] =array[i];
 120   }
 121   for(Int_t istep=0;istep<fNStep;istep++){
 122     fGrid[istep]->SetBinLimits(varindex,array);
 123   }
 124 }
 125 //____________________________________________________________________
 126 void AliCFContainer::Copy(TObject& c) const
 127 {
 128   //
 129   // copy function
 130   //
 131   AliCFContainer& target = (AliCFContainer &) c;
 132   target.fNStep=fNStep;
 133   target.fNVar=fNVar;
 134   target.fNDim=fNDim;
 135   target.fNVarBinLimits=fNVarBinLimits;
 136   if (fNVarBins)
 137     target.fNVarBins = fNVarBins;
 138   if (fVarBinLimits)
 139     target.fVarBinLimits = fVarBinLimits;
 140   if (fGrid)
 141     target.fGrid = fGrid;
 142     for(Int_t istep=0;istep<fNStep;istep++){
 143       for(Int_t iel=0;iel<fNDim;iel++){
 144         target.fGrid[istep]->SetElement(iel,fGrid[istep]->GetElement(iel));
 145       }
 146     }
 147 }
 148 //____________________________________________________________________
 149 void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
 150 {
 151   //
 152   // Fills the grid at selection step istep for a set of values of the
 153   // input variables, with a given weight (by default w=1)
 154   //
 155   if(istep >= fNStep || istep < 0){
 156     AliError("Non-existent selection step, grid was not filled");
 157     return;
 158   }
 159   fGrid[istep]->Fill(var,weight);
 160 }
 161 //___________________________________________________________________
 162 TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
 163 {
 164   //
 165   // returns 1-D projection along variable ivar at selection step istep
 166   //
 167   if(istep >= fNStep || istep < 0){
 168     AliError("Non-existent selection step, return NULL");
 169     return 0x0;
 170   }
 171   if(ivar >= fNVar || ivar < 0){
 172     AliError("Non-existent selection step, return NULL");
 173     return 0x0;
 174   }
 175
 176   return fGrid[istep]->Project(ivar);
 177 }
 178 //___________________________________________________________________
 179 TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const
 180 {
 181   //
 182   // returns 2-D projection along variables ivar1,ivar2 at selection step istep
 183   //
 184   if(istep >= fNStep || istep < 0){
 185     AliError("Non-existent selection step, return NULL");
 186     return 0x0;
 187   }
 188   if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){
 189     AliError("Non-existent selection step, return NULL");
 190     return 0x0;
 191   }
 192
 193   return fGrid[istep]->Project(ivar1,ivar2);
 194 }
 195 //___________________________________________________________________
 196 TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
 197 {
 198   //
 199   // returns 3-D projection along variables ivar1,ivar2,ivar3
 200   // at selection step istep
 201   //
 202   if(istep >= fNStep || istep < 0){
 203     AliError("Non-existent selection step, return NULL");
 204     return 0x0;
 205   }
 206   if(ivar1 >= fNVar || ivar1 < 0 ||
 207      ivar2 >= fNVar || ivar2 < 0 ||
 208      ivar3 >= fNVar || ivar3 < 0 ) {
 209     AliError("Non-existent selection step, return NULL");
 210     return 0x0;
 211   }
 212
 213   return fGrid[istep]->Project(ivar1,ivar2,ivar3);
 214 }
 215 //___________________________________________________________________
 216 TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax, Int_t istep) const
 217 {
 218   //
 219   // Make a slice along variable ivar at selection level istep in range [varMin,varMax]
 220   //
 221   if(istep >= fNStep || istep < 0){
 222     AliError("Non-existent selection step, return NULL");
 223     return 0x0;
 224   }
 225   if (ivar >= fNVar || ivar < 0) {
 226     AliError("Non-existent variable, return NULL");
 227     return 0x0;
 228   }
 229   return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax);
 230 }
 231 //___________________________________________________________________
 232 TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t* varMax, Int_t istep) const
 233 {
 234   //
 235   // Make a slice along variables ivar1 and ivar2 at selection level istep in range [varMin,varMax]
 236   //
 237   if(istep >= fNStep || istep < 0){
 238     AliError("Non-existent selection step, return NULL");
 239     return 0x0;
 240   }
 241   if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0) {
 242     AliError("Non-existent variable, return NULL");
 243     return 0x0;
 244   }
 245   return (TH2D*)fGrid[istep]->Slice(ivar1,ivar2,varMin,varMax);
 246 }
 247 //___________________________________________________________________
 248 TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t* varMax, Int_t istep) const
 249 {
 250   //
 251   // Make a slice along variables ivar1, ivar2and ivar3 at selection level istep in range [varMin,varMax]
 252   //
 253   if(istep >= fNStep || istep < 0){
 254     AliError("Non-existent selection step, return NULL");
 255     return 0x0;
 256   }
 257   if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0 || ivar3 >= fNVar || ivar3 < 0) {
 258     AliError("Non-existent variable, return NULL");
 259     return 0x0;
 260   }
 261   return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax);
 262 }
 263 //____________________________________________________________________
 264 AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
 265 {
 266   //
 267   // Makes a slice along the "nVars" variables defined in "vars" in range [varMin,varMax]
 268   // and returns a new container
 269   //
 270
 271   if (nVars < 1 || nVars > fNVar)   AliError("Bad number of dimensions required for the slice");
 272
 273   //define new binning for new container
 274   Int_t* bins=new Int_t[nVars];
 275   for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = fNVarBins[vars[iVar]];
 276   AliCFContainer* out = new AliCFContainer(fName,fTitle,fNStep,nVars,bins);
 277
 278   //set the bin limits
 279   for (Int_t iVar=0; iVar<nVars; iVar++) {
 280     Double_t *array = new Double_t[fNVarBins[vars[iVar]]+1];
 281     GetBinLimits(vars[iVar],array);
 282     out->SetBinLimits(iVar,array);
 283     delete array;
 284   }
 285
 286   //set grid for each step
 287   AliInfo(Form("Making a slice in %d dimension(s)",nVars));
 288   for (Int_t iStep=0; iStep<fNStep; iStep++) out->SetGrid(iStep,fGrid[iStep]->Project(nVars,vars,varMin,varMax));
 289
 290   delete bins;
 291   return out;
 292 }
 293
 294 //____________________________________________________________________
 295 Long64_t AliCFContainer::Merge(TCollection* list)
 296 {
 297   // Merge a list of AliCorrection objects with this (needed for
 298   // PROOF).
 299   // Returns the number of merged objects (including this).
 300
 301   if (!list)
 302     return 0;
 303
 304   if (list->IsEmpty())
 305     return 1;
 306
 307   TIterator* iter = list->MakeIterator();
 308   TObject* obj;
 309
 310   Int_t count = 0;
 311   while ((obj = iter->Next())) {
 312     AliCFContainer* entry = dynamic_cast<AliCFContainer*> (obj);
 313     if (entry == 0)
 314       continue;
 315     this->Add(entry);
 316     count++;
 317   }
 318
 319   return count+1;
 320 }
 321
 322 //____________________________________________________________________
 323 void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c)
 324 {
 325   //
 326   //add the content of container aContainerToAdd to the current one
 327   //
 328   if( (aContainerToAdd->GetNStep()!=fNStep)
 329       ||
 330       (aContainerToAdd->GetNVar()!=fNVar)
 331       ||
 332       (aContainerToAdd->GetNDim()!=fNDim)){
 333     AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers");
 334     return;
 335   }
 336   for(Int_t istep=0;istep<fNStep;istep++){
 337     fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c);
 338   }
 339 }
 340 //____________________________________________________________________
 341 Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep) const {
 342   //
 343   // Get overflows in variable var at selection level istep
 344   //
 345   if(istep >= fNStep || istep < 0){
 346     AliError("Non-existent selection step, return -1");
 347     return -1.;
 348   }
 349   return fGrid[istep]->GetOverFlows(ivar);
 350 }
 351 //____________________________________________________________________
 352 Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep) const {
 353   //
 354   // Get underflows in variable var at selection level istep
 355   //
 356   if(istep >= fNStep || istep < 0){
 357     AliError("Non-existent selection step, return -1");
 358     return -1.;
 359   }
 360   return fGrid[istep]->GetUnderFlows(ivar);
 361 }
 362 //____________________________________________________________________
 363 Float_t AliCFContainer::GetEntries( Int_t istep) const {
 364   //
 365   // Get total entries in variable var at selection level istep
 366   //
 367   if(istep >= fNStep || istep < 0){
 368     AliError("Non-existent selection step, return -1");
 369     return -1.;
 370   }
 371   return fGrid[istep]->GetEntries();
 372 }
 373 //____________________________________________________________________
 374 Int_t AliCFContainer::GetEmptyBins( Int_t istep) const {
 375   //
 376   // Get empty bins in variable var at selection level istep
 377   //
 378   if(istep >= fNStep || istep < 0){
 379     AliError("Non-existent selection step, return -1");
 380     return -1;
 381   }
 382   return fGrid[istep]->GetEmptyBins();
 383 }
 384 //____________________________________________________________________
 385 Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const {
 386   //
 387   // Get empty bins in a range in variable var at selection level istep
 388   //
 389   if(istep >= fNStep || istep < 0){
 390     AliError("Non-existent selection step, return -1");
 391     return -1;
 392   }
 393   return fGrid[istep]->GetEmptyBins(varMin,varMax);
 394 }
 395 //_____________________________________________________________________
 396 Double_t AliCFContainer::GetIntegral( Int_t istep) const
 397 {
 398   //
 399   // Get Integral over the grid at selection level istep
 400   //
 401   if(istep >= fNStep || istep < 0){
 402     AliError("Non-existent selection step, return -1");
 403     return -1.;
 404   }
 405   return fGrid[istep]->GetIntegral();
 406 }
 407 //_____________________________________________________________________
 408 Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const
 409 {
 410   //
 411   // Get Integral over the grid in a range at selection level istep
 412   //
 413   if(istep >= fNStep || istep < 0){
 414     AliError("Non-existent selection step, return -1");
 415     return -1.;
 416   }
 417   return fGrid[istep]->GetIntegral(varMin,varMax);
 418 }
 419 //_____________________________________________________________________
 420 void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep)
 421 {
 422   //
 423   // set axis range at step istep
 424   //
 425   if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) {
 426     AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented");
 427     return;
 428   }
 429   if (istep >= fNStep || istep < 0){
 430     AliError("Non-existent selection step");
 431     return ;
 432   }
 433   if (ivar >= fNVar || ivar < 0){
 434     AliError("Non-existent selection var");
 435     return ;
 436   }
 437   ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax);
 438 }
 439
 440 //_____________________________________________________________________
 441 void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep)
 442 {
 443   //
 444   // set all axis ranges at step istep according to varMin and varMax values
 445   //
 446   if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) {
 447     AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented");
 448     return;
 449   }
 450   if (istep >= fNStep || istep < 0){
 451     AliError("Non-existent selection step");
 452     return ;
 453   }
 454   ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax);
 455 }