PWGLF/RESONANCES/AliRsnCutTrackQuality.cxx

   1 //
   2 // Class AliRsnCutTrackQuality
   3 //
   4 // General implementation of a single cut strategy, which can be:
   5 // - a value contained in a given interval  [--> IsBetween()   ]
   6 // - a value equal to a given reference     [--> MatchesValue()]
   7 //
   8 // In all cases, the reference value(s) is (are) given as data members
   9 // and each kind of cut requires a given value type (Int, UInt, Double),
  10 // but the cut check procedure is then automatized and chosen thanks to
  11 // an enumeration of the implemented cut types.
  12 // At the end, the user (or any other point which uses this object) has
  13 // to use the method IsSelected() to check if this cut has been passed.
  14 //
  15 // authors: Martin Vala (martin.vala@cern.ch)
  16 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
  17 //
  18
  19 #include <Riostream.h>
  20 #include <TFormula.h>
  21 #include <TBits.h>
  22
  23 #include "AliLog.h"
  24 #include "AliESDtrackCuts.h"
  25
  26 #include "AliRsnEvent.h"
  27 #include "AliRsnDaughter.h"
  28 #include "AliRsnCutTrackQuality.h"
  29
  30 ClassImp(AliRsnCutTrackQuality)
  31
  32 //_________________________________________________________________________________________________
  33 AliRsnCutTrackQuality::AliRsnCutTrackQuality(const char *name) :
  34    AliRsnCut(name, AliRsnTarget::kDaughter, 0.0, 0.0),
  35    fFlagsOn(0x0),
  36    fFlagsOff(0x0),
  37    fRejectKinkDaughters(kTRUE),
  38    fDCARmaxfixed(kTRUE),
  39    fDCARminfixed(kTRUE),
  40    fDCARptFormula(""),
  41    fDCARptFormulaMin(""),
  42    fDCARmax(1E20),
  43    fDCARmin(0),
  44    fDCAZfixed(kTRUE),
  45    fDCAZptFormula(""),
  46    fDCAZmax(1E20),
  47    fSPDminNClusters(0),
  48    fITSminNClusters(0),
  49    fITSmaxChi2(1E20),
  50    fTPCminNClusters(0),
  51    fTPCmaxChi2(1E20),
  52    fCutMaxChi2TPCConstrainedVsGlobal(1E20),
  53    fIsUseCrossedRowsCut(kFALSE),
  54    fTPCminNCrossedRows(0),
  55    fTPCminCrossedRowsOverFindableCls(0),
  56    fIsUseLengthActiveVolumeTPCCut(kFALSE),
  57    fCutMinLengthActiveVolumeTPC(0),
  58    fAODTestFilterBit(-1),
  59    fCheckOnlyFilterBit(kTRUE),
  60    fESDtrackCuts(0x0)
  61 {
  62 //
  63 // Default constructor.
  64 // Initializes all cuts in such a way that all of them are disabled.
  65 //
  66    SetPtRange(0.0, 1E20);
  67    SetEtaRange(-1E20, 1E20);
  68 }
  69
  70 //_________________________________________________________________________________________________
  71 AliRsnCutTrackQuality::AliRsnCutTrackQuality(const AliRsnCutTrackQuality &copy) :
  72    AliRsnCut(copy),
  73    fFlagsOn(copy.fFlagsOn),
  74    fFlagsOff(copy.fFlagsOff),
  75    fRejectKinkDaughters(copy.fRejectKinkDaughters),
  76    fDCARmaxfixed(copy.fDCARmaxfixed),
  77    fDCARminfixed(copy.fDCARminfixed),
  78    fDCARptFormula(copy.fDCARptFormula),
  79    fDCARptFormulaMin(copy.fDCARptFormulaMin),
  80    fDCARmax(copy.fDCARmax),
  81    fDCARmin(copy.fDCARmin),
  82    fDCAZfixed(copy.fDCAZfixed),
  83    fDCAZptFormula(copy.fDCAZptFormula),
  84    fDCAZmax(copy.fDCAZmax),
  85    fSPDminNClusters(copy.fSPDminNClusters),
  86    fITSminNClusters(copy.fITSminNClusters),
  87    fITSmaxChi2(copy.fITSmaxChi2),
  88    fTPCminNClusters(copy.fTPCminNClusters),
  89    fTPCmaxChi2(copy.fTPCmaxChi2),
  90    fCutMaxChi2TPCConstrainedVsGlobal(copy.fCutMaxChi2TPCConstrainedVsGlobal),
  91    fIsUseCrossedRowsCut(copy.fIsUseCrossedRowsCut),
  92    fTPCminNCrossedRows(copy.fTPCminNCrossedRows),
  93    fTPCminCrossedRowsOverFindableCls(copy.fTPCminCrossedRowsOverFindableCls),
  94    fIsUseLengthActiveVolumeTPCCut(copy.fIsUseLengthActiveVolumeTPCCut),
  95    fCutMinLengthActiveVolumeTPC(copy.fCutMinLengthActiveVolumeTPC),
  96    fAODTestFilterBit(copy.fAODTestFilterBit),
  97    fCheckOnlyFilterBit(copy.fCheckOnlyFilterBit),
  98    fESDtrackCuts(copy.fESDtrackCuts)
  99 {
 100 //
 101 // Copy constructor.
 102 // Just copy all data member values.
 103 //
 104
 105    SetPtRange(copy.fPt[0], copy.fPt[1]);
 106    SetEtaRange(copy.fEta[0], copy.fEta[1]);
 107 }
 108
 109 //_________________________________________________________________________________________________
 110 AliRsnCutTrackQuality &AliRsnCutTrackQuality::operator=(const AliRsnCutTrackQuality &copy)
 111 {
 112 //
 113 // Assignment operator.
 114 // Just copy all data member values.
 115 //
 116
 117    if (this == &copy)
 118       return *this;
 119
 120    fFlagsOn = copy.fFlagsOn;
 121    fFlagsOff = copy.fFlagsOff;
 122    fRejectKinkDaughters = copy.fRejectKinkDaughters;
 123    fDCARmaxfixed = copy.fDCARmaxfixed;
 124    fDCARminfixed = copy.fDCARminfixed;
 125    fDCARptFormula = copy.fDCARptFormula;
 126    fDCARptFormulaMin = copy.fDCARptFormulaMin;
 127    fDCARmax = copy.fDCARmax;
 128    fDCARmin = copy.fDCARmin;
 129    fDCAZfixed = copy.fDCAZfixed;
 130    fDCAZptFormula = copy.fDCAZptFormula;
 131    fDCAZmax = copy.fDCAZmax;
 132    fSPDminNClusters = copy.fSPDminNClusters;
 133    fITSminNClusters = copy.fITSminNClusters;
 134    fITSmaxChi2 = copy.fITSmaxChi2;
 135    fTPCminNClusters = copy.fTPCminNClusters;
 136    fTPCmaxChi2 = copy.fTPCmaxChi2;
 137    fCutMaxChi2TPCConstrainedVsGlobal = copy.fCutMaxChi2TPCConstrainedVsGlobal;
 138    fIsUseCrossedRowsCut=copy.fIsUseCrossedRowsCut;
 139    fTPCminNCrossedRows = copy.fTPCminNCrossedRows;
 140    fTPCminCrossedRowsOverFindableCls = copy.fTPCminCrossedRowsOverFindableCls;
 141    fIsUseLengthActiveVolumeTPCCut=copy.fIsUseLengthActiveVolumeTPCCut;
 142    fCutMinLengthActiveVolumeTPC = copy.fCutMinLengthActiveVolumeTPC;
 143
 144    fAODTestFilterBit = copy.fAODTestFilterBit;
 145    fCheckOnlyFilterBit = copy.fCheckOnlyFilterBit;
 146    fESDtrackCuts = copy.fESDtrackCuts;
 147    SetPtRange(copy.fPt[0], copy.fPt[1]);
 148    SetEtaRange(copy.fEta[0], copy.fEta[1]);
 149
 150    return (*this);
 151 }
 152
 153 //_________________________________________________________________________________________________
 154 void AliRsnCutTrackQuality::DisableAll()
 155 {
 156 //
 157 // Disable all cuts
 158 //
 159
 160    fFlagsOn = 0x0;
 161    fFlagsOff = 0x0;
 162    fRejectKinkDaughters = kFALSE;
 163    fDCARmaxfixed = kTRUE;
 164    fDCARminfixed = kTRUE;
 165    fDCARptFormula = "";
 166    fDCARptFormulaMin = "";
 167    fDCARmax = 1E20;
 168    fDCARmin = 0;
 169    fDCAZfixed = kTRUE;
 170    fDCAZptFormula = "";
 171    fDCAZmax = 1E20;
 172    fSPDminNClusters = 0;
 173    fITSminNClusters = 0;
 174    fITSmaxChi2 = 1E20;
 175    fTPCminNClusters = 0;
 176    fTPCmaxChi2 = 1E20;
 177    fAODTestFilterBit = -1;
 178    fCutMaxChi2TPCConstrainedVsGlobal = 1E20;
 179    fIsUseCrossedRowsCut = 0;
 180    fTPCminNCrossedRows = 0;
 181    fTPCminCrossedRowsOverFindableCls = 0;
 182    fIsUseLengthActiveVolumeTPCCut = 0;
 183    fCutMinLengthActiveVolumeTPC = 0.0;
 184
 185    if (fESDtrackCuts) {
 186       const char *cutsName = fESDtrackCuts->GetName();
 187       const char *cutsTitle = fESDtrackCuts->GetTitle();
 188       delete fESDtrackCuts;
 189       fESDtrackCuts = new AliESDtrackCuts(cutsName,cutsTitle);
 190    }
 191    SetPtRange(0.0, 1E20);
 192    SetEtaRange(-1E20, 1E20);
 193 }
 194
 195 //_________________________________________________________________________________________________
 196 Bool_t AliRsnCutTrackQuality::IsSelected(TObject *object)
 197 {
 198 //
 199 // Cut checker.
 200 // Checks the type of object being evaluated
 201 // and then calls the appropriate sub-function (for ESD or AOD)
 202 //
 203
 204    // coherence check
 205    if (!TargetOK(object)) return kFALSE;
 206
 207    // status is checked in the same way for all tracks, using AliVTrack
 208    // as a convention, if a the collection of 'on' flags is '0x0', it
 209    // is assumed that no flags are required, and this check is skipped;
 210    // for the collection of 'off' flags this is not needed
 211    AliVTrack *vtrack = fDaughter->Ref2Vtrack();
 212    if (!vtrack) {
 213       AliDebug(AliLog::kDebug + 2, "This object is not either an ESD nor AOD track");
 214       return kFALSE;
 215    }
 216    ULong_t status   = (ULong_t)vtrack->GetStatus();
 217    ULong_t checkOn  = status & fFlagsOn;
 218    ULong_t checkOff = status & fFlagsOff;
 219    if (fFlagsOn != 0x0 && checkOn != fFlagsOn) {
 220       AliDebug(AliLog::kDebug + 2, Form("Failed flag check: required  %s", Binary(fFlagsOn)));
 221       AliDebug(AliLog::kDebug + 2, Form("                   track has %s", Binary(status  )));
 222       return kFALSE;
 223    }
 224    if (checkOff != 0) {
 225       AliDebug(AliLog::kDebug + 2, Form("Failed flag check: forbidden %s", Binary(fFlagsOff)));
 226       AliDebug(AliLog::kDebug + 2, Form("                   track has %s", Binary(status  )));
 227       return kFALSE;
 228    }
 229    AliDebug(AliLog::kDebug + 3, Form("Flag check OK: required  %s", Binary(fFlagsOn)));
 230    AliDebug(AliLog::kDebug + 3, Form("               forbidden %s", Binary(fFlagsOff)));
 231    AliDebug(AliLog::kDebug + 3, Form("               track has %s", Binary(status  )));
 232
 233    // retrieve real object type
 234    AliESDtrack *esdTrack = fDaughter->Ref2ESDtrack();
 235    AliAODTrack *aodTrack = fDaughter->Ref2AODtrack();
 236    if (esdTrack) {
 237       AliDebug(AliLog::kDebug + 2, "Checking an ESD track");
 238       if (fESDtrackCuts)
 239          return fESDtrackCuts->IsSelected(esdTrack);
 240       else
 241          return CheckESD(esdTrack);
 242    } else if (aodTrack) {
 243       AliDebug(AliLog::kDebug + 2, "Checking an AOD track");
 244       return CheckAOD(aodTrack);
 245    } else {
 246       AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
 247       return kFALSE;
 248    }
 249 }
 250
 251 //_________________________________________________________________________________________________
 252 Bool_t AliRsnCutTrackQuality::CheckESD(AliESDtrack *track)
 253 {
 254 //
 255 // Check an ESD track.
 256 // This is done using the default track checker for ESD.
 257 // It is declared static, not to recreate it every time.
 258 //
 259   //static AliESDtrackCuts cuts;
 260   AliESDtrackCuts cuts;
 261
 262    // general acceptance/pt cuts
 263    cuts.SetPtRange(fPt[0], fPt[1]);
 264    cuts.SetEtaRange(fEta[0], fEta[1]);
 265
 266    // transverse DCA cuts
 267    if (fDCARmaxfixed)
 268       cuts.SetMaxDCAToVertexXY(fDCARmax);
 269    else
 270       cuts.SetMaxDCAToVertexXYPtDep(fDCARptFormula.Data());
 271
 272    if (fDCARminfixed)
 273       cuts.SetMinDCAToVertexXY(fDCARmin);
 274    else
 275       cuts.SetMinDCAToVertexXYPtDep(fDCARptFormulaMin.Data());
 276
 277    // longitudinal DCA cuts
 278    if (fDCAZfixed)
 279       cuts.SetMaxDCAToVertexZ(fDCAZmax);
 280    else
 281       cuts.SetMaxDCAToVertexZPtDep(fDCAZptFormula.Data());
 282
 283    // these options are always disabled in current version
 284    cuts.SetDCAToVertex2D(kFALSE);
 285    cuts.SetRequireSigmaToVertex(kFALSE);
 286
 287    // TPC related cuts for TPC+ITS tracks
 288    if (fIsUseCrossedRowsCut) {
 289      cuts.SetMinNCrossedRowsTPC(fTPCminNCrossedRows);
 290      cuts.SetMinRatioCrossedRowsOverFindableClustersTPC(fTPCminCrossedRowsOverFindableCls);
 291    } else {
 292      cuts.SetMinNClustersTPC(fTPCminNClusters);
 293    }
 294    cuts.SetMaxChi2PerClusterTPC(fTPCmaxChi2);
 295    cuts.SetAcceptKinkDaughters(!fRejectKinkDaughters);
 296    cuts.SetMaxChi2TPCConstrainedGlobal(fCutMaxChi2TPCConstrainedVsGlobal);
 297
 298    if (fIsUseLengthActiveVolumeTPCCut)
 299      cuts.SetMinLengthActiveVolumeTPC(fCutMinLengthActiveVolumeTPC);
 300
 301    // ITS related cuts for TPC+ITS tracks
 302    if (fSPDminNClusters > 0)
 303       cuts.SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
 304    cuts.SetMaxChi2PerClusterITS(fITSmaxChi2);
 305
 306    // now that all is initialized, do the check
 307    return cuts.IsSelected(track);
 308 }
 309
 310 //_________________________________________________________________________________________________
 311 Bool_t AliRsnCutTrackQuality::CheckAOD(AliAODTrack *track)
 312 {
 313 //
 314 // Check an AOD track.
 315 // This is done doing directly all checks, since there is not
 316 // an equivalend checker for AOD tracks
 317 //
 318
 319    // if a test bit is used, check it and skip the following
 320    if (fAODTestFilterBit >= 0) {
 321       UInt_t bit = 1 << fAODTestFilterBit;
 322       AliDebugClass(2, Form("Required a test filter bit for AOD check: %u (result: %s)", bit, (track->TestFilterBit(bit) ? "accept" : "reject")));
 323       if (!track->TestFilterBit(bit))
 324          return kFALSE;
 325       else {
 326          if (track->Pt() < fPt[0] || track->Pt() > fPt[1]) return kFALSE;
 327          if (track->Eta() < fEta[0] || track->Eta() > fEta[1]) return kFALSE;
 328          if (fCheckOnlyFilterBit) return kTRUE;
 329       }
 330    }
 331
 332    // try to retrieve the reference AOD event
 333    AliAODEvent *aodEvent = 0x0;
 334    if (fEvent) aodEvent = fEvent->GetRefAOD();
 335    if (!aodEvent) {
 336       AliError("AOD reference event is not initialized!");
 337       return kFALSE;
 338    }
 339
 340    // step #0: check SPD and ITS clusters
 341    Int_t nSPD = 0;
 342    nSPD  = TESTBIT(track->GetITSClusterMap(), 0);
 343    nSPD += TESTBIT(track->GetITSClusterMap(), 1);
 344    if (nSPD < fSPDminNClusters) {
 345       AliDebug(AliLog::kDebug + 2, "Not enough SPD clusters in this track. Rejected");
 346       return kFALSE;
 347    }
 348
 349
 350    //step #1: check number of clusters
 351    if ((!fIsUseCrossedRowsCut) && (track->GetTPCNcls() < fTPCminNClusters)) {
 352       AliDebug(AliLog::kDebug + 2, "Too few TPC clusters. Rejected");
 353       return kFALSE;
 354    }
 355
 356    if (track->GetITSNcls() < fITSminNClusters) {
 357       AliDebug(AliLog::kDebug + 2, "Too few ITS clusters. Rejected");
 358       return kFALSE;
 359    }
 360
 361    //check chi square
 362    if (track->Chi2perNDF() > fTPCmaxChi2) {
 363       AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
 364       return kFALSE;
 365    }
 366    if (track->Chi2perNDF() > fITSmaxChi2) {
 367       AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
 368       return kFALSE;
 369    }
 370
 371    //step #2a: check number of crossed rows in TPC
 372    if (fIsUseCrossedRowsCut) {
 373      Float_t nCrossedRowsTPC = track->GetTPCNCrossedRows();
 374      if (nCrossedRowsTPC < fTPCminNCrossedRows) {
 375        AliDebug(AliLog::kDebug + 2, "Too few TPC crossed rows. Rejected");
 376        return kFALSE;
 377      }
 378      if (track->GetTPCNclsF()>0) {
 379        Float_t ratioCrossedRowsOverFindableClustersTPC = nCrossedRowsTPC / track->GetTPCNclsF();
 380        if (ratioCrossedRowsOverFindableClustersTPC < fTPCminCrossedRowsOverFindableCls){
 381          AliDebug(AliLog::kDebug + 2, "Too few TPC crossed rows/findable clusters. Rejected");
 382          return kFALSE;
 383        }
 384      } else {
 385        AliDebug(AliLog::kDebug + 2, "Negative value for TPC crossed rows/findable clusters. Rejected");
 386        return kFALSE;
 387      }
 388    }
 389    //step #2b: check on track length in active volume of TPC implemented only for ESD tracks
 390    //if (fIsUseLengthActiveVolumeTPCCut) { // not yet implemented in AODs}
 391
 392    //step #3: reject kink daughters
 393    AliAODVertex *vertex = track->GetProdVertex();
 394    if (vertex && fRejectKinkDaughters) {
 395       if (vertex->GetType() == AliAODVertex::kKink) {
 396          AliDebug(AliLog::kDebug + 2, "Kink daughter. Rejected");
 397          return kFALSE;
 398       }
 399    }
 400
 401    // step #4: DCA cut (transverse)
 402    // --> reject all tracks not ITS refitted
 403    Double_t b[2], cov[3];
 404    vertex = aodEvent->GetPrimaryVertex();
 405    if (!vertex) {
 406       AliDebug(AliLog::kDebug + 2, "NULL vertex");
 407       return kFALSE;
 408    }
 409    if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) {
 410       AliDebug(AliLog::kDebug + 2, "Not ITS refitted");
 411       return kFALSE;
 412    }
 413    if (!track->PropagateToDCA(vertex, aodEvent->GetMagneticField(), kVeryBig, b, cov)) {
 414       AliDebug(AliLog::kDebug + 2, "Failed propagation to vertex");
 415       return kFALSE;
 416    }
 417    // if the DCA cut is not fixed, compute current value
 418    if (!fDCARmaxfixed) {
 419       TString str(fDCARptFormula);
 420       str.ReplaceAll("pt", "x");
 421       TFormula dcaXY(Form("%s_dcaXY", GetName()), str.Data());
 422       fDCARmax = dcaXY.Eval(track->Pt());
 423    }
 424    if (!fDCARminfixed) {
 425       TString str2(fDCARptFormulaMin);
 426       str2.ReplaceAll("pt", "x");
 427       TFormula dcaXY_2(Form("%s_dcaXY_2", GetName()), str2.Data());
 428       fDCARmin = dcaXY_2.Eval(track->Pt());
 429    }
 430    // check the cut
 431    if (TMath::Abs(b[0]) > fDCARmax) {
 432       AliDebug(AliLog::kDebug + 2, "Too large transverse DCA");
 433       return kFALSE;
 434    }
 435
 436    if (TMath::Abs(b[0]) < fDCARmin) {
 437       AliDebug(AliLog::kDebug + 2, "Too short transverse DCA");
 438       return kFALSE;
 439    }
 440
 441    // step #5: DCA cut (longitudinal)
 442    // the DCA has already been computed above
 443    // if the DCA cut is not fixed, compute current value
 444    if (!fDCAZfixed) {
 445       TString str(fDCAZptFormula);
 446       str.ReplaceAll("pt", "x");
 447       TFormula dcaZ(Form("%s_dcaXY", GetName()), str.Data());
 448       fDCAZmax = dcaZ.Eval(track->Pt());
 449    }
 450    // check the cut
 451    if (TMath::Abs(b[1]) > fDCAZmax) {
 452       AliDebug(AliLog::kDebug + 2, "Too large longitudinal DCA");
 453       return kFALSE;
 454    }
 455
 456    // step #6: check eta/pt range
 457    if (track->Eta() < fEta[0] || track->Eta() > fEta[1]) {
 458       AliDebug(AliLog::kDebug + 2, "Outside ETA acceptance");
 459       return kFALSE;
 460    }
 461    if (track->Pt() < fPt[0] || track->Pt() > fPt[1]) {
 462       AliDebug(AliLog::kDebug + 2, "Outside PT acceptance");
 463       return kFALSE;
 464    }
 465
 466    // if we are here, all cuts were passed and no exit point was got
 467    AliDebug(AliLog::kDebug + 2, "============================= ACCEPTED TRACK =====================================================");
 468    return kTRUE;
 469 }
 470
 471 //_________________________________________________________________________________________________
 472 void AliRsnCutTrackQuality::Print(const Option_t *) const
 473 {
 474 //
 475 // Print information on this cut
 476 //
 477
 478    AliInfo(Form("Cut name                : %s", GetName()));
 479    AliInfo(Form("Required flags (off, on): %lx %lx", fFlagsOn, fFlagsOff));
 480    AliInfo(Form("Ranges in eta, pt       : %.2f - %.2f, %.2f - %.2f", fEta[0], fEta[1], fPt[0], fPt[1]));
 481    AliInfo(Form("Kink daughters are      : %s", (fRejectKinkDaughters ? "rejected" : "accepted")));
 482    AliInfo(Form("TPC requirements (clusters)       : min. cluster = %i, max chi2 = %f", fTPCminNClusters, fTPCmaxChi2));
 483    AliInfo(Form("TPC requirements (crossed rows)   : min. crossed rows = %f, min. crossed rows/findable clusters = %f", fTPCminNCrossedRows, fTPCminCrossedRowsOverFindableCls));
 484    AliInfo(Form("TPC requirements (track length)   : min. track length in active volume TPC = %f", fCutMinLengthActiveVolumeTPC));
 485
 486    AliInfo(Form("ITS requirements        : min. cluster = %d (all), %d (SPD), max chi2 = %f", fITSminNClusters, fSPDminNClusters, fITSmaxChi2));
 487
 488    if (fDCARmaxfixed) {
 489       AliInfo(Form("Max DCA r cut               : fixed to %f cm", fDCARmax));
 490    } else {
 491       AliInfo(Form("Max DCA r cut formula       : %s", fDCARptFormula.Data()));
 492    }
 493
 494    if (fDCARminfixed) {
 495       AliInfo(Form("Min DCA r cut               : fixed to %f cm", fDCARmin));
 496    } else {
 497       AliInfo(Form("Min DCA r cut formula       : %s", fDCARptFormulaMin.Data()));
 498    }
 499
 500    if (fDCAZfixed) {
 501       AliInfo(Form("DCA z cut               : fixed to %f cm", fDCAZmax));
 502    } else {
 503       AliInfo(Form("DCA z cut formula       : %s", fDCAZptFormula.Data()));
 504    }
 505
 506    AliInfo(Form("fAODTestFilterBit       : filter bit %i",fAODTestFilterBit));
 507    AliInfo(Form("fCheckOnlyFilterBit     : %i",((int) fCheckOnlyFilterBit)));
 508 }
 509 //__________________________________________________________________________________________________
 510 void AliRsnCutTrackQuality::SetDefaults2010()
 511 {
 512 //
 513 // Default settings for cuts used in 2010
 514 //
 515    AddStatusFlag(AliESDtrack::kTPCin   , kTRUE);
 516    AddStatusFlag(AliESDtrack::kTPCrefit, kTRUE);
 517    AddStatusFlag(AliESDtrack::kITSrefit, kTRUE);
 518    SetPtRange(0.15, 1E+20);
 519    SetEtaRange(-0.8, 0.8);
 520    SetDCARPtFormula("0.0182+0.0350/pt^1.01");
 521    SetDCAZmax(2.0);
 522    SetSPDminNClusters(1);
 523    SetITSminNClusters(0);
 524    // SetITSmaxChi2(36);
 525    // SetMaxChi2TPCConstrainedGlobal(36);
 526    SetTPCminNClusters(70);
 527    SetTPCmaxChi2(4.0);
 528    SetRejectKinkDaughters();
 529    SetAODTestFilterBit(5);
 530 }
 531
 532 //__________________________________________________________________________________________________
 533 void AliRsnCutTrackQuality::SetDefaultsHighPt2011(Bool_t useTPCCrossedRows)
 534 {
 535 //
 536 // Default settings for cuts used in 2011 (for high-pT)
 537 //
 538    fIsUseCrossedRowsCut=useTPCCrossedRows;
 539    fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE, useTPCCrossedRows);
 540    fESDtrackCuts->SetMinNCrossedRowsTPC(120); //default is min 70 crossed rows -> use 120 to go to higher pt
 541    fESDtrackCuts->SetMaxFractionSharedTPCClusters(0.4);//default is not set --> use to go to higher pt
 542    //fESDtrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);//already in 2011 std
 543    //fESDtrackCuts->SetMaxChi2PerClusterITS(36);//already in 2011 std
 544    //fESDtrackCuts->SetMaxChi2TPCConstrainedGlobal(36);//already in 2011 std
 545    // AddStatusFlag(AliESDtrack::kTPCin   , kTRUE); //already in 2011 std
 546    // AddStatusFlag(AliESDtrack::kTPCrefit, kTRUE);//already in 2011 std
 547    // AddStatusFlag(AliESDtrack::kITSrefit, kTRUE);//already in 2011 std
 548    SetPtRange(0.15, 1E+20);
 549    SetEtaRange(-0.8, 0.8);
 550    SetAODTestFilterBit(10);
 551    return;
 552 }
 553
 554 //__________________________________________________________________________________________________
 555 void AliRsnCutTrackQuality::SetDefaults2011(Bool_t useTPCCrossedRows)
 556 {
 557 //
 558 // Default std cuts 2011 with crossed rows (=70)
 559 //
 560   fIsUseCrossedRowsCut=useTPCCrossedRows;
 561   fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE,useTPCCrossedRows);
 562   SetPtRange(0.15, 1E+20);
 563   SetEtaRange(-0.8, 0.8);
 564   SetAODTestFilterBit(5);
 565   return;
 566 }
 567 //__________________________________________________________________________________________________
 568 const char *AliRsnCutTrackQuality::Binary(UInt_t number)
 569 {
 570 //
 571 // Convert an integer in binary
 572 //
 573
 574    static char b[50];
 575    b[0] = '\0';
 576
 577    UInt_t z;
 578    for (z = 512; z > 0; z >>= 1)
 579       strncat(b, ((number & z) == z) ? "1" : "0", 1);
 580
 581    return b;
 582 }