Coverity fix
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCut.cxx
index f1d2a38..222f47a 100644 (file)
 //
-// Class AliRsnCut
+// *** Class AliRsnCut ***
 //
-// General implementation of a single cut strategy, which can be:
-// - a value contained in a given interval  [--> IsBetween()   ]
-// - a value equal to a given reference     [--> MatchesValue()]
+// Cut base class: all other cuts inherit from it.
+// The 'core' of the class is the method "IsSelected()" which
+// must be overloaded by any specific cut implementation.
 //
-// In all cases, the reference value(s) is (are) given as data members
-// and each kind of cut requires a given value type (Int, UInt, Double),
-// but the cut check procedure is then automatized and chosen thanks to
-// an enumeration of the implemented cut types.
-// At the end, the user (or any other point which uses this object) has
-// to use the method IsSelected() to check if this cut has been passed.
+// This class provides some default instruments to check values
+// agains a reference or an allowed range, in order to permit
+// a unique way to execute such kind of checks.
 //
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+// authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//          Martin Vala (martin.vala@cern.ch)
 //
-#include "AliLog.h"
 
 #include "AliRsnCut.h"
 
 ClassImp(AliRsnCut)
 
-//_________________________________________________________________________________________________
-AliRsnCut::AliRsnCut() :
-    TNamed(),
-    fVarType(kInt),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE)
+//______________________________________________________________________________
+AliRsnCut::AliRsnCut(const char *name, RSNTARGET target) :
+   AliRsnTarget(name, target),
+   fMinI(0),
+   fMaxI(0),
+   fMinD(0.),
+   fMaxD(0.),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
 // Default constructor.
 //
 }
 
-//_________________________________________________________________________________________________
+//______________________________________________________________________________
 AliRsnCut::AliRsnCut
-(const char *name, Int_t min, Int_t max) :
-    TNamed(name, ""),
-    fVarType(kInt),
-    fMinI(min),
-    fMaxI(max),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE)
+(const char *name, RSNTARGET target, Int_t imin, Int_t imax, Double_t dmin, Double_t dmax) :
+   AliRsnTarget(name, target),
+   fMinI(imin),
+   fMaxI(imax),
+   fMinD(dmin),
+   fMaxD(dmax),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
-// Constructor.
-// If the cut must check values inside a range,
-// both 'value' arguments must be used, and they are, in the order,
-// the minimum and maximum of the allowed range.
-// If the cut must check a value, the second 'value' argument will never be used.
+// Constructor with arguments.
+// This is provided to allow a quick setting of all data members.
 //
 }
 
-//_________________________________________________________________________________________________
+//______________________________________________________________________________
 AliRsnCut::AliRsnCut
-(const char *name, ULong_t min, ULong_t max) :
-    TNamed(name, ""),
-    fVarType(kULong),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(min),
-    fMaxU(max),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE)
+(const char *name, RSNTARGET target, Double_t dmin, Double_t dmax, Int_t imin, Int_t imax) :
+   AliRsnTarget(name, target),
+   fMinI(imin),
+   fMaxI(imax),
+   fMinD(dmin),
+   fMaxD(dmax),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
-// Constructor.
-// If the cut must check values inside a range,
-// both 'value' arguments must be used, and they are, in the order,
-// the minimum and maximum of the allowed range.
-// If the cut must check a value, the second 'value' argument will never be used.
+// Constructor with arguments.
+// This is provided to allow a quick setting of all data members.
 //
 }
 
-//_________________________________________________________________________________________________
-AliRsnCut::AliRsnCut
-(const char *name, Double_t min, Double_t max) :
-    TNamed(name, ""),
-    fVarType(kDouble),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(min),
-    fMaxD(max),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE)
+//______________________________________________________________________________
+AliRsnCut::AliRsnCut(const AliRsnCut& copy) :
+   AliRsnTarget(copy),
+   fMinI(copy.fMinI),
+   fMaxI(copy.fMaxI),
+   fMinD(copy.fMinD),
+   fMaxD(copy.fMaxD),
+   fCutValueI(copy.fCutValueI),
+   fCutValueD(copy.fCutValueD),
+   fCutResult(copy.fCutResult)
 {
 //
-// Constructor.
-// If the cut must check values inside a range,
-// both 'value' arguments must be used, and they are, in the order,
-// the minimum and maximum of the allowed range.
-// If the cut must check a value, the second 'value' argument will never be used.
+// Copy constructor.
+// Don't duplicate memory occupancy for pointer
 //
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnDaughter* /*track*/)
+//______________________________________________________________________________
+AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// Assignment operator.
+// Don't duplicate memory occupancy for pointer
 //
 
