Coverity fix
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCut.cxx
index 732f37f..222f47a 100644 (file)
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-//=========================================================================
-// 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     [--> IsEqual()  ]
-// 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.
+// *** Class AliRsnCut ***
+//
+// 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.
+//
+// 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: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//          Martin Vala (martin.vala@cern.ch)
 //
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//=========================================================================
-
-#include "AliLog.h"
 
-#include "AliRsnDaughter.h"
-#include "AliRsnMCInfo.h"
-#include "AliRsnPairParticle.h"
-#include "AliRsnPairDef.h"
 #include "AliRsnCut.h"
 
-const Double_t AliRsnCut::fgkDSmallNumber = 1e-100;
-const Double_t AliRsnCut::fgkDBigNumber = 1e10;
-const Int_t    AliRsnCut::fgkIBigNumber = 32767;
-
-ClassImp (AliRsnCut)
+ClassImp(AliRsnCut)
 
-//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut() :
-  TNamed(),
-  fDMin(-fgkDBigNumber),
-  fDMax( fgkDBigNumber),
-  fIMin(-fgkIBigNumber),
-  fIMax( fgkIBigNumber),
-  fUIMin(0),
-  fUIMax(2 * (UInt_t)fgkIBigNumber),
-  fRsnCutType (kLastCutType),
-  fRsnCutVarType (kDouble_t)
+//______________________________________________________________________________
+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)
 {
 //
-// Constructor
+// Default constructor.
 //
 }
 
-//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type) :
-  TNamed (name,title),
-  fDMin(-fgkDBigNumber),
-  fDMax( fgkDBigNumber),
-  fIMin(-fgkIBigNumber),
-  fIMax( fgkIBigNumber),
-  fUIMin(0),
-  fUIMax(2 * (UInt_t)fgkIBigNumber),
-  fRsnCutType (type),
-  fRsnCutVarType (kDouble_t)
+//______________________________________________________________________________
+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)
 {
 //
-// Constructor with arguments but not limits
+// Constructor with arguments.
+// This is provided to allow a quick setting of all data members.
 //
 }
 
-//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type, Double_t min, Double_t max) :
-  TNamed (name,title),
-  fDMin(min),
-  fDMax(max),
-  fIMin(-fgkIBigNumber),
-  fIMax( fgkIBigNumber),
-  fUIMin(0),
-  fUIMax(2 * (UInt_t)fgkIBigNumber),
-  fRsnCutType (type),
-  fRsnCutVarType (kDouble_t)
+//______________________________________________________________________________
+AliRsnCut::AliRsnCut
+(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 arguments and limits
+// Constructor with arguments.
+// This is provided to allow a quick setting of all data members.
 //
 }
 
-//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, Int_t min, Int_t max) :
-  TNamed (name,title),
-  fDMin(-fgkDBigNumber),
-  fDMax( fgkDBigNumber),
-  fIMin(min),
-  fIMax(max),
-  fUIMin(0),
-  fUIMax(2 * (UInt_t)fgkIBigNumber),
-  fRsnCutType (type),
-  fRsnCutVarType (kInt_t)
+//______________________________________________________________________________
+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 arguments and limits
+// Copy constructor.
+// Don't duplicate memory occupancy for pointer
 //
 }
 
-//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, UInt_t min, UInt_t max) :
-  TNamed (name,title),
-  fDMin(-fgkDBigNumber),
-  fDMax( fgkDBigNumber),
-  fIMin(-fgkIBigNumber),
-  fIMax( fgkIBigNumber),
-  fUIMin(min),
-  fUIMax(max),
-  fRsnCutType (type),
-  fRsnCutVarType (kUInt_t)
+//______________________________________________________________________________
+AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 {
 //
-// Constructor with arguments and limits
+// Assignment operator.
+// Don't duplicate memory occupancy for pointer
 //
-}
 
