PWGLF/RESONANCES/AliRsnCut.cxx

   1 //
   2 // *** Class AliRsnCut ***
   3 //
   4 // Cut base class: all other cuts inherit from it.
   5 // The 'core' of the class is the method "IsSelected()" which
   6 // must be overloaded by any specific cut implementation.
   7 //
   8 // This class provides some default instruments to check values
   9 // agains a reference or an allowed range, in order to permit
  10 // a unique way to execute such kind of checks.
  11 //
  12 // authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
  13 //          Martin Vala (martin.vala@cern.ch)
  14 //
  15
  16 #include <TFormula.h>
  17 #include "AliRsnCut.h"
  18
  19 ClassImp(AliRsnCut)
  20
  21 //______________________________________________________________________________
  22 AliRsnCut::AliRsnCut(const char *name, RSNTARGET target) :
  23    AliRsnTarget(name, target),
  24    fMinI(0),
  25    fMaxI(0),
  26    fMinD(0.),
  27    fMaxD(0.),
  28    fCutValueI(0),
  29    fCutValueD(0.0),
  30    fPtDepCut(kFALSE),
  31    fRefPtValueD(0.0),
  32    fMaxPt(1E20),
  33    fMinPt(0.0),
  34    fPtDepCutMaxFormula(""),
  35    fPtDepCutMinFormula(""),
  36    fCutResult(kTRUE)
  37 {
  38 //
  39 // Default constructor.
  40 //
  41 }
  42
  43 //______________________________________________________________________________
  44 AliRsnCut::AliRsnCut
  45 (const char *name, RSNTARGET target, Int_t imin, Int_t imax, Double_t dmin, Double_t dmax) :
  46    AliRsnTarget(name, target),
  47    fMinI(imin),
  48    fMaxI(imax),
  49    fMinD(dmin),
  50    fMaxD(dmax),
  51    fCutValueI(0),
  52    fCutValueD(0.0),
  53    fPtDepCut(kFALSE),
  54    fRefPtValueD(0.0),
  55    fMaxPt(1E20),
  56    fMinPt(0.0),
  57    fPtDepCutMaxFormula(""),
  58    fPtDepCutMinFormula(""),
  59    fCutResult(kTRUE)
  60 {
  61 //
  62 // Constructor with arguments.
  63 // This is provided to allow a quick setting of all data members.
  64 //
  65 }
  66
  67 //______________________________________________________________________________
  68 AliRsnCut::AliRsnCut
  69 (const char *name, RSNTARGET target, Double_t dmin, Double_t dmax, Int_t imin, Int_t imax) :
  70    AliRsnTarget(name, target),
  71    fMinI(imin),
  72    fMaxI(imax),
  73    fMinD(dmin),
  74    fMaxD(dmax),
  75    fCutValueI(0),
  76    fCutValueD(0.0),
  77    fPtDepCut(kFALSE),
  78    fRefPtValueD(0.0),
  79    fMaxPt(1E20),
  80    fMinPt(0.0),
  81    fPtDepCutMaxFormula(""),
  82    fPtDepCutMinFormula(""),
  83    fCutResult(kTRUE)
  84 {
  85 //
  86 // Constructor with arguments.
  87 // This is provided to allow a quick setting of all data members.
  88 //
  89 }
  90
  91 //______________________________________________________________________________
  92 AliRsnCut::AliRsnCut(const AliRsnCut &copy) :
  93    AliRsnTarget(copy),
  94    fMinI(copy.fMinI),
  95    fMaxI(copy.fMaxI),
  96    fMinD(copy.fMinD),
  97    fMaxD(copy.fMaxD),
  98    fCutValueI(copy.fCutValueI),
  99    fCutValueD(copy.fCutValueD),
 100    fPtDepCut(copy.fPtDepCut),
 101    fRefPtValueD(copy.fRefPtValueD),
 102    fMaxPt(copy.fMaxPt),
 103    fMinPt(copy.fMinPt),
 104    fPtDepCutMaxFormula(copy.fPtDepCutMaxFormula),
 105    fPtDepCutMinFormula(copy.fPtDepCutMinFormula),
 106    fCutResult(copy.fCutResult)
 107 {
 108 //
 109 // Copy constructor.
 110 // Don't duplicate memory occupancy for pointer
 111 //
 112 }
 113
 114 //______________________________________________________________________________
 115 AliRsnCut &AliRsnCut::operator=(const AliRsnCut &copy)
 116 {
 117 //
 118 // Assignment operator.
 119 // Don't duplicate memory occupancy for pointer
 120 //
 121
 122    AliRsnTarget::operator=(copy);
 123    if (this == &copy)
 124       return *this;
 125
 126    fMinI      = copy.fMinI;
 127    fMaxI      = copy.fMaxI;
 128    fMinD      = copy.fMinD;
 129    fMaxD      = copy.fMaxD;
 130    fCutValueI = copy.fCutValueI;
 131    fCutValueD = copy.fCutValueD;
 132    fPtDepCut = copy.fPtDepCut;
 133    fRefPtValueD = copy.fRefPtValueD;
 134    fMaxPt = copy.fMaxPt;
 135    fMinPt = copy.fMinPt;
 136    fPtDepCutMaxFormula = copy.fPtDepCutMaxFormula;
 137    fPtDepCutMinFormula = copy.fPtDepCutMinFormula;
 138    fCutResult = copy.fCutResult;
 139
 140    return (*this);
 141 }
 142
 143 //______________________________________________________________________________
 144 Bool_t AliRsnCut::IsSelected(TObject * /*object*/)
 145 {
 146 //
 147 // Virtual cut-checking method.
 148 // In this implementation, it does nothing, and all classes
 149 // inheriting from this, should provide a proper implementation
 150 // which must return kTRUE if the cut is passed, and kFALSE otherwise.
 151 //
 152
 153    AliWarning("This virtual function must be implemented properly");
 154    return kTRUE;
 155 }
 156
 157 //______________________________________________________________________________
 158 Bool_t AliRsnCut::OkValueI()
 159 {
 160 //
 161 // This method is used to compare a value with a reference.
 162 // In the case of integers, the equality must be exact.
 163 //
 164
 165    // eval result
 166
 167    if (fPtDepCut){
 168         if(fRefPtValueD > fMaxPt) {
 169         AliDebug(2,Form("pt = %f (> %f), cutting at %d\n",fRefPtValueD, fMaxPt, fMinI));
 170         fCutResult = (fCutValueI == fMinI);
 171         } else if (fRefPtValueD < fMinPt){
 172         AliDebug(2,Form("pt = %f (< %f), cutting at %d\n",fRefPtValueD, fMinPt, fMinI));
 173         fCutResult = (fCutValueI == fMinI);
 174         }else{
 175         TString str(fPtDepCutMinFormula);
 176         str.ReplaceAll("pt", "x");
 177         TFormula ptdepcut(Form("%s_ptdepcut", GetName()), str.Data());
 178         fMinI = static_cast<int> (ptdepcut.Eval(fRefPtValueD));
 179         AliDebug(2,Form("pt = %f (> %f and < %f), cutting  at %d\n",fRefPtValueD, fMinPt, fMaxPt, fMinI));
 180         fCutResult = (fCutValueI == fMinI);
 181         }
 182   }
 183   else fCutResult = (fCutValueI == fMinI);
 184
 185    // print debug message
 186    AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
 187    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
 188    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
 189    AliDebug(AliLog::kDebug + 2, Form("Cut value    : %d", fMinI));
 190    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
 191    AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
 192
 193    return fCutResult;
 194 }
 195
 196 //______________________________________________________________________________
 197 Bool_t AliRsnCut::OkValueD()
 198 {
 199 //
 200 // This method is used to compare a value with a reference.
 201 // In the case of doubles, the equality consists in being very close.
 202 //
 203
 204    // eval result
 205
 206     if (fPtDepCut){
 207         if(fRefPtValueD > fMaxPt) {
 208         AliDebug(2,Form("pt = %f (> %f), cutting at %f\n",fRefPtValueD, fMaxPt, fMinD));
 209         fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 210         } else if (fRefPtValueD < fMinPt){
 211         AliDebug(2,Form("pt = %f (< %f), cutting at %f\n",fRefPtValueD, fMinPt, fMinD));
 212         fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 213         }else{
 214         TString str(fPtDepCutMinFormula);
 215         str.ReplaceAll("pt", "x");
 216         TFormula ptdepcut(Form("%s_ptdepcut", GetName()), str.Data());
 217         fMinD = ptdepcut.Eval(fRefPtValueD);
 218         AliDebug(2,Form("pt = %f (> %f and < %f), cutting  at %f\n",fRefPtValueD, fMinPt, fMaxPt, fMinD));
 219         fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 220         }
 221   }
 222   else fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 223
 224    // print debug message
 225    AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG =======================================================");
 226    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
 227    AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
 228    AliDebug(AliLog::kDebug + 2, Form("Cut value    : %f", fMinD));
 229    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
 230    AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ===================================================");
 231
 232    return fCutResult;
 233 }
 234
 235 //______________________________________________________________________________
 236 Bool_t AliRsnCut::OkRangeI()
 237 {
 238 //
 239 // This method is used to compare a value with an integer range.
 240 //
 241
 242   // eval result
 243   if (fPtDepCut){
 244     if(fRefPtValueD > fMaxPt) {
 245       AliDebug(2,Form("pt = %f (> %f), cutting between [%d, %d]\n",fRefPtValueD, fMaxPt, fMinI, fMaxI));
 246       fCutResult = ((fCutValueI >= fMinI) && (fCutValueD <= fMaxI));
 247     } else if (fRefPtValueD < fMinPt){
 248       AliDebug(2,Form("pt = %f (< %f), cutting between [%d, %d]\n",fRefPtValueD, fMinPt, fMinI, fMaxI));
 249       fCutResult = ((fCutValueI >= fMinI) && (fCutValueD <= fMaxI));
 250     } else {
 251       TString str(fPtDepCutMinFormula);
 252       str.ReplaceAll("pt", "x");
 253       TFormula ptdepcut(Form("%s_ptdepcut", GetName()), str.Data());
 254       fMinI = static_cast<int> (ptdepcut.Eval(fRefPtValueD));
 255
 256       TString str2(fPtDepCutMaxFormula);
 257       str2.ReplaceAll("pt", "x");
 258       TFormula ptdepcut2(Form("%s_ptdepcut", GetName()), str2.Data());
 259       fMaxI = static_cast<int> (ptdepcut2.Eval(fRefPtValueD));
 260
 261       AliDebug(2,Form("pt = %f (> %f and < %f), cutting  according to the fiducial zone [%d, %d]\n",fRefPtValueD, fMinPt, fMaxPt, fMinI, fMaxI));
 262       fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
 263     }
 264   }
 265   else fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
 266
 267    // print debug message
 268    AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
 269    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
 270    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
 271    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
 272    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
 273    AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
 274
 275    return fCutResult;
 276 }
 277
 278 //______________________________________________________________________________
 279 Bool_t AliRsnCut::OkRangeD()
 280 {
 281 //
 282 // This method is used to compare a value with a double-float range.
 283 //
 284
 285   // eval result
 286
 287   if (fPtDepCut){
 288     if(fRefPtValueD > fMaxPt) {
 289       AliDebug(2,Form("pt = %f (> %f), cutting between [%f, %f]\n",fRefPtValueD, fMaxPt, fMinD, fMaxD));
 290       fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 291     } else if (fRefPtValueD < fMinPt) {
 292       AliDebug(2,Form("pt = %f (< %f), cutting between [%f, %f]\n",fRefPtValueD, fMinPt, fMinD, fMaxD));
 293       fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 294     } else {
 295       TString str(fPtDepCutMinFormula);
 296       str.ReplaceAll("pt", "x");
 297       TFormula ptdepcut(Form("%s_ptdepcut", GetName()), str.Data());
 298       fMinD = ptdepcut.Eval(fRefPtValueD);
 299
 300       TString str2(fPtDepCutMaxFormula);
 301       str2.ReplaceAll("pt", "x");
 302       TFormula ptdepcut2(Form("%s_ptdepcut", GetName()), str2.Data());
 303       fMaxD = ptdepcut2.Eval(fRefPtValueD);
 304
 305       AliDebug(2,Form("pt = %f (> %f and < %f), cutting  according to the fiducial zone [%f, %f]\n",fRefPtValueD, fMinPt, fMaxPt, fMinD, fMaxD));
 306       fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 307     }
 308   }
 309   else fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 310
 311    // print debug message
 312    AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
 313    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
 314    AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
 315    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
 316    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
 317    AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
 318
 319    return fCutResult;
 320 }
 321
 322
 323 //______________________________________________________________________________
 324 void AliRsnCut::Print(Option_t *) const
 325 {
 326 //
 327 // Override TObject::Print() method,
 328 // and print some useful info about the cut general parameters.
 329 //
 330
 331    AliInfo("=== CUT DETAILS ====================================");
 332    AliInfo(Form("Cut name     : [%s]", GetName()));
 333    AliInfo(Form("Cut target   : [%s]", GetTargetTypeName()));
 334    AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
 335    AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
 336    AliInfo(Form("Cut pt dependent: %s", (fPtDepCut ? "YES" : "NO")));
 337    AliInfo("====================================================");
 338 }