PWG2/RESONANCES/AliRsnCutStd.cxx

   1 //
   2 // Class AliRsnCutStd
   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 "TParticle.h"
  20 #include "TMath.h"
  21
  22 #include "AliRsnDaughter.h"
  23 #include "AliRsnEvent.h"
  24 #include "AliRsnPairParticle.h"
  25
  26 #include "AliRsnCutStd.h"
  27
  28 ClassImp(AliRsnCutStd)
  29
  30 //_________________________________________________________________________________________________
  31 AliRsnCutStd::AliRsnCutStd() :
  32     AliRsnCut(),
  33     fType(kLastType),
  34     fUseMC(kFALSE),
  35     fMass(0.0)
  36 {
  37 //
  38 // Default constructor.
  39 //
  40 }
  41
  42 //_________________________________________________________________________________________________
  43 AliRsnCutStd::AliRsnCutStd
  44 (const char *name, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
  45     AliRsnCut(name, val1, val2),
  46     fType(type),
  47     fUseMC(useMC),
  48     fMass(0.0)
  49 {
  50 //
  51 // Main constructor.
  52 // Checks also that cut values are given in the correct type,
  53 // in order to avoid that one passes, for example, a value which should be double
  54 // but is interpreted as integer due to the overloading of constructors
  55 //
  56
  57   switch (fType) {
  58     // int
  59   case kMult:
  60   case kMultDiff:
  61   case kKink:
  62   case kKinkMother:
  63   case kAssignedPID:
  64   case kTruePID:
  65   case kRequiredPID:
  66   case kCharge:
  67     break;
  68     // ulong
  69   case kStatus:
  70     if (fVarType != kULong) {
  71       AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
  72       SetRange((ULong_t)val1, (ULong_t)val2);
  73       AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %lu, %lu", GetName(), fMinU, fMaxU));
  74     }
  75     break;
  76     // double
  77   case kP:
  78   case kPt:
  79   case kEta:
  80   case kY:
  81   case kThetaDeg:
  82   case kDr:
  83   case kDz:
  84   case kTPCsignal:
  85   case kMultDiffRel:
  86   case kVzDiff:
  87     if (fVarType != kDouble) {
  88       AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
  89       SetRange((Double_t)val1, (Double_t)val2);
  90       AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
  91     }
  92     break;
  93     // other cuts are not based on a value, so no problem
  94   default:
  95     break;
  96   }
  97 }
  98
  99 //_________________________________________________________________________________________________
 100 AliRsnCutStd::AliRsnCutStd
 101 (const char *name, EType type, ULong_t val1, ULong_t val2, Bool_t useMC) :
 102     AliRsnCut(name, val1, val2),
 103     fType(type),
 104     fUseMC(useMC),
 105     fMass(0.0)
 106 {
 107 //
 108 // Main constructor.
 109 // Checks also that cut values are given in the correct type,
 110 // in order to avoid that one passes, for example, a value which should be double
 111 // but is interpreted as integer due to the overloading of constructors
 112 //
 113
 114   switch (fType) {
 115     // int
 116   case kMult:
 117   case kMultDiff:
 118   case kKink:
 119   case kKinkMother:
 120   case kAssignedPID:
 121   case kTruePID:
 122   case kRequiredPID:
 123   case kCharge:
 124     if (fVarType != kInt) {
 125       AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
 126       SetRange((Int_t)val1, (Int_t)val2);
 127       AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
 128     }
 129     break;
 130     // ulong
 131   case kStatus:
 132     break;
 133     // double
 134   case kP:
 135   case kPt:
 136   case kEta:
 137   case kY:
 138   case kThetaDeg:
 139   case kDr:
 140   case kDz:
 141   case kTPCsignal:
 142   case kMultDiffRel:
 143   case kVzDiff:
 144     if (fVarType != kDouble) {
 145       AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
 146       SetRange((Double_t)val1, (Double_t)val2);
 147       AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
 148     }
 149     break;
 150     // other cuts are not based on a value, so no problem
 151   default:
 152     break;
 153   }
 154 }
 155
 156 //_________________________________________________________________________________________________
 157 AliRsnCutStd::AliRsnCutStd
 158 (const char *name, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
 159     AliRsnCut(name, val1, val2),
 160     fType(type),
 161     fUseMC(useMC),
 162     fMass(0.0)
 163 {
 164 //
 165 // Main constructor.
 166 // Checks also that cut values are given in the correct type,
 167 // in order to avoid that one passes, for example, a value which should be double
 168 // but is interpreted as integer due to the overloading of constructors
 169 //
 170
 171   switch (fType) {
 172     // int
 173   case kMult:
 174   case kMultDiff:
 175   case kKink:
 176   case kKinkMother:
 177   case kAssignedPID:
 178   case kTruePID:
 179   case kRequiredPID:
 180   case kCharge:
 181     if (fVarType != kInt) {
 182       AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
 183       SetRange((Int_t)val1, (Int_t)val2);
 184       AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
 185     }
 186     break;
 187     // ulong
 188   case kStatus:
 189     if (fVarType != kULong) {
 190       AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
 191       SetRange((ULong_t)val1, (ULong_t)val2);
 192       AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %lu, %lu", GetName(), fMinU, fMaxU));
 193     }
 194     break;
 195     // double
 196   case kP:
 197   case kPt:
 198   case kEta:
 199   case kY:
 200   case kThetaDeg:
 201   case kDr:
 202   case kDz:
 203   case kTPCsignal:
 204   case kMultDiffRel:
 205   case kVzDiff:
 206     break;
 207     // other cuts are not based on a value, so no problem
 208   default:
 209     break;
 210   }
 211 }
 212
 213 //_________________________________________________________________________________________________
 214 Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter * const track)
 215 {
 216 //
 217 // Cut checker.
 218 //
 219
 220   // coherence check
 221   if (tgt != AliRsnCut::kParticle) {
 222     AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
 223     return kTRUE;
 224   }
 225
 226
 227   // if MC info is required, try to retrieve the TParticle:
 228   // if it is not present, the cut is skipped
 229   // this avoids to raise a seg-fault when accessing the NULL TParticle object
 230   TParticle *part = 0x0;
 231   if (fUseMC) {
 232     part = track->GetParticle();
 233     if (!part) {
 234       AliError("Required MC info but it is not present. Cut Skipped.");
 235       return kTRUE;
 236     }
 237   }
 238
 239   // loop on allowed possibilities
 240   switch (fType) {
 241   case kP:
 242     fCutValueD = fUseMC ? part->P() : track->P();
 243     return OkRange();
 244   case kPt:
 245     fCutValueD = fUseMC ? part->Pt() : track->Pt();
 246     return OkRange();
 247   case kThetaDeg:
 248     fCutValueD = track->ThetaDeg();
 249     return OkRange();
 250   case kEta:
 251     fCutValueD = fUseMC ? part->Eta() : track->Eta();
 252     return OkRange();
 253   case kDr:
 254     fCutValueD = track->Dr();
 255     return OkRange();
 256   case kDz:
 257     fCutValueD = track->Dz();
 258     return OkRange();
 259   case kStatus:
 260     fCutValueU = track->GetStatus();
 261     return OkValue();
 262   case kKink:
 263     fCutValueI = track->IsKink();
 264     return OkValue();
 265   case kKinkMother:
 266     fCutValueI = track->IsKinkMother();
 267     return OkValue();
 268   case kCharge:
 269     fCutValueI = (Int_t)track->Charge();
 270     return OkValue();
 271   case kTruePID:
 272     fCutValueI = (Int_t)track->PerfectPID();
 273     return OkValue();
 274   case kAssignedPID:
 275     fCutValueI = (Int_t)track->AssignedPID();
 276     return OkValue();
 277   case kRequiredPID:
 278     fCutValueI = (Int_t)track->RequiredPID();
 279     return OkValue();
 280   case kRealisticPID:
 281     fCutValueI = (Int_t)track->RealisticPID();
 282     return OkValue();
 283   case kPairIndex:
 284     fCutValueI = track->PairIndex();
 285     return OkValue();
 286   case kTruePIDMatch:
 287     return (track->PerfectPID() == track->RequiredPID());
 288   case kRealisticPIDMatch:
 289     return (track->RealisticPID() == track->RequiredPID());
 290   default:
 291     AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
 292     return kTRUE;
 293   }
 294 }
 295
 296 //_________________________________________________________________________________________________
 297 Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle * const pair)
 298 {
 299 //
 300 // Cut checker
 301 //
 302
 303   // coherence check
 304   if (tgt != AliRsnCut::kPair) {
 305     AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
 306     return kTRUE;
 307   }
 308
 309   // loop on allowed possibilities
 310   switch (fType) {
 311   case kP:
 312     fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
 313     return OkRange();
 314   case kPt:
 315     fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
 316     return OkRange();
 317   case kEta:
 318     fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
 319     return OkRange();
 320   case kY:
 321     fCutValueD = (fUseMC ? pair->GetYMC(fMass) : pair->GetY(fMass));
 322     return OkRange();
 323   case kSameLabel:
 324     return pair->IsLabelEqual();
 325   case kTruePair:
 326     fCutValueI = TMath::Abs(pair->CommonMother());
 327     return OkValue();
 328   default:
 329     AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
 330     return kTRUE;
 331   }
 332 }
 333
 334 //_________________________________________________________________________________________________
 335 Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const event)
 336 {
 337 //
 338 // Cut checker
 339 //
 340
 341   // coherence check
 342   if (tgt != AliRsnCut::kEvent) {
 343     AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
 344     return kTRUE;
 345   }
 346
 347   // loop on allowed possibilities
 348   switch (fType) {
 349   case kMult:
 350     fCutValueI = event->GetMultiplicity();
 351     return OkRange();
 352   default:
 353     AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
 354     return kTRUE;
 355   }
 356 }
 357
 358 //_________________________________________________________________________________________________
 359 Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const ev1, AliRsnEvent * const ev2)
 360 {
 361 //
 362 // Cut checker
 363 //
 364
 365   // coherence check
 366   if (tgt != AliRsnCut::kMixEvent) {
 367     AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
 368     return kTRUE;
 369   }
 370
 371   // loop on allowed possibilities
 372   Double_t mult1, mult2;
 373   switch (fType) {
 374   case kMultDiff:
 375     fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
 376     return OkRange();
 377   case kMultDiffRel:
 378     mult1 = (Double_t)ev1->GetMultiplicity();
 379     mult2 = (Double_t)ev2->GetMultiplicity();
 380     if (mult1 == 0.0  && mult2 == 0.0) return kTRUE;
 381     fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
 382     return OkRange();
 383   case kVzDiff:
 384     fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
 385     return OkRange();
 386   default:
 387     AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
 388     return kTRUE;
 389   }
 390 }