PWG/muon/AliAnalysisMuMuBinning.cxx

   1 #include "AliAnalysisMuMuBinning.h"
   2
   3 //
   4 // AliAnalysisMuMuBinning.h : a class to hold bins of various sizes
   5 //
   6 // The idea behind this class is to store it together with
   7 // the histograms (corresponding to the bins)
   8 // so we can then loop easily on all bins afterwards.
   9 //
  10 // author: L. Aphecetche (Subatech)
  11 //
  12
  13 #include "AliLog.h"
  14 #include "Riostream.h"
  15 #include "TMap.h"
  16 #include "TMath.h"
  17 #include "TObjArray.h"
  18 #include "TObjString.h"
  19 #include <cassert>
  20
  21 ClassImp(AliAnalysisMuMuBinning::Range)
  22 ClassImp(AliAnalysisMuMuBinning)
  23
  24 //______________________________________________________________________________
  25 AliAnalysisMuMuBinning::AliAnalysisMuMuBinning(const char* name, const char* title)
  26 : TNamed(name,title), fBins(0x0)
  27 {
  28   // default ctor
  29 }
  30
  31 //______________________________________________________________________________
  32 AliAnalysisMuMuBinning::AliAnalysisMuMuBinning(const AliAnalysisMuMuBinning& rhs)
  33 : TNamed(), fBins(0x0)
  34 {
  35   // copy ctor
  36   TObjArray* bins = rhs.CreateBinObjArray();
  37   TIter next(bins);
  38   AliAnalysisMuMuBinning::Range* b;
  39
  40   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
  41   {
  42     AddBin(*b);
  43   }
  44 }
  45
  46 //______________________________________________________________________________
  47 AliAnalysisMuMuBinning& AliAnalysisMuMuBinning::operator=(const AliAnalysisMuMuBinning& rhs)
  48 {
  49   // assignment  operator
  50
  51   if ( this != &rhs )
  52   {
  53     delete fBins;
  54     fBins = 0x0;
  55     TObjArray* bins = rhs.CreateBinObjArray();
  56     TIter next(bins);
  57     AliAnalysisMuMuBinning::Range* b;
  58
  59     while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
  60     {
  61       AddBin(*b);
  62     }
  63   }
  64   return *this;
  65 }
  66
  67 //______________________________________________________________________________
  68 AliAnalysisMuMuBinning::~AliAnalysisMuMuBinning()
  69 {
  70   // dtor
  71   delete fBins;
  72 }
  73
  74 //______________________________________________________________________________
  75 void AliAnalysisMuMuBinning::AddBin(const AliAnalysisMuMuBinning::Range& bin)
  76 {
  77   /// add one bin
  78   AddBin(bin.What().Data(),bin.Quantity().Data(),
  79          bin.Xmin(),bin.Xmax(),
  80          bin.Ymin(),bin.Ymax(),bin.Flavour());
  81 }
  82
  83 //______________________________________________________________________________
  84 void AliAnalysisMuMuBinning::AddBin(const char* what, const char* quantity,
  85                                     Double_t xmin, Double_t xmax,
  86                                     Double_t ymin, Double_t ymax,
  87                                     const char* flavour)
  88 {
  89   /// Add a bin
  90   /// Note that what and Quantity are not case sensitive.
  91   if (!fBins)
  92   {
  93     fBins = new TMap;
  94     fBins->SetOwnerKeyValue(kTRUE,kTRUE);
  95   }
  96
  97   TString swhat(what);
  98   swhat.ToUpper();
  99
 100   TString sQuantity(quantity);
 101   sQuantity.ToUpper();
 102
 103   TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(swhat.Data()));
 104   if (!b)
 105   {
 106     b = new TObjArray;
 107     b->SetOwner(kTRUE);
 108     fBins->Add(new TObjString(swhat),b);
 109   }
 110
 111   Range* r = new Range(swhat.Data(),sQuantity.Data(),xmin,xmax,ymin,ymax,flavour);
 112
 113   if ( b->FindObject(r) )
 114   {
 115     AliDebug(1,Form("Trying to add an already existing bin : %s. Not doing it.",r->AsString().Data()));
 116     delete r;
 117   }
 118   else
 119   {
 120     b->Add(r);
 121
 122     TString bQuantity(Form("%s-%s",swhat.Data(),sQuantity.Data()));
 123
 124     TString name(GetName());
 125
 126     if ( !name.Contains(bQuantity) )
 127     {
 128       if (name.Length()>0)
 129       {
 130         name += " ";
 131       }
 132
 133       name += bQuantity;
 134       SetName(name);
 135     }
 136   }
 137
 138   b->Sort();
 139 }
 140
 141 //______________________________________________________________________________
 142 Double_t* AliAnalysisMuMuBinning::CreateBinArray() const
 143 {
 144   /// Create a (variable) bin array suitable for TH1 constructor
 145   /// The returned array must be deleted by the user
 146   /// (using delete[] )
 147
 148   TObjArray* binArray = CreateBinObjArray();
 149   if (!binArray) return 0x0;
 150   Double_t* bins = new Double_t[binArray->GetEntries()+1];
 151   TIter next(binArray);
 152   AliAnalysisMuMuBinning::Range* b;
 153   Int_t i(0);
 154   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
 155   {
 156     bins[i] = b->Xmin();
 157     ++i;
 158   }
 159
 160   b = static_cast<AliAnalysisMuMuBinning::Range*>(binArray->At(binArray->GetEntries()-1));
 161
 162   bins[i] = b->Xmax();
 163
 164   delete binArray;
 165   return bins;
 166 }
 167
 168 //______________________________________________________________________________
 169 TObjArray* AliAnalysisMuMuBinning::CreateBinObjArray() const
 170 {
 171   /// Get the list of all the bins
 172   /// The returned array must be deleted by the user
 173
 174   TObjArray* a = new TObjArray;
 175   a->SetOwner(kTRUE);
 176
 177   TIter nextwhat(fBins);
 178   TObjString* what;
 179
 180   while ( ( what = static_cast<TObjString*>(nextwhat()) ) )
 181   {
 182     TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(what->String().Data()));
 183     TIter next(b);
 184     Range* r;
 185
 186     while ( ( r = static_cast<Range*>(next()) ) )
 187     {
 188       a->Add(r->Clone());
 189     }
 190   }
 191
 192   if ( a->GetLast() < 0 )
 193   {
 194     delete a;
 195     a = 0x0;
 196   }
 197   return a;
 198 }
 199
 200 //______________________________________________________________________________
 201 TObjArray* AliAnalysisMuMuBinning::CreateBinObjArray(const char* what) const
 202 {
 203   /// Get the list of bins for a given what
 204   /// The returned array must be deleted by the user
 205
 206   if (!fBins) return 0x0;
 207
 208   TObjArray* a = new TObjArray;
 209   a->SetOwner(kTRUE);
 210
 211   TString swhat(what);
 212   swhat.ToUpper();
 213
 214   TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(swhat.Data()));
 215   if (!b) return 0x0;
 216
 217   TIter next(b);
 218   Range* r;
 219
 220   while ( ( r = static_cast<Range*>(next()) ) )
 221   {
 222     a->Add(r->Clone());
 223   }
 224
 225   if ( a->GetLast() < 0 )
 226   {
 227     delete a;
 228     a = 0x0;
 229   }
 230   return a;
 231 }
 232
 233
 234 //______________________________________________________________________________
 235 TObjArray* AliAnalysisMuMuBinning::CreateBinObjArray(const char* what, const char* quantity, const char* flavour) const
 236 {
 237   /// Get the list of bins for a given what and given Quantity
 238   /// The returned array must be deleted by the user
 239   /// Quantity can be a single Quantity or several Quantitys separated by comma
 240
 241   TObjArray* a = new TObjArray;
 242   a->SetOwner(kTRUE);
 243
 244   TString swhat(what);
 245   swhat.ToUpper();
 246
 247   TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(swhat.Data()));
 248   if (!b) return 0x0;
 249
 250   TIter next(b);
 251   Range* r;
 252
 253   TString sQuantity(quantity);
 254   sQuantity.ToUpper();
 255
 256   TString sflavour(flavour);
 257
 258   TObjArray* Quantitys = sQuantity.Tokenize(",");
 259   TObjString* oneQuantity;
 260   TIter nextQuantity(Quantitys);
 261
 262   while ( ( r = static_cast<Range*>(next()) ) )
 263   {
 264     nextQuantity.Reset();
 265     while ( ( oneQuantity = static_cast<TObjString*>(nextQuantity()) ) )
 266     {
 267       if ( r->Quantity() == oneQuantity->String() &&
 268           ( ( sflavour.Length() > 0 && r->Flavour() == sflavour.Data() ) || sflavour.Length()==0 ) )
 269       {
 270         a->Add(r->Clone());
 271       }
 272     }
 273   }
 274
 275   if ( a->GetLast() < 0 )
 276   {
 277     delete a;
 278     a = 0x0;
 279   }
 280
 281   delete Quantitys;
 282   return a;
 283 }
 284
 285 //______________________________________________________________________________
 286 Double_t* AliAnalysisMuMuBinning::CreateBinArrayY() const
 287 {
 288   /// Create a TObjArray with 2 (variable) bin array with x and y binning, suitable for TH1
 289   /// The returned array must be deleted by the user
 290   /// (using delete[] )
 291
 292   TObjArray* binArray = CreateBinObjArray();
 293   if (!binArray) return 0x0;
 294
 295   AliAnalysisMuMuBinning::Range* firstBin = static_cast<AliAnalysisMuMuBinning::Range*>(binArray->First());
 296
 297   Double_t* binsY = new Double_t[binArray->GetEntries()+1];
 298
 299   Double_t minY = firstBin->Ymin();
 300   Double_t maxY = firstBin->Ymax();
 301
 302   if ( !(minY < maxY))
 303   {
 304     std::cout << "No 2D binning" << std::endl;
 305     delete binsY;
 306     delete binArray;
 307     return 0x0;
 308   }
 309
 310   TIter next(binArray);
 311   AliAnalysisMuMuBinning::Range* b;
 312   Int_t i(0);
 313   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
 314   {
 315     if ( (i != 0) && (minY == b->Ymin()) ) break;
 316
 317     binsY[i] = b->Ymin();
 318     ++i;
 319   }
 320
 321   b = static_cast<AliAnalysisMuMuBinning::Range*>(binArray->At(i-1));
 322
 323   binsY[i] = b->Ymax();
 324
 325   Double_t* bins = new Double_t[i + 1];
 326
 327   for (Int_t j = 0 ; j < (i+1) ; j++)
 328   {
 329     bins[j] = binsY[j];
 330   }
 331
 332   delete binArray;
 333   delete[] binsY;
 334   return bins;
 335 }
 336
 337 //______________________________________________________________________________
 338 Int_t AliAnalysisMuMuBinning::GetNBinsX() const
 339 {
 340   /// Gets the number of x bins, suitable for TH1
 341
 342
 343   TObjArray* binArray = CreateBinObjArray();
 344   if (!binArray) return 0;
 345
 346   Double_t binsX(0);
 347
 348
 349   TIter next(binArray);
 350   AliAnalysisMuMuBinning::Range* b;
 351   Int_t i(0);
 352   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
 353   {
 354     if ( (i != 0) && (binsX == b->Xmin()) ) continue;
 355
 356     binsX = b->Xmin();
 357     ++i;
 358   }
 359
 360   delete binArray;
 361   return i;
 362 }
 363
 364 //______________________________________________________________________________
 365 Int_t AliAnalysisMuMuBinning::GetNBinsY() const
 366 {
 367   /// Gets the number of x bins, suitable for TH1
 368
 369
 370   TObjArray* binArray = CreateBinObjArray();
 371   if (!binArray) return 0x0;
 372
 373   Double_t binsY(0);
 374
 375   AliAnalysisMuMuBinning::Range* firstBin = static_cast<AliAnalysisMuMuBinning::Range*>(binArray->First());
 376
 377   Double_t minY = firstBin->Ymin();
 378   Double_t maxY = firstBin->Ymax();
 379
 380   if ( !(minY < maxY))
 381   {
 382     std::cout << "No 2D binning" << std::endl;
 383     delete binArray;
 384     return 0;
 385   }
 386
 387   TIter next(binArray);
 388   AliAnalysisMuMuBinning::Range* b;
 389   Int_t i(0);
 390   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
 391   {
 392     if ( (i != 0) && (minY == b->Ymin()) ) break;
 393
 394     binsY = b->Ymin();
 395     ++i;
 396   }
 397
 398   delete binArray;
 399   return i;
 400 }
 401
 402 //______________________________________________________________________________
 403 Double_t* AliAnalysisMuMuBinning::CreateBinArrayX() const
 404 {
 405   /// Create a TObjArray with 2 (variable) bin array with x and y binning , suitable for TH1
 406   /// The returned array must be deleted by the user
 407   /// (using delete[] )
 408
 409   TObjArray* binArray = CreateBinObjArray();
 410   if (!binArray) return 0x0;
 411
 412   Double_t* binsX = new Double_t[binArray->GetEntries()+1];
 413
 414
 415   TIter next(binArray);
 416   AliAnalysisMuMuBinning::Range* b;
 417   Int_t i(0);
 418   while ( ( b = static_cast<AliAnalysisMuMuBinning::Range*>(next()) ) )
 419   {
 420     if ( (i != 0) && (binsX[i-1] == b->Xmin()) ) continue;
 421
 422     binsX[i] = b->Xmin();
 423     ++i;
 424   }
 425
 426   b = static_cast<AliAnalysisMuMuBinning::Range*>(binArray->At(binArray->GetEntries()-1));
 427
 428   binsX[i] = b->Xmax();
 429
 430   Double_t* bins = new Double_t[i + 1];
 431
 432   for (Int_t j = 0 ; j < (i+1) ; j++)
 433   {
 434     bins[j] = binsX[j];
 435   }
 436
 437   delete binArray;
 438   delete[] binsX;
 439   return bins;
 440 }
 441
 442 //______________________________________________________________________________
 443 void AliAnalysisMuMuBinning::CreateMesh(const char* what,
 444                                         const char* quantity1, const char* quantity2,
 445                                         const char* flavour,
 446                                         Bool_t remove12)
 447 {
 448   /// Create 2D bins from existing 1d ones of Quantity1 and Quantity2
 449   TObjArray* a1 = CreateBinObjArray(what,quantity1,flavour);
 450   if (!a1)
 451   {
 452     AliError(Form("No bin for Quantity %s. Done nothing.",quantity1));
 453     return;
 454   }
 455   TObjArray* a2 = CreateBinObjArray(what,quantity2,flavour);
 456   if (!a2)
 457   {
 458     AliError(Form("No bin for Quantity %s. Done nothing.",quantity2));
 459     return;
 460   }
 461
 462   TString meshQuantity(Form("%s VS %s - %s",quantity1,quantity2,flavour));
 463
 464   for ( Int_t i1 = 0; i1 <= a1->GetLast(); ++i1 )
 465   {
 466     Range* r1 = static_cast<Range*>(a1->At(i1));
 467
 468     for ( Int_t i2 = 0; i2 <= a2->GetLast(); ++i2 )
 469     {
 470       Range* r2 = static_cast<Range*>(a2->At(i2));
 471
 472       AddBin(what,meshQuantity,r2->Xmin(),r2->Xmax(),r1->Xmin(),r1->Xmax(),Form("%s VS %s",r1->Flavour().Data(),r2->Flavour().Data()));
 473     }
 474   }
 475
 476   delete a1;
 477   delete a2;
 478
 479   if ( remove12 )
 480   {
 481     TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(what));
 482     TIter next(b);
 483     Range* r;
 484     TString sQuantity1(quantity1);
 485     TString sQuantity2(quantity2);
 486
 487     sQuantity1.ToUpper();
 488     sQuantity2.ToUpper();
 489
 490     while ( ( r = static_cast<Range*>(next())) )
 491     {
 492       if ( r->Quantity() == quantity1 ||
 493            r->Quantity() == quantity2 )
 494       {
 495         b->Remove(r);
 496       }
 497     }
 498   }
 499 }
 500
 501 //______________________________________________________________________________
 502 TObjArray* AliAnalysisMuMuBinning::CreateWhatArray() const
 503 {
 504   /// Create a TObjString array with the names of the what we're holding results for
 505   /// Returned array must be delete by user
 506
 507   TObjArray* whatArray(0x0);
 508
 509   TIter nextwhat(fBins);
 510   TObjString* what;
 511
 512   while ( ( what = static_cast<TObjString*>(nextwhat()) ) )
 513   {
 514     if (!whatArray)
 515     {
 516       whatArray = new TObjArray;
 517       whatArray->SetOwner(kTRUE);
 518     }
 519     whatArray->Add(new TObjString(*what));
 520   }
 521   return whatArray;
 522 }
 523
 524 //______________________________________________________________________________
 525 TObjArray* AliAnalysisMuMuBinning::CreateQuantityArray() const
 526 {
 527   /// Create a TObjString array with the names of the binning Quantitys
 528   /// Returned array must be delete by user
 529
 530   TObjArray* QuantityArray(0x0);
 531
 532   TIter nextwhat(fBins);
 533   TObjString* what;
 534
 535   while ( ( what = static_cast<TObjString*>(nextwhat()) ) )
 536   {
 537     TObjArray* whats = static_cast<TObjArray*>(fBins->GetValue(what->String()));
 538
 539     TIter next(whats);
 540     Range* r;
 541
 542     while ( ( r = static_cast<Range*>(next())) )
 543     {
 544       if (!QuantityArray)
 545       {
 546         QuantityArray = new TObjArray;
 547         QuantityArray->SetOwner(kTRUE);
 548       }
 549       if ( !QuantityArray->FindObject(r->Quantity()) )
 550       {
 551         QuantityArray->Add(new TObjString(r->Quantity()));
 552       }
 553     }
 554   }
 555   return QuantityArray;
 556 }
 557
 558 //______________________________________________________________________________
 559 Bool_t AliAnalysisMuMuBinning::IsEqual(const TObject* obj) const
 560 {
 561   /// Return kTRUE if obj is an AliAnalysisMuMuBinning object and is
 562   /// equal to *this
 563
 564   if ( obj->IsA() == AliAnalysisMuMuBinning::Class() )
 565   {
 566     const AliAnalysisMuMuBinning* other = static_cast<const AliAnalysisMuMuBinning*>(obj);
 567
 568     TIter nextOther(other->fBins);
 569     TObjString* str;
 570
 571     while ( ( str = static_cast<TObjString*>(nextOther()) ) )
 572     {
 573       TObject* o = fBins->GetValue(str->String());
 574       if (!o) return kFALSE;
 575       if (o->IsA() != TObjArray::Class()) return kFALSE;
 576
 577       TObjArray* thisArray = static_cast<TObjArray*>(o);
 578
 579       o = other->fBins->GetValue(str->String());
 580       if (!o) return kFALSE;
 581       if (o->IsA() != TObjArray::Class()) return kFALSE;
 582
 583       TObjArray* otherArray = static_cast<TObjArray*>(o);
 584
 585       Int_t n = thisArray->GetEntries();
 586
 587       if ( n != otherArray->GetEntries() ) return kFALSE;
 588
 589       for ( Int_t i = 0; i < n; ++i )
 590       {
 591         Range* thisRange = static_cast<Range*>(thisArray->At(i));
 592         Range* otherRange = static_cast<Range*>(otherArray->At(i));
 593
 594         if ( !thisRange->IsEqual(otherRange) ) return kFALSE;
 595       }
 596     }
 597     return kTRUE;
 598   }
 599
 600   return kFALSE;
 601 }
 602
 603
 604 //______________________________________________________________________________
 605 Long64_t AliAnalysisMuMuBinning::Merge(TCollection* list)
 606 {
 607   /// Merge method
 608
 609   // Merge a list of AliAnalysisMuMuBinning objects with this
 610   // Returns the number of merged objects (including this).
 611
 612   if (!list) return 0;
 613
 614   if (list->IsEmpty()) return 1;
 615
 616   TIter next(list);
 617   TObject* currObj;
 618   Int_t count(0);
 619
 620   while ( ( currObj = next() ) )
 621   {
 622     AliAnalysisMuMuBinning* binning = dynamic_cast<AliAnalysisMuMuBinning*>(currObj);
 623     if (!binning)
 624     {
 625       AliFatal(Form("object named \"%s\" is a %s instead of an AliAnalysisMuMuBinning!", currObj->GetName(), currObj->ClassName()));
 626       continue;
 627     }
 628
 629     if ( IsEqual(binning) )
 630     {
 631       // nothing to do if we have the same binning already ;-)
 632     }
 633     else
 634     {
 635       AliWarning("Implement me!");
 636       std::cout << ">>>> this=" << std::endl;
 637       Print();
 638       std::cout << ">>>> other=" << std::endl;
 639       binning->Print();
 640     }
 641     ++count;
 642   }
 643
 644   return count+1;
 645 }
 646
 647 //______________________________________________________________________________
 648 AliAnalysisMuMuBinning*
 649 AliAnalysisMuMuBinning::Project(const char* what, const char* quantity, const char* flavour) const
 650 {
 651   /// Create a sub-binning object with only the bins pertaining to (what,Quantity)
 652
 653   TObjArray* bins = CreateBinObjArray(what,quantity,flavour);
 654   if (!bins) return 0x0;
 655   AliAnalysisMuMuBinning* p = new AliAnalysisMuMuBinning;
 656   TIter next(bins);
 657   AliAnalysisMuMuBinning::Range* bin;
 658   TString sQuantity(quantity);
 659   sQuantity.ToUpper();
 660
 661   while ( ( bin = static_cast<AliAnalysisMuMuBinning::Range*>(next())) )
 662   {
 663     if  (bin->Quantity()!=sQuantity || bin->Flavour()!=flavour)
 664     {
 665       AliDebug(1,Form("sQuantity=%s flavour=%s bin=%s => skip",sQuantity.Data(),flavour,bin->AsString().Data()));
 666       continue;
 667     }
 668     {
 669       p->AddBin(what,bin->Quantity(),bin->Xmin(),bin->Xmax(),bin->Ymin(),bin->Ymax(),bin->Flavour().Data());
 670     }
 671   }
 672
 673   delete bins;
 674
 675   return p;
 676 }
 677
 678 //______________________________________________________________________________
 679 void AliAnalysisMuMuBinning::Print(Option_t* /*opt*/) const
 680 {
 681   /// Print the bins
 682
 683   if (!fBins)
 684   {
 685     std::cout << "Empty object. No bin defined. " << std::endl;
 686     return;
 687   }
 688
 689   TIter nextwhat(fBins);
 690   TObjString* str;
 691
 692   while ( ( str = static_cast<TObjString*>(nextwhat()) ) )
 693   {
 694     std::cout << "what : " << str->String().Data() << std::endl;
 695     TObjArray* b = static_cast<TObjArray*>(fBins->GetValue(str->String()));
 696     TIter next(b);
 697     Range* r(0x0);
 698     next.Reset();
 699     Int_t i(1);
 700     while ( ( r = static_cast<Range*>(next()) ) )
 701     {
 702       std::cout << Form("BIN %3d ",i++);
 703       r->Print();
 704     }
 705   }
 706 }
 707
 708 //______________________________________________________________________________
 709 //______________________________________________________________________________
 710 //______________________________________________________________________________
 711 //______________________________________________________________________________
 712
 713 //______________________________________________________________________________
 714 AliAnalysisMuMuBinning::Range::Range(const char* what, const char* quantity,
 715                                      Double_t xmin, Double_t xmax,
 716                                      Double_t ymin, Double_t ymax,
 717                                      const char* flavour)
 718 : TObject(), fWhat(what), fQuantity(quantity),
 719   fXmin(xmin), fXmax(xmax), fYmin(ymin), fYmax(ymax),
 720   fFlavour(flavour)
 721 {
 722   /// ctor
 723   fWhat.ToUpper();
 724   fQuantity.ToUpper();
 725 }
 726
 727 //______________________________________________________________________________
 728 TString AliAnalysisMuMuBinning::Range::AsString() const
 729 {
 730   /// Return a string representation of this range
 731
 732   if ( IsIntegrated()) return Quantity().Data();
 733
 734   TString s;
 735
 736   if ( fFlavour.Length() > 0 )
 737   {
 738     s.Form("%s_%s_%05.2f_%05.2f",Quantity().Data(),Flavour().Data(),Xmin(),Xmax());
 739   }
 740   else
 741   {
 742     s.Form("%s_%05.2f_%05.2f",Quantity().Data(),Xmin(),Xmax());
 743   }
 744
 745   if (Is2D())
 746   {
 747     s += TString::Format("_%06.2f_%06.2f",Ymin(),Ymax());
 748   }
 749
 750   s.ReplaceAll(" ","");
 751   s.ReplaceAll("+","");
 752   s.ReplaceAll("-","m");
 753
 754   return s;
 755 }
 756
 757 //______________________________________________________________________________
 758 Int_t   AliAnalysisMuMuBinning::Range::Compare(const TObject* obj) const
 759 {
 760   //  Must return -1 if this is smaller
 761   // than obj, 0 if objects are equal and 1 if this is larger than obj.
 762   const Range* other = static_cast<const Range*>(obj);
 763
 764   int s = strcmp(What().Data(),other->What().Data());
 765
 766   if ( s ) return s;
 767
 768   s = strcmp(Quantity().Data(),other->Quantity().Data());
 769
 770   if (s) return s;
 771
 772   s = strcmp(Flavour().Data(),other->Flavour().Data());
 773
 774   if (s) return s;
 775
 776 //  if ( IsIntegrated() && other->IsIntegrated() ) return 0;
 777
 778   if ( Xmin() < other->Xmin() )
 779   {
 780     return -1;
 781   }
 782   else if ( Xmin() > other->Xmin() )
 783   {
 784     return 1;
 785   }
 786   else
 787   {
 788     if  ( Xmax() < other->Xmax() )
 789     {
 790       return -1;
 791     }
 792     else if ( Xmax() > other->Xmax() )
 793     {
 794       return 1;
 795     }
 796     else {
 797       if ( Ymin() < other->Ymin() )
 798       {
 799         return -1;
 800       }
 801       else if ( Ymin() > other->Ymin() )
 802       {
 803         return 1;
 804       }
 805       else
 806       {
 807         if ( Ymax() < other->Ymax() )
 808         {
 809           return -1;
 810         }
 811         else if ( Ymax() > other->Ymax() )
 812         {
 813           return 1;
 814         }
 815       }
 816     }
 817   }
 818   return 0;
 819 }
 820
 821 //______________________________________________________________________________
 822 Bool_t AliAnalysisMuMuBinning::Range::IsInRange(Double_t x, Double_t y) const
 823 {
 824   /// If Range is 1D, returns true if x is in range
 825   /// If Range is 2D, returns true if (x,y) is in range
 826
 827   if ( IsIntegrated() )
 828   {
 829     return kTRUE;
 830   }
 831   else
 832   {
 833     if ( Is2D() )
 834     {
 835       return ( x >= Xmin() && x < Xmax() && y >= Ymin() && y < Ymax());
 836     }
 837     else
 838     {
 839       return ( x >= Xmin() && x < Xmax() );
 840     }
 841   }
 842 }
 843
 844 //______________________________________________________________________________
 845 Bool_t AliAnalysisMuMuBinning::Range::IsIntegrated() const
 846 {
 847   /// Whether we're a null object (aka integrated) or not
 848   return
 849   Xmin() >= TMath::Limits<Double_t>::Max() &&
 850   Ymin() >= TMath::Limits<Double_t>::Max() &&
 851   Xmax() >= TMath::Limits<Double_t>::Max() &&
 852   Ymax() >= TMath::Limits<Double_t>::Max() ;
 853 }
 854
 855
 856 //______________________________________________________________________________
 857 void AliAnalysisMuMuBinning::Range::Print(Option_t* /*opt*/) const
 858 {
 859   /// Output to stdout
 860
 861   if (IsIntegrated())
 862   {
 863     std::cout << Form("%s : %s : INTEGRATED",What().Data(),Quantity().Data()) << std::endl;
 864
 865     return;
 866   }
 867
 868   std::cout << Form("%s : %s : %5.2f : %5.2f",What().Data(),Quantity().Data(),Xmin(),Xmax());
 869
 870   if (Is2D())
 871   {
 872     std::cout << Form(" ; %5.2f : %5.2f",Ymin(),Ymax());
 873   }
 874
 875   if (Flavour().Length()>0)
 876   {
 877     std::cout << " - " << Flavour().Data();
 878   }
 879
 880   std::cout << "->" << AsString().Data() << std::endl;
 881
 882 }
 883
 884