Coverity fix
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCut.cxx
index 631b7bf..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 "AliRsnDaughter.h"
-#include "AliRsnMother.h"
-#include "AliRsnEvent.h"
 
 #include "AliRsnCut.h"
 
 ClassImp(AliRsnCut)
 
-//_________________________________________________________________________________________________
-AliRsnCut::AliRsnCut(ETarget target) :
-  TNamed(),
-  fVarType(kInt),
-  fTarget(target),
-  fMinI(0),
-  fMaxI(0),
-  fMinD(0.0),
-  fMaxD(0.0),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE),
-  fEvent(0x0)
+//______________________________________________________________________________
+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 AliRsnCut& copy) :
-  TNamed(copy),
-  fVarType(copy.fVarType),
-  fTarget(copy.fTarget),
-  fMinI(copy.fMinI),
-  fMaxI(copy.fMaxI),
-  fMinD(copy.fMinD),
-  fMaxD(copy.fMaxD),
-  fCutValueI(copy.fCutValueI),
-  fCutValueD(copy.fCutValueD),
-  fCutResult(copy.fCutResult),
-  fEvent(copy.fEvent)
+//______________________________________________________________________________
+AliRsnCut::AliRsnCut
+(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)
 {
 //
-// Copy constructor.
+// Constructor with arguments.
+// This is provided to allow a quick setting of all data members.
 //
 }
 
-//_________________________________________________________________________________________________
+//______________________________________________________________________________
 AliRsnCut::AliRsnCut
-(const char *name, ETarget target, Int_t min, Int_t max) :
-  TNamed(name, ""),
-  fVarType(kInt),
-  fTarget(target),
-  fMinI(min),
-  fMaxI(max),
-  fMinD(0.0),
-  fMaxD(0.0),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE),
-  fEvent(0x0)
+(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 with integer values.
-// 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, ETarget target, Double_t min, Double_t max) :
-  TNamed(name, ""),
-  fVarType(kDouble),
-  fTarget(target),
-  fMinI(0),
-  fMaxI(0),
-  fMinD(min),
-  fMaxD(max),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE),
-  fEvent(0x0)
+//______________________________________________________________________________
+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 with double values.
-// 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
 //
 }
 
