PWG3/vertexingHF/AliRDHFCuts.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /////////////////////////////////////////////////////////////
  17 //
  18 // Base class for cuts on AOD reconstructed heavy-flavour decay
  19 //
  20 // Author: A.Dainese, andrea.dainese@pd.infn.it
  21 /////////////////////////////////////////////////////////////
  22 #include <Riostream.h>
  23
  24 #include "AliVEvent.h"
  25 #include "AliESDEvent.h"
  26 #include "AliAODEvent.h"
  27 #include "AliVVertex.h"
  28 #include "AliESDVertex.h"
  29 #include "AliAODVertex.h"
  30 #include "AliESDtrack.h"
  31 #include "AliAODTrack.h"
  32 #include "AliESDtrackCuts.h"
  33 #include "AliAODRecoDecayHF.h"
  34 #include "AliRDHFCuts.h"
  35
  36 ClassImp(AliRDHFCuts)
  37
  38 //--------------------------------------------------------------------------
  39 AliRDHFCuts::AliRDHFCuts(const Char_t* name, const Char_t* title) :
  40 AliAnalysisCuts(name,title),
  41 fMinVtxType(3),
  42 fMinVtxContr(1),
  43 fMaxVtxRedChi2(1e6),
  44 fMinSPDMultiplicity(0),
  45 fTriggerMask(0),
  46 fTrackCuts(0),
  47 fnPtBins(1),
  48 fnPtBinLimits(1),
  49 fPtBinLimits(0),
  50 fnVars(1),
  51 fVarNames(0),
  52 fnVarsForOpt(0),
  53 fVarsForOpt(0),
  54 fGlobalIndex(1),
  55 fCutsRD(0),
  56 fIsUpperCut(0),
  57 fUsePID(kFALSE),
  58 fPidHF(0),
  59 fWhyRejection(0),
  60 fRemoveDaughtersFromPrimary(kFALSE),
  61 fOptPileup(0),
  62 fMinContrPileup(3),
  63 fMinDzPileup(0.6)
  64 {
  65   //
  66   // Default Constructor
  67   //
  68 }
  69 //--------------------------------------------------------------------------
  70 AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :
  71   AliAnalysisCuts(source),
  72   fMinVtxType(source.fMinVtxType),
  73   fMinVtxContr(source.fMinVtxContr),
  74   fMaxVtxRedChi2(source.fMaxVtxRedChi2),
  75   fMinSPDMultiplicity(source.fMinSPDMultiplicity),
  76   fTriggerMask(source.fTriggerMask),
  77   fTrackCuts(0),
  78   fnPtBins(source.fnPtBins),
  79   fnPtBinLimits(source.fnPtBinLimits),
  80   fPtBinLimits(0),
  81   fnVars(source.fnVars),
  82   fVarNames(0),
  83   fnVarsForOpt(source.fnVarsForOpt),
  84   fVarsForOpt(0),
  85   fGlobalIndex(source.fGlobalIndex),
  86   fCutsRD(0),
  87   fIsUpperCut(0),
  88   fUsePID(source.fUsePID),
  89   fPidHF(0),
  90   fWhyRejection(source.fWhyRejection),
  91   fRemoveDaughtersFromPrimary(source.fRemoveDaughtersFromPrimary),
  92   fOptPileup(source.fOptPileup),
  93   fMinContrPileup(source.fMinContrPileup),
  94   fMinDzPileup(source.fMinDzPileup)
  95 {
  96   //
  97   // Copy constructor
  98   //
  99   cout<<"Copy constructor"<<endl;
 100   if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
 101   if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
 102   if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
 103   if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
 104   if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
 105   if(source.fPidHF) SetPidHF(source.fPidHF);
 106   PrintAll();
 107
 108 }
 109 //--------------------------------------------------------------------------
 110 AliRDHFCuts &AliRDHFCuts::operator=(const AliRDHFCuts &source)
 111 {
 112   //
 113   // assignment operator
 114   //
 115   if(&source == this) return *this;
 116
 117   AliAnalysisCuts::operator=(source);
 118
 119   fMinVtxType=source.fMinVtxType;
 120   fMinVtxContr=source.fMinVtxContr;
 121   fMaxVtxRedChi2=source.fMaxVtxRedChi2;
 122   fMinSPDMultiplicity=source.fMinSPDMultiplicity;
 123   fTriggerMask=source.fTriggerMask;
 124   fnPtBins=source.fnPtBins;
 125   fnVars=source.fnVars;
 126   fGlobalIndex=source.fGlobalIndex;
 127   fnVarsForOpt=source.fnVarsForOpt;
 128   fUsePID=source.fUsePID;
 129   SetPidHF(source.GetPidHF());
 130   fWhyRejection=source.fWhyRejection;
 131   fRemoveDaughtersFromPrimary=source.fRemoveDaughtersFromPrimary;
 132   fOptPileup=source.fOptPileup;
 133   fMinContrPileup=source.fMinContrPileup;
 134   fMinDzPileup=source.fMinDzPileup;
 135
 136   if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
 137   if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
 138   if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
 139   if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
 140   if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
 141   PrintAll();
 142
 143   return *this;
 144 }
 145 //--------------------------------------------------------------------------
 146 AliRDHFCuts::~AliRDHFCuts() {
 147   //
 148   // Default Destructor
 149   //
 150   if(fPtBinLimits) {delete [] fPtBinLimits; fPtBinLimits=0;}
 151   if(fVarNames) {delete [] fVarNames; fVarNames=0;}
 152   if(fVarsForOpt) {delete [] fVarsForOpt; fVarsForOpt=0;}
 153   if(fCutsRD) {
 154     delete [] fCutsRD;
 155     fCutsRD=0;
 156   }
 157   if(fIsUpperCut) {delete [] fIsUpperCut; fIsUpperCut=0;}
 158   if(fPidHF){
 159     delete fPidHF;
 160     fPidHF=0;
 161   }
 162 }
 163 //---------------------------------------------------------------------------
 164 Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) {
 165   //
 166   // Event selection
 167   //
 168   //if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;
 169
 170   fWhyRejection=0;
 171
 172   // multiplicity cuts no implemented yet
 173
 174
 175
 176   const AliVVertex *vertex = event->GetPrimaryVertex();
 177
 178   if(!vertex) return kFALSE;
 179
 180   TString title=vertex->GetTitle();
 181   if(title.Contains("Z") && fMinVtxType>1) return kFALSE;
 182   if(title.Contains("3D") && fMinVtxType>2) return kFALSE;
 183
 184   if(vertex->GetNContributors()<fMinVtxContr) return kFALSE;
 185
 186   // switch to settings for 1-pad cls in TPC
 187   if(fPidHF) {
 188     if(event->GetRunNumber()>121693 && event->GetRunNumber()<136851)
 189       fPidHF->SetOnePad(kTRUE);
 190     if(event->GetRunNumber()>=136851 && event->GetRunNumber()<=139517)
 191       fPidHF->SetPbPb(kTRUE);
 192   }
 193
 194   if(fOptPileup==kRejectPileupEvent){
 195     Int_t cutc=(Int_t)fMinContrPileup;
 196     Double_t cutz=(Double_t)fMinDzPileup;
 197     if(event->IsPileupFromSPD(cutc,cutz,3.,2.,10.)) {
 198       fWhyRejection=1;
 199       return kFALSE;
 200     }
 201   }
 202
 203   return kTRUE;
 204 }
 205 //---------------------------------------------------------------------------
 206 Bool_t AliRDHFCuts::AreDaughtersSelected(AliAODRecoDecayHF *d) const {
 207   //
 208   // Daughter tracks selection
 209   //
 210   if(!fTrackCuts) return kTRUE;
 211
 212   Int_t ndaughters = d->GetNDaughters();
 213   AliAODVertex *vAOD = d->GetPrimaryVtx();
 214   Double_t pos[3],cov[6];
 215   vAOD->GetXYZ(pos);
 216   vAOD->GetCovarianceMatrix(cov);
 217   const AliESDVertex vESD(pos,cov,100.,100);
 218
 219   Bool_t retval=kTRUE;
 220
 221   for(Int_t idg=0; idg<ndaughters; idg++) {
 222     AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
 223     if(!dgTrack) retval = kFALSE;
 224     //printf("charge %d\n",dgTrack->Charge());
 225     if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
 226
 227     if(!IsDaughterSelected(dgTrack,&vESD,fTrackCuts)) retval = kFALSE;
 228   }
 229
 230   return retval;
 231 }
 232 //---------------------------------------------------------------------------
 233 Bool_t AliRDHFCuts::IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const {
 234   //
 235   // Convert to ESDtrack, relate to vertex and check cuts
 236   //
 237   if(!cuts) return kTRUE;
 238
 239   Bool_t retval=kTRUE;
 240
 241   // convert to ESD track here
 242   AliESDtrack esdTrack(track);
 243   // needed to calculate the impact parameters
 244   esdTrack.RelateToVertex(primary,0.,3.);
 245   if(!cuts->IsSelected(&esdTrack)) retval = kFALSE;
 246
 247   if(fOptPileup==kRejectTracksFromPileupVertex){
 248     // to be implemented
 249     // we need either to have here the AOD Event,
 250     // or to have the pileup vertex object
 251   }
 252   return retval;
 253 }
 254 //---------------------------------------------------------------------------
 255 void AliRDHFCuts::SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits) {
 256   // Set the pt bins
 257
 258   if(fPtBinLimits) {
 259     delete [] fPtBinLimits;
 260     fPtBinLimits = NULL;
 261     printf("Changing the pt bins\n");
 262   }
 263
 264   if(nPtBinLimits != fnPtBins+1){
 265     cout<<"Warning: ptBinLimits dimention "<<nPtBinLimits<<" != nPtBins+1 ("<<fnPtBins+1<<")\nSetting nPtBins to "<<nPtBinLimits-1<<endl;
 266     SetNPtBins(nPtBinLimits-1);
 267   }
 268
 269   fnPtBinLimits = nPtBinLimits;
 270   SetGlobalIndex();
 271   //cout<<"Changing also Global Index -> "<<fGlobalIndex<<endl;
 272   fPtBinLimits = new Float_t[fnPtBinLimits];
 273   for(Int_t ib=0; ib<nPtBinLimits; ib++) fPtBinLimits[ib]=ptBinLimits[ib];
 274
 275   return;
 276 }
 277 //---------------------------------------------------------------------------
 278 void AliRDHFCuts::SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut){
 279   // Set the variable names
 280
 281   if(fVarNames) {
 282     delete [] fVarNames;
 283     fVarNames = NULL;
 284     //printf("Changing the variable names\n");
 285   }
 286   if(nVars!=fnVars){
 287     printf("Wrong number of variables: it has to be %d\n",fnVars);
 288     return;
 289   }
 290   //fnVars=nVars;
 291   fVarNames = new TString[nVars];
 292   fIsUpperCut = new Bool_t[nVars];
 293   for(Int_t iv=0; iv<nVars; iv++) {
 294     fVarNames[iv] = varNames[iv];
 295     fIsUpperCut[iv] = isUpperCut[iv];
 296   }
 297
 298   return;
 299 }
 300 //---------------------------------------------------------------------------
 301 void AliRDHFCuts::SetVarsForOpt(Int_t nVars,Bool_t *forOpt) {
 302   // Set the variables to be used for cuts optimization
 303
 304   if(fVarsForOpt) {
 305     delete [] fVarsForOpt;
 306     fVarsForOpt = NULL;
 307     //printf("Changing the variables for cut optimization\n");
 308   }
 309
 310   if(nVars==0){//!=fnVars) {
 311     printf("%d not accepted as number of variables: it has to be %d\n",nVars,fnVars);
 312     return;
 313   }
 314
 315   fnVarsForOpt = 0;
 316   fVarsForOpt = new Bool_t[fnVars];
 317   for(Int_t iv=0; iv<fnVars; iv++) {
 318     fVarsForOpt[iv]=forOpt[iv];
 319     if(fVarsForOpt[iv]) fnVarsForOpt++;
 320   }
 321
 322   return;
 323 }
 324 //---------------------------------------------------------------------------
 325 void AliRDHFCuts::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {
 326   //
 327   // store the cuts
 328   //
 329   if(nVars!=fnVars) {
 330     printf("Wrong number of variables: it has to be %d\n",fnVars);
 331     return;
 332   }
 333   if(nPtBins!=fnPtBins) {
 334     printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
 335     return;
 336   }
 337
 338   if(!fCutsRD)  fCutsRD = new Float_t[fGlobalIndex];
 339
 340
 341   for(Int_t iv=0; iv<fnVars; iv++) {
 342
 343     for(Int_t ib=0; ib<fnPtBins; ib++) {
 344
 345       //check
 346       if(GetGlobalIndex(iv,ib)>=fGlobalIndex) {
 347         cout<<"Overflow, exit..."<<endl;
 348         return;
 349       }
 350
 351       fCutsRD[GetGlobalIndex(iv,ib)] = cutsRD[iv][ib];
 352
 353     }
 354   }
 355   return;
 356 }
 357 //---------------------------------------------------------------------------
 358 void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){
 359   //
 360   // store the cuts
 361   //
 362   if(glIndex != fGlobalIndex){
 363     cout<<"Wrong array size: it has to be "<<fGlobalIndex<<endl;
 364     return;
 365   }
 366   if(!fCutsRD)  fCutsRD = new Float_t[fGlobalIndex];
 367
 368   for(Int_t iGl=0;iGl<fGlobalIndex;iGl++){
 369     fCutsRD[iGl] = cutsRDGlob[iGl];
 370   }
 371   return;
 372 }
 373 //---------------------------------------------------------------------------
 374 void AliRDHFCuts::PrintAll() const {
 375   //
 376   // print all cuts values
 377   //
 378
 379   printf("Minimum vtx type %d\n",fMinVtxType);
 380   printf("Minimum vtx contr %d\n",fMinVtxContr);
 381   printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);
 382   printf("Min SPD mult %d\n",fMinSPDMultiplicity);
 383   printf("Use PID %d\n",(Int_t)fUsePID);
 384   printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);
 385
 386   if(fVarNames){
 387     cout<<"Array of variables"<<endl;
 388     for(Int_t iv=0;iv<fnVars;iv++){
 389       cout<<fVarNames[iv]<<"\t";
 390     }
 391     cout<<endl;
 392   }
 393   if(fVarsForOpt){
 394     cout<<"Array of optimization"<<endl;
 395     for(Int_t iv=0;iv<fnVars;iv++){
 396       cout<<fVarsForOpt[iv]<<"\t";
 397     }
 398     cout<<endl;
 399   }
 400   if(fIsUpperCut){
 401     cout<<"Array of upper/lower cut"<<endl;
 402    for(Int_t iv=0;iv<fnVars;iv++){
 403      cout<<fIsUpperCut[iv]<<"\t";
 404    }
 405    cout<<endl;
 406   }
 407   if(fPtBinLimits){
 408     cout<<"Array of ptbin limits"<<endl;
 409     for(Int_t ib=0;ib<fnPtBinLimits;ib++){
 410       cout<<fPtBinLimits[ib]<<"\t";
 411     }
 412     cout<<endl;
 413   }
 414   if(fCutsRD){
 415     cout<<"Matrix of cuts"<<endl;
 416    for(Int_t iv=0;iv<fnVars;iv++){
 417      for(Int_t ib=0;ib<fnPtBins;ib++){
 418        cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";
 419      }
 420      cout<<endl;
 421    }
 422    cout<<endl;
 423   }
 424   return;
 425 }
 426 //---------------------------------------------------------------------------
 427 void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{
 428   //
 429   // get the cuts
 430   //
 431
 432   //cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;
 433
 434
 435   Int_t iv,ib;
 436   if(!cutsRD) {
 437     //cout<<"Initialization..."<<endl;
 438     cutsRD=new Float_t*[fnVars];
 439     for(iv=0; iv<fnVars; iv++) {
 440       cutsRD[iv] = new Float_t[fnPtBins];
 441     }
 442   }
 443
 444   for(Int_t iGlobal=0; iGlobal<fGlobalIndex; iGlobal++) {
 445     GetVarPtIndex(iGlobal,iv,ib);
 446     cutsRD[iv][ib] = fCutsRD[iGlobal];
 447   }
 448
 449   return;
 450 }
 451
 452 //---------------------------------------------------------------------------
 453 Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{
 454   //
 455   // give the global index from variable and pt bin
 456   //
 457   return iPtBin*fnVars+iVar;
 458 }
 459
 460 //---------------------------------------------------------------------------
 461 void AliRDHFCuts::GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const {
 462   //
 463   //give the index of the variable and of the pt bin from the global index
 464   //
 465   iPtBin=(Int_t)iGlob/fnVars;
 466   iVar=iGlob%fnVars;
 467
 468   return;
 469 }
 470
 471 //---------------------------------------------------------------------------
 472 Int_t AliRDHFCuts::PtBin(Double_t pt) const {
 473   //
 474   //give the pt bin where the pt lies.
 475   //
 476   Int_t ptbin=-1;
 477   for (Int_t i=0;i<fnPtBins;i++){
 478     if(pt<fPtBinLimits[i+1]) {
 479       ptbin=i;
 480       break;
 481     }
 482   }
 483   return ptbin;
 484 }
 485 //-------------------------------------------------------------------
 486 Float_t AliRDHFCuts::GetCutValue(Int_t iVar,Int_t iPtBin) const {
 487   //
 488   // Give the value of cut set for the variable iVar and the pt bin iPtBin
 489   //
 490   if(!fCutsRD){
 491     cout<<"Cuts not iniziaisez yet"<<endl;
 492     return 0;
 493   }
 494   return fCutsRD[GetGlobalIndex(iVar,iPtBin)];
 495 }
 496 //-------------------------------------------------------------------
 497 Bool_t AliRDHFCuts::CompareCuts(const AliRDHFCuts *obj) const {
 498   //
 499   // Compare two cuts objects
 500   //
 501
 502   Bool_t areEqual=kTRUE;
 503
 504   if(fMinVtxType!=obj->fMinVtxType) { printf("Minimum vtx type %d  %d\n",fMinVtxType,obj->fMinVtxType); areEqual=kFALSE;}
 505
 506   if(fMinVtxContr!=obj->fMinVtxContr) { printf("Minimum vtx contr %d  %d\n",fMinVtxContr,obj->fMinVtxContr); areEqual=kFALSE;}
 507
 508   if(TMath::Abs(fMaxVtxRedChi2-obj->fMaxVtxRedChi2)>1.e-10) {   printf("Max vtx red chi2 %f  %f\n",fMaxVtxRedChi2,obj->fMaxVtxRedChi2);areEqual=kFALSE;}
 509
 510   if(fMinSPDMultiplicity!=obj->fMinSPDMultiplicity) {  printf("Min SPD mult %d\n  %d",fMinSPDMultiplicity,obj->fMinSPDMultiplicity);areEqual=kFALSE;}
 511
 512   if(fUsePID!=obj->fUsePID) { printf("Use PID %d  %d\n",(Int_t)fUsePID,(Int_t)obj->fUsePID); areEqual=kFALSE;}
 513
 514   if(fRemoveDaughtersFromPrimary!=obj->fRemoveDaughtersFromPrimary) {printf("Remove daughters from vtx %d  %d\n",(Int_t)fRemoveDaughtersFromPrimary,(Int_t)obj->fRemoveDaughtersFromPrimary); areEqual=kFALSE;}
 515   if(fTrackCuts){
 516     if(fTrackCuts->GetMinNClusterTPC()!=obj->fTrackCuts->GetMinNClusterTPC()) {printf("MinNClsTPC %d  %d\n",fTrackCuts->GetMinNClusterTPC(),obj->fTrackCuts->GetMinNClusterTPC()); areEqual=kFALSE;}
 517
 518     if(fTrackCuts->GetMinNClustersITS()!=obj->fTrackCuts->GetMinNClustersITS()) {printf("MinNClsITS %d  %d\n",fTrackCuts->GetMinNClustersITS(),obj->fTrackCuts->GetMinNClustersITS()); areEqual=kFALSE;}
 519
 520     if(TMath::Abs(fTrackCuts->GetMaxChi2PerClusterTPC()-obj->fTrackCuts->GetMaxChi2PerClusterTPC())>1.e-10) {printf("MaxChi2ClsTPC %f  %f\n",fTrackCuts->GetMaxChi2PerClusterTPC(),obj->fTrackCuts->GetMaxChi2PerClusterTPC()); areEqual=kFALSE;}
 521
 522     if(fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)!=obj->fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)) {printf("ClusterReq SPD %d  %d\n",fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD),obj->fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)); areEqual=kFALSE;}
 523   }
 524
 525   if(fCutsRD) {
 526    for(Int_t iv=0;iv<fnVars;iv++) {
 527      for(Int_t ib=0;ib<fnPtBins;ib++) {
 528        if(TMath::Abs(fCutsRD[GetGlobalIndex(iv,ib)]-obj->fCutsRD[GetGlobalIndex(iv,ib)])>1.e-10) {
 529          cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"   "<<obj->fCutsRD[GetGlobalIndex(iv,ib)]<<"\n";
 530          areEqual=kFALSE;
 531        }
 532      }
 533    }
 534   }
 535
 536   return areEqual;
 537 }
 538 //---------------------------------------------------------------------------
 539 void AliRDHFCuts::MakeTable() const {
 540   //
 541   // print cuts values in table format
 542   //
 543
 544         TString ptString = "pT range";
 545         if(fVarNames && fPtBinLimits && fCutsRD){
 546                 TString firstLine(Form("*       %-15s",ptString.Data()));
 547                 for (Int_t ivar=0; ivar<fnVars; ivar++){
 548                         firstLine+=Form("*    %-15s  ",fVarNames[ivar].Data());
 549                         if (ivar == fnVars){
 550                                 firstLine+="*\n";
 551                         }
 552                 }
 553                 Printf("%s",firstLine.Data());
 554
 555                 for (Int_t ipt=0; ipt<fnPtBins; ipt++){
 556                         TString line;
 557                         if (ipt==fnPtBins-1){
 558                                 line=Form("*  %5.1f < pt < inf    ",fPtBinLimits[ipt]);
 559                         }
 560                         else{
 561                                 line=Form("*  %5.1f < pt < %4.1f   ",fPtBinLimits[ipt],fPtBinLimits[ipt+1]);
 562                         }
 563                         for (Int_t ivar=0; ivar<fnVars; ivar++){
 564                                 line+=Form("*     %-15f ",fCutsRD[GetGlobalIndex(ivar,ipt)]);
 565                         }
 566                         Printf("%s",line.Data());
 567                 }
 568
 569         }
 570
 571
 572   return;
 573 }