-  AliWarning("This cut does not provide checks on AliRsnDaughter. This function will return kTRUE");
-  return kTRUE;
+   AliRsnTarget::operator=(copy);
+
+   fMinI      = copy.fMinI;
+   fMaxI      = copy.fMaxI;
+   fMinD      = copy.fMinD;
+   fMaxD      = copy.fMaxD;
+   fCutValueI = copy.fCutValueI;
+   fCutValueD = copy.fCutValueD;
+   fCutResult = copy.fCutResult;
+
+   return (*this);
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
+//______________________________________________________________________________
+Bool_t AliRsnCut::IsSelected(TObject* /*object*/)
 {
 //
 // Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// In this implementation, it does nothing, and all classes
+// inheriting from this, should provide a proper implementation
+// which must return kTRUE if the cut is passed, and kFALSE otherwise.
 //
 
-  AliWarning("This cut does not provide checks on AliRsnPairParticle. This function will return kTRUE");
-  return kTRUE;
+   AliWarning("This virtual function must be implemented properly");
+   return kTRUE;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*event*/)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueI()
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// This method is used to compare a value with a reference.
+// In the case of integers, the equality must be exact.
 //
 
-  AliWarning("This cut does not provide checks on AliRsnEvent. This function will return kTRUE");
-  return kTRUE;
+   // eval result
+   fCutResult = (fCutValueI == fMinI);
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
+   AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+   AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
+   AliDebug(AliLog::kDebug + 2, Form("Cut value    : %d", fMinI));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
+
+   return fCutResult;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueD()
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// This method is used to compare a value with a reference.
+// In the case of doubles, the equality consists in being very close.
 //
 
-  AliWarning("This cut does not provide checks on two AliRsnEvent's. This function will return kTRUE");
-  return kTRUE;
+   // eval result
+   fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG =======================================================");
+   AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+   AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
+   AliDebug(AliLog::kDebug + 2, Form("Cut value    : %f", fMinD));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ===================================================");
+
+   return fCutResult;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkValue()
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkRangeI()
 {
 //
-// This method is used when the cut consists in comparing the cut value
-// with a reference value to which it must be equal (in case of doubles, 'almost' equal).
-// Then, the cut result is kTRUE if the cut value is equal to this reference value.
+// This method is used to compare a value with an integer range.
 //
 
-  switch (fVarType) {
-  case kInt:
-    // eval result
-    fCutResult = (fCutValueI == fMinI);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueI));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinI));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kULong:
-    // eval result
-    fCutResult = (fCutValueU == fMinU);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueU));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinU));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kDouble:
-    // eval result
-    fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %f", fCutValueD));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %f", fMinD));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  default:
-    AliError(Form("fVarType = %d --> not allowed", fVarType));
-    return kFALSE;
-  }
+   // eval result
+   fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
+   AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+   AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
+   AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
 
-  return fCutResult;
+   return fCutResult;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkRange()
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkRangeD()
 {
 //
-// This method is used when the cut consists in an allowed range
-// where the cut value must be included to pass the cut.
-// Then, the cut result is kTRUE if the cut value is inside this range.
+// This method is used to compare a value with a double-float range.
 //
 
-  switch (fVarType) {
-  case kInt:
-    // eval result
-    fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kULong:
-    // eval result
-    fCutResult = ((fCutValueU >= fMinU) && (fCutValueU <= fMaxU));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueU));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinU, fMaxU));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kDouble:
-    // eval result
-    fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  default:
-    AliError(Form("fVarType = %d --> not allowed", fVarType));
-    return kFALSE;
-  }
+   // eval result
+   fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 
-  return fCutResult;
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== CUT DEBUG ========================================================");
+   AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+   AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
+   AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ====================================================");
+
+   return fCutResult;
 }
 
+//______________________________________________________________________________
+void AliRsnCut::Print(Option_t*) const
+{
+//
+// Override TObject::Print() method,
+// and print some useful info about the cut general parameters.
+//
+
+   AliInfo("=== CUT DETAILS ====================================");
+   AliInfo(Form("Cut name     : [%s]", GetName()));
+   AliInfo(Form("Cut target   : [%s]", GetTargetTypeName()));
+   AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
+   AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
+   AliInfo("====================================================");
+}