-//_________________________________________________________________________________________________
+//______________________________________________________________________________
 AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 {
 //
-// Assignment operator
-// don't duplicate memory occupancy for pointer
+// Assignment operator.
+// Don't duplicate memory occupancy for pointer
 //
 
-  fVarType   = copy.fVarType;
-  fTarget    = copy.fTarget;
-  fMinI      = copy.fMinI;
-  fMaxI      = copy.fMaxI;
-  fMinD      = copy.fMinD;
-  fMaxD      = copy.fMaxD;
-  fCutValueI = copy.fCutValueI;
-  fCutValueD = copy.fCutValueD;
-  fCutResult = copy.fCutResult;
-  fEvent     = copy.fEvent;
-
-  return (*this);
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::TargetOK(TObject *obj1, TObject *obj2)
-{
-//
-// This method checks if the expected target and the passed object match.
-//
+   AliRsnTarget::operator=(copy);
 
-  if (!obj1)
-  {
-    AliError("Cannot cut on a NULL object!");
-    return kFALSE;
-  }
+   fMinI      = copy.fMinI;
+   fMaxI      = copy.fMaxI;
+   fMinD      = copy.fMinD;
+   fMaxD      = copy.fMaxD;
+   fCutValueI = copy.fCutValueI;
+   fCutValueD = copy.fCutValueD;
+   fCutResult = copy.fCutResult;
 
-  switch (fTarget)
-  {
-    case kDaughter:
-      if (dynamic_cast<AliRsnDaughter*>(obj1) == 0x0)
-      {
-        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnDaughter', passed '%s'", GetName(), obj1->ClassName()));
-        Print();
-        return kFALSE;
-      }
-      break;
-    case kMother:
-      if (dynamic_cast<AliRsnMother*>(obj1) == 0x0)
-      {
-        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnMother', passed '%s'", GetName(), obj1->ClassName()));
-        Print();
-        return kFALSE;
-      }
-      break;
-    case kEvent:
-      if (dynamic_cast<AliRsnEvent*>(obj1) == 0x0)
-      {
-        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnEvent', passed '%s'", GetName(), obj1->ClassName()));
-        Print();
-        return kFALSE;
-      }
-      break;
-    case kMixEvent:
-      if (dynamic_cast<AliRsnEvent*>(obj1) == 0x0)
-      {
-        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnEvent', passed '%s' an", GetName(), obj1->ClassName()));
-        Print();
-        return kFALSE;
-      }
-      if (obj2)
-      {
-        if (dynamic_cast<AliRsnEvent*>(obj2) == 0x0)
-        {
-          AliError(Form("[%s] Target mismatch (obj #2): expected  'AliRsnEvent', passed '%s' an", GetName(), obj2->ClassName()));
-          Print();
-          return kFALSE;
-        }
-      }
-      else
-      {
-        AliError("Mix-event cuts require 2 not NULL objects");
-        Print();
-        return kFALSE;
-      }
-      break;
-    default:
-      return kTRUE;
-  }
-  
-  return kTRUE;
+   return (*this);
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(TObject* /*obj1*/, TObject* /*obj2*/)
+//______________________________________________________________________________
+Bool_t AliRsnCut::IsSelected(TObject* /*object*/)
 {
 //
-// Virtual cut-checking method for event mixing.
-// This method checks only that the target is the oner for mixing.
+// Virtual cut-checking method.
+// 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("Single-object cuts are not implemented here.");
-  return kTRUE;
+   AliWarning("This virtual function must be implemented properly");
+   return kTRUE;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkValue()
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueI()
 {
 //
-// 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 a reference.
+// In the case of integers, the equality must be exact.
 //
 
-  switch (fVarType) 
-  {
-    case kInt:
-      return OkValueI();
-    case kDouble:
-      return OkValueD();
-    default:
-      AliError(Form("fVarType = %d --> not allowed", fVarType));
-      return kFALSE;
-  }
-}
+   // eval result
+   fCutResult = (fCutValueI == fMinI);
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkRange()
-{
-//
-// 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.
-//
+   // 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 ====================================================");
 
-  switch (fVarType) 
-  {
-    case kInt:
-      return OkRangeI();
-    case kDouble:
-      return OkRangeD();
-    default:
-      AliError(Form("fVarType = %d --> not allowed", fVarType));
-      return kFALSE;
-  }
+   return fCutResult;
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkValueI()
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueD()
 {
 //
-// This method is used when the cut consists in comparing the cut value
-// with a reference integer value to which it must be equal.
+// This method is used to compare a value with a reference.
+// In the case of doubles, the equality consists in being very close.
 //
 
-  // 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 ================================");
-  
-  return fCutResult;
-}
+   // eval result
+   fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkValueD()
-{
-//
-// This method is used when the cut consists in comparing the cut value
-// with a reference double value to which it must be equal (or at least, almost).
-//
+   // 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 ===================================================");
 
-  // 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 ================================");
-  
-  return fCutResult;
+   return fCutResult;
 }
 
-//_________________________________________________________________________________________________
+//______________________________________________________________________________
 Bool_t AliRsnCut::OkRangeI()
 {
 //
-// 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 an integer range.
 //
 
-  // 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 ================================");
-  
-  return fCutResult;
-}
+   // eval result
+   fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
 
-//_________________________________________________________________________________________________
-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.
-//
-
-  // 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 ================================");
+   // 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;
 }
 
-//_________________________________________________________________________________________________
-void AliRsnCut::Print(Option_t*) const
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkRangeD()
 {
 //
-// Override TObject::Print() method
+// This method is used to compare a value with a double-float range.
 //
 
-  Char_t target[100];
-  switch (fTarget)
-  {
-    case kDaughter: sprintf(target, "DAUGHTER"); break;
-    case kMother  : sprintf(target, "MOTHER"); break;
-    case kEvent   : sprintf(target, "EVENT"); break;
-    case kMixEvent: sprintf(target, "MIX EVENT"); break;
-    default       : sprintf(target, "UNDEFINED"); break;
-  }
+   // eval result
+   fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 
-  AliInfo("=== CUT DETAILS ====================================");
-  AliInfo(Form("Cut name     : [%s]", GetName()));
-  AliInfo(Form("Cut target   : [%s]", target));
-  AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
-  AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
-  AliInfo("====================================================");
+   // 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::SetEvent(AliRsnEvent *event)
+//______________________________________________________________________________
+void AliRsnCut::Print(Option_t*) const
 {
 //
-// Sets the reference event
+// Override TObject::Print() method,
+// and print some useful info about the cut general parameters.
 //
 
-  fEvent = event;
+   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("====================================================");
 }