-//________________________________________________________________________________________________________________
-AliRsnCut::~ AliRsnCut()
-{
-//
-// Destructor.
-// Does absolutely nothing.
-//
-}
+   AliRsnTarget::operator=(copy);
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsBetween (const Double_t & theValue)
-{
-//
-// Interval check.
-// Question: "Is the argument included between fDMin and fDMax?"
-// (not implemented for integer values because usually it is not used with them)
-//
-    return ((theValue >= fDMin) && (theValue <= fDMax));
-}
+   fMinI      = copy.fMinI;
+   fMaxI      = copy.fMaxI;
+   fMinD      = copy.fMinD;
+   fMaxD      = copy.fMaxD;
+   fCutValueI = copy.fCutValueI;
+   fCutValueD = copy.fCutValueD;
+   fCutResult = copy.fCutResult;
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsEqual (const Int_t &theValue)
-{
-//
-// Reference check.
-// Question: "Is the argument equal to fIMin?" (fIMax is assumed never used)
-//
-    return (theValue == fIMin);
+   return (*this);
 }
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsEqual (const UInt_t &theValue)
+//______________________________________________________________________________
+Bool_t AliRsnCut::IsSelected(TObject* /*object*/)
 {
 //
-// Reference check.
-// Question: "Is the argument equal to fUIMin?" (fUIMax is assumed never used)
+// 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.
 //
-    return (theValue == fUIMin);
-}
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsEqual (const Double_t &theValue)
-{
-//
-// Reference check.
-// Question: "Is the argument reasonably close to fDMin?" (fDMax is assumed never used)
-// Here, "reasonably close" means that the difference is smaller than the
-// 'fgkSmallNumber' global static data member of this class
-//
-    return (TMath::Abs (theValue - fDMin) < fgkDSmallNumber);
+   AliWarning("This virtual function must be implemented properly");
+   return kTRUE;
 }
 
-//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const Double_t & theValue, const Double_t & theValue2)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueI()
 {
 //
-// (Re)assignment of cut values
+// This method is used to compare a value with a reference.
+// In the case of integers, the equality must be exact.
 //
-    fRsnCutType = type;
-    fDMin = theValue;
-    fDMax = theValue2;
-}
 
-//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const Int_t& theValue, const Int_t& theValue2)
-{
-//
-// (Re)assignment of cut values
-//
-    fRsnCutType = type;
-    fIMin = theValue;
-    fIMax = theValue2;
-}
+   // eval result
+   fCutResult = (fCutValueI == fMinI);
 
-//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const UInt_t& theValue, const UInt_t& theValue2)
-{
-//
-// (Re)assignment of cut values
-//
-    fRsnCutType = type;
-    fUIMin = theValue;
-    fUIMax = theValue2;
+   // 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(ECutSetType type, AliRsnDaughter *daughter)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkValueD()
 {
 //
-// Core of the whole class.
-// According to the kind of cut selected in the enumeration,
-// checks the cut taking the right values from the argument.
-// Depending on the second argument type, only some cuts are checked
-// (the ones for that type of object), otherwise kTRUE is returned in order
-// not to act as a cleaning factor for an AND with other cuts.
+// This method is used to compare a value with a reference.
+// In the case of doubles, the equality consists in being very close.
 //
-    AliDebug (AliLog::kDebug, "<-");
-    AliRsnMCInfo *mcinfo = daughter->GetMCInfo();
 
-    // check type
-    if (type != kParticle) {
-        AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnDaughter)", type, kParticle, daughter->ClassName()));
-        return kTRUE;
-    }
+   // eval result
+   fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
 
-    switch (fRsnCutType) {
-        case kMomentum:
-            return IsBetween (daughter->P());
-        case kTransMomentum:
-            return IsBetween (daughter->Pt());
-        case kEta:
-            return IsBetween (daughter->Eta());
-        case kRadialImpactParam:
-            return IsBetween (daughter->Vt());
-        case kMomentumMC:
-            if (mcinfo) return IsBetween (mcinfo->P());
-            else return kTRUE;
-        case kTransMomentumMC:
-            if (mcinfo) return IsBetween (mcinfo->P());
-            else return kTRUE;
-        case kStatus:
-            return daughter->CheckFlag(fUIMin);
-        case kChargePos:
-            return (daughter->Charge() > 0);
-        case kChargeNeg:
-            return (daughter->Charge() < 0);
-        case kPIDType:
-            return IsEqual((Int_t)daughter->PIDType());
-        /*
-        case kEtaMC:
-            if (mcinfo) return IsBetween (mcinfo->Eta());
-            else return kTRUE;
-        case kMcVt:
-            if (mcinfo) return IsBetween (mcinfo->Vt());
-            else return kTRUE;
-        case kEsdNSigma:
-            return IsBetween (daughter->GetNSigma());
-        case kEsdNSigmaCalculate:
-            return IsBetween (daughter->GetESDInfo()->GetNSigmaCalculate());
-        */
-    }
+   // 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 kTRUE;
+   return fCutResult;
 }
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ECutSetType type, AliRsnPairParticle * pair)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkRangeI()
 {
-    AliDebug (AliLog::kDebug, "<-");
-
-    // check type
-    if (type != kPair) {
-        AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnPairParticle)", type, kPair, pair->ClassName()));
-        return kTRUE;
-    }
+//
+// This method is used to compare a value with an integer range.
+//
 
-    switch (fRsnCutType) {
-        case kMomentum:
-            return IsBetween (pair->GetP());
-        case kTransMomentum:
-            return IsBetween (pair->GetPt());
-        /*
-        case kEta:
-            return IsBetween (daughter->Eta());
-        */
-        case kMomentumMC:
-            return IsBetween (pair->GetPMC());
-        case kTransMomentumMC:
-            return IsBetween (pair->GetPtMC());
-        case kRestMomentum:
-            return CheckRestMomentum(pair);
-        case kIsPdgEqual:
-            return pair->IsPDGEqual();
-        case kIsLabelEqual:
-            return pair->IsLabelEqual();
-        case kIsTruePair:
-            return pair->IsTruePair(fIMin);
-    }
+   // eval result
+   fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
 
-    return kTRUE;
-}
+   // 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 ====================================================");
 
-//________________________________________________________________________________________________________________
-void AliRsnCut::PrintAllValues()
-{
-  AliInfo (Form ("fRsnCutType=%d fRsnCutVarType=%d",fRsnCutType,fRsnCutVarType));
-  AliInfo (Form ("fDMin=%.2e fDMax=%.2e",fDMin,fDMax));
-  AliInfo (Form ("fIMin=%d fIMax=%d",fIMin,fIMax));
-  AliInfo (Form ("fUIMin=%d fUIMax=%d",fUIMin,fUIMax));
+   return fCutResult;
 }
 
-//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::CheckRestMomentum(AliRsnPairParticle *pair)
+//______________________________________________________________________________
+Bool_t AliRsnCut::OkRangeD()
 {
 //
-// Check the cut on daughter momenta in rest reference frame of mother
+// This method is used to compare a value with a double-float range.
 //
 
-    Double_t beta = pair->GetP() / pair->GetMass();
-    Double_t gamma = 1. / TMath::Sqrt(1. - beta*beta);
-
-    Double_t p1labP = 0.0, p1labT, p1restP, p1restTot;
-    p1labP += pair->GetDaughter(0)->Px() * pair->GetP(0);
-    p1labP += pair->GetDaughter(0)->Py() * pair->GetP(1);
-    p1labP += pair->GetDaughter(0)->Pz() * pair->GetP(2);
-    p1labP /= pair->GetP();
-
-    p1labT = TMath::Sqrt(pair->GetDaughter(0)->P2() - p1labP*p1labP);
-
-    p1restP = gamma*p1labP - beta*gamma*pair->GetDaughter(0)->E();
+   // eval result
+   fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
 
-    p1restTot = TMath::Sqrt(p1restP*p1restP + p1labT*p1labT);
+   // 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 IsBetween(p1restTot);
+   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("====================================================");
+}