Checked and cleaned code on all PID cuts. Removed TOF direct dependencies, which...
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Feb 2011 15:21:51 +0000 (15:21 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 Feb 2011 15:21:51 +0000 (15:21 +0000)
Next step: removal of all TOF direct dependencies from the package.

PWG2/RESONANCES/AliRsnCutPIDITS.cxx
PWG2/RESONANCES/AliRsnCutPIDITS.h
PWG2/RESONANCES/AliRsnCutPIDTOF.cxx
PWG2/RESONANCES/AliRsnCutPIDTOF.h
PWG2/RESONANCES/AliRsnCutPIDTPC.cxx
PWG2/RESONANCES/AliRsnCutPIDTPC.h

index 28c4056..60085ba 100644 (file)
@@ -32,40 +32,34 @@ ClassImp(AliRsnCutPIDITS)
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDITS::AliRsnCutPIDITS
-(const char *name, AliPID::EParticleType type, Bool_t isMC, Double_t momLimit, Double_t cut1, Double_t cut2) :
-  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
-  fPIDtype(type),
-  fIsMC(isMC),
-  fMomentumLimit(momLimit),
-  fLargeCut(TMath::Max(cut1, cut2)),
-  fSmallCut(TMath::Min(cut1, cut2)),
+(const char *name, AliPID::EParticleType ref, Double_t min, Double_t max, Bool_t rejectOutside) :
+  AliRsnCut(name, AliRsnCut::kDaughter, min, max),
+  fRejectOutside(rejectOutside),
+  fMomMin(0.0),
+  fMomMax(1E+20),
+  fRefType(ref),
   fESDpid(),
   fAODpid()
 {
 //
 // Main constructor.
 //
-
-  SetMC(isMC);
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDITS::AliRsnCutPIDITS
 (const AliRsnCutPIDITS& copy) :
   AliRsnCut(copy),
-  fPIDtype(copy.fPIDtype),
-  fIsMC(copy.fIsMC),
-  fMomentumLimit(copy.fMomentumLimit),
-  fLargeCut(copy.fLargeCut),
-  fSmallCut(copy.fSmallCut),
+  fRejectOutside(copy.fRejectOutside),
+  fMomMin(copy.fMomMin),
+  fMomMax(copy.fMomMax),
+  fRefType(copy.fRefType),
   fESDpid(copy.fESDpid),
   fAODpid(copy.fAODpid)
 {
 //
 // Copy constructor.
 //
-
-  SetMC(copy.fIsMC);
 }
 
 //_________________________________________________________________________________________________
@@ -77,14 +71,12 @@ AliRsnCutPIDITS& AliRsnCutPIDITS::operator=(const AliRsnCutPIDITS& copy)
 
   AliRsnCut::operator=(copy);
 
-  fPIDtype = copy.fPIDtype;
-  fMomentumLimit = copy.fMomentumLimit;
-  fLargeCut = copy.fLargeCut;
-  fSmallCut = copy.fSmallCut;
-  fESDpid = copy.fESDpid;
-  fAODpid = copy.fAODpid;
-  
-  SetMC(copy.fIsMC);
+  fRejectOutside = copy.fRejectOutside;
+  fMomMin        = copy.fMomMin;
+  fMomMax        = copy.fMomMax;
+  fRefType       = copy.fRefType;
+  fESDpid        = copy.fESDpid;
+  fAODpid        = copy.fAODpid;
   
   return (*this);
 }
@@ -96,8 +88,8 @@ void AliRsnCutPIDITS::SetMC(Bool_t yn)
 // Properly set the PID response
 //
 
-  fIsMC = yn;
-  AliITSPIDResponse itsresponse(fIsMC);
+  AliITSPIDResponse itsresponse(yn);
+  
   fESDpid.GetITSResponse() = itsresponse;
   fAODpid.GetITSResponse() = itsresponse;
 }
@@ -117,81 +109,64 @@ Bool_t AliRsnCutPIDITS::IsSelected(TObject *object)
   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
   if (!vtrack)
   {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
+    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
     return kFALSE;
   }
   
   // check status, to know it track is an ITS+TPC or ITS standalone
-  // and reject it if it is of none of the allowed types
+  // and reject it if it is of none of them
   Bool_t isSA = kFALSE;
-  if (IsITSTPC(vtrack)) isSA = kFALSE;
-  else if (IsITSSA(vtrack)) isSA = kTRUE;
+  if (IsTPC(vtrack)) isSA = kFALSE;
+  else if (IsSA(vtrack)) isSA = kTRUE;
   else
   {
-    AliWarning("Track is neither ITS+TPC nor ITS standalone");
+    AliDebug(AliLog::kDebug + 2, "Status flags unmatched");
     return kFALSE;
   }
-  
-  // common evaluation variables
-  Double_t mom = vtrack->P();
-  Int_t    k, nITSpidLayers;
 
-  // retrieve real object type
+  // common evaluation variables
+  Int_t        k, nITSpidLayers = 0;
+  Double_t     mom      = vtrack->P();
   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
+
+  // check momentum
+  if (mom < fMomMin || mom > fMomMax)
+  {
+    AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
+    return (!fRejectOutside);
+  }
+
+  // count number of PID layers...
   if (esdTrack) 
   {
-    AliDebug(AliLog::kDebug + 2, "Checking an ESD track");
-    
-    // count PID layers and reject if they are too few
-    nITSpidLayers = 0;
     UChar_t itsCluMap = esdTrack->GetITSClusterMap();
     for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITSpidLayers;
-    if (nITSpidLayers < 3)
-    {
-      AliDebug(AliLog::kDebug+2, "Rejecting track with too few ITS pid layers");
-      return kFALSE;
-    }
-  
-    // create the PID response object and compute nsigma
-    AliITSPIDResponse &itsrsp = fESDpid.GetITSResponse();
-    fCutValueD = itsrsp.GetNumberOfSigmas(mom, esdTrack->GetITSsignal(), fPIDtype, nITSpidLayers, isSA);
   }
   else if (aodTrack)
   {
-    AliDebug(AliLog::kDebug + 2, "Checking an AOD track");
-    
-    // count PID layers and reject if they are too few
-    nITSpidLayers = 0;
     for(k = 2; k < 6; k++) if (TESTBIT(aodTrack->GetITSClusterMap(), k)) ++nITSpidLayers;
-    if (nITSpidLayers < 3)
-    {
-      AliDebug(AliLog::kDebug+2, "Rejecting track with too few ITS pid layers");
-      return kFALSE;
-    }
-    
-    // compute nsigma
-    fCutValueD = fAODpid.NumberOfSigmasITS(aodTrack, fPIDtype);
   }
   else
   {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
+    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
     return kFALSE;
   }
-  
-  // determine cut range from the momentum
-  if (mom < fMomentumLimit)
+  // ...and reject tracks where it is smaller than 3
+  if (nITSpidLayers < 3)
   {
-    fMinD = -fLargeCut;
-    fMaxD =  fLargeCut;
+    AliDebug(AliLog::kDebug+2, "Rejecting track with too few ITS pid layers");
+    return kFALSE;
   }
+    
+  // assign PID nsigmas to default cut check value
+  // since bad object types are rejected before, here we have an ESD track or AOD track
+  if (esdTrack) 
+    fCutValueD = fESDpid.GetITSResponse().GetNumberOfSigmas(mom, esdTrack->GetITSsignal(), fRefType, nITSpidLayers, isSA);
   else
-  {
-    fMinD = -fSmallCut;
-    fMaxD =  fSmallCut;
-  }
+    fCutValueD = fAODpid.NumberOfSigmasITS(aodTrack, fRefType);
   
-  // check the cut using the standard AliRsnCut facilities
+  // use default cut checking method
   return OkRangeD();
 }
 
@@ -202,6 +177,8 @@ void AliRsnCutPIDITS::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name, type                  : %s %s", GetName(), ClassName()));
-  AliInfo(Form("ITS PID cut: limit, large, small: %.3f %.3f %.3f", fMomentumLimit, fLargeCut, fSmallCut));
+  AliInfo(Form("Cut name                    : %s", GetName()));
+  AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
+  AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
+  AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
 }
index f13db71..d784150 100644 (file)
 #define ALIRSNCUTPIDITS_H
 
 #include "AliPID.h"
-#include "AliVTrack.h"
+
+#include "AliESDtrack.h"
+#include "AliESDtrackCuts.h"
 #include "AliESDpid.h"
+
 #include "AliAODpidUtil.h"
+
+#include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
 class AliRsnCutPIDITS : public AliRsnCut
 {
   public:
 
-    AliRsnCutPIDITS(const char *name = "cutPIDITS", AliPID::EParticleType type = AliPID::kKaon, Bool_t fIsMC = kFALSE, Double_t momLimit = 0.0, Double_t cut1 = 3.0, Double_t cut2 = 3.0);
+    AliRsnCutPIDITS(const char *name          = "cutITS",
+                    EPARTYPE    ref           = AliPID::kKaon,
+                    Double_t    nSigmaMin     = -3.,
+                    Double_t    nSigmaMax     =  3.,
+                    Bool_t      rejectOutside = kTRUE);
+                    
     AliRsnCutPIDITS(const AliRsnCutPIDITS& copy);
     AliRsnCutPIDITS& operator=(const AliRsnCutPIDITS& copy);
     virtual ~AliRsnCutPIDITS() { }
 
-    AliESDpid*       GetESDpid()                         {return &fESDpid;}    
-    void             SetPIDType(AliPID::EParticleType t) {fPIDtype = t;}
-        
-    void             SetMC(Bool_t yn = kTRUE);
-    void             SetMomentumLimit(Double_t v)        {fMomentumLimit = v;}
-    void             SetLargeCut(Double_t v)             {fLargeCut = v;}
-    void             SetSmallCut(Double_t v)             {fSmallCut = v;}
-    
+    AliESDpid*       ESDpid()  {return &fESDpid;}
+    AliAODpidUtil*   AODpid()  {return &fAODpid;}
+
+    void             SetMC(Bool_t mc = kTRUE); 
+    void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
+    void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
+    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
+    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
+
+    Bool_t           IsTPC(AliVTrack *vtrack);
+    Bool_t           IsSA(AliVTrack *vtrack);
     virtual Bool_t   IsSelected(TObject *object);
     virtual void     Print(const Option_t *option = "") const;
 
-  protected:
-  
-    Bool_t  IsITSTPC (AliVTrack *d);  // check that the track is TPC+ITS
-    Bool_t  IsITSSA  (AliVTrack *d);  // check that the track is ITS standalone
-  
-    AliPID::EParticleType   fPIDtype;          //  PID reference type used for checks
-    
-    Bool_t                  fIsMC;             //  to know what settings must be used
-    Double_t                fMomentumLimit;    //  below this value, large cut is used; above, small one is used (value in GeV/c)
-    Double_t                fLargeCut;         //  range for ITS de/dx large cut
-    Double_t                fSmallCut;         //  range for ITS de/dx small cut
-    
-    AliESDpid               fESDpid;           //  ESD PID object
-    AliAODpidUtil           fAODpid;           //  AOD PID object
+  private:
+
+    Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
+    Double_t        fMomMin;         // min p in range where this cut is checked
+    Double_t        fMomMax;         // max p in range where this cut is checked
+    EPARTYPE        fRefType;        // particle type for which PID is checked
+    AliESDpid       fESDpid;         // ESD PID object
+    AliAODpidUtil   fAODpid;         // AOD PID object
 
     ClassDef(AliRsnCutPIDITS, 1)
 };
 
-inline Bool_t AliRsnCutPIDITS::IsITSTPC(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDITS::IsTPC(AliVTrack *vtrack)
 {
 //
 // Checks if the track has the status flags required for a global track
@@ -78,7 +85,7 @@ inline Bool_t AliRsnCutPIDITS::IsITSTPC(AliVTrack *vtrack)
   return kTRUE;
 }
 
-inline Bool_t AliRsnCutPIDITS::IsITSSA(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDITS::IsSA(AliVTrack *vtrack)
 {
 //
 // Checks if the track has the status flags required for an ITS standalone track
index 6a20fc1..8e1113d 100644 (file)
@@ -1,89 +1,72 @@
 //
 // Class AliRsnCutPIDTOF
 //
-// 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()]
-//
-// 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.
+// Implements the PID check with TOF detector,
+// computed as a compatibility within a given range
+// expressed in number of sigmas w.r. to expected time.
+// Uses the default cut checking facilities of AliRsnCut
+// to check this.
 //
 // authors: Martin Vala (martin.vala@cern.ch)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#include <Riostream.h>
-
-#include "AliESDtrack.h"
-#include "AliAODTrack.h"
-#include "AliESDpid.h"
-#include "AliTOFT0maker.h"
-#include "AliTOFcalib.h"
-#include "AliCDBManager.h"
-#include "AliVTrack.h"
-
 #include "AliRsnEvent.h"
-#include "AliRsnDaughter.h"
 #include "AliRsnCutPIDTOF.h"
 
 ClassImp(AliRsnCutPIDTOF)
 
-//Bool_t         AliRsnCutPIDTOF::fgTOFcalibrateESD = kTRUE;
-Bool_t         AliRsnCutPIDTOF::fgTOFcorrectTExp  = kTRUE;
-Bool_t         AliRsnCutPIDTOF::fgTOFuseT0        = kTRUE;
-Bool_t         AliRsnCutPIDTOF::fgTOFtuneMC       = kFALSE;
-Double_t       AliRsnCutPIDTOF::fgTOFresolution   = 100.0;
-AliTOFT0maker* AliRsnCutPIDTOF::fgTOFmaker        = 0x0;
-AliTOFcalib*   AliRsnCutPIDTOF::fgTOFcalib        = 0x0;
-Int_t          AliRsnCutPIDTOF::fgLastRun         = -1;
-Int_t          AliRsnCutPIDTOF::fgLastEventID     = -1;
-AliESDEvent*   AliRsnCutPIDTOF::fgLastEvent       = 0x0;
-
-
 //_________________________________________________________________________________________________
-AliRsnCutPIDTOF::AliRsnCutPIDTOF(const char *name, AliPID::EParticleType pid, Bool_t isMC, Double_t min, Double_t max, Bool_t forceMatching) :
+AliRsnCutPIDTOF::AliRsnCutPIDTOF
+(const char *name, AliPID::EParticleType ref, Double_t min, Double_t max, Bool_t rejectUnmatched) :
   AliRsnCut(name, AliRsnCut::kDaughter, min, max),
-  fIsMC(isMC),
-  fForceMatching(forceMatching),
-  fPIDtype(pid),
+  fRejectUnmatched(rejectUnmatched),
+  fRefType(AliPID::kUnknown),
+  fRefMass(0.0),
   fESDpid(),
   fAODpid()
 {
 //
 // Default constructor.
+// To set the reference PID type, calls the SetRefType method,
+// which sets the mass accordingly and coherently.
 //
+
+  SetRefType(ref);
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDTOF::AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy) :
   AliRsnCut(copy),
-  fIsMC(copy.fIsMC),
-  fForceMatching(copy.fForceMatching),
-  fPIDtype(copy.fPIDtype),
+  fRejectUnmatched(copy.fRejectUnmatched),
+  fRefType(AliPID::kUnknown),
+  fRefMass(0.0),
   fESDpid(copy.fESDpid),
   fAODpid(copy.fAODpid)
 {
 //
-// Copy constructor
+// Copy constructor.
+// To set the reference PID type, calls the SetRefType method,
+// which sets the mass accordingly and coherently.
 //
+
+  SetRefType(copy.fRefType);
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDTOF& AliRsnCutPIDTOF::operator=(const AliRsnCutPIDTOF& copy)
 {
 //
-// Assignment operator
+// Assignment operator.
+// To set the reference PID type, calls the SetRefType method,
+// which sets the mass accordingly and coherently.
 //
 
-  fIsMC = copy.fIsMC;
-  fForceMatching = copy.fForceMatching;
-  fPIDtype = copy.fPIDtype;
+  fRejectUnmatched = copy.fRejectUnmatched;
   fESDpid = copy.fESDpid;
   fAODpid = copy.fAODpid;
+
+  SetRefType(copy.fRefType);
   
   return (*this);
 }
@@ -102,147 +85,63 @@ Bool_t AliRsnCutPIDTOF::IsSelected(TObject *object)
   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
   if (!vtrack)
   {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
+    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
     return kFALSE;
   }
   
-  // for non TOF-matched tracks, the TOF PID check cannot be done:
-  // -- if 'fForceMatching' is kTRUE
-  //    all non matched tracks are rejected as if they didn't pass the cut
-  // -- if 'fForceMatching' is kFALSE
-  //    all non matched tracks are ignored, as if they did pass the cut
-  ULong_t status = (ULong_t)vtrack->GetStatus();
-  if ((status & AliESDtrack::kTOFout) == 0 || (status & AliESDtrack::kTIME) == 0)
+  // checks that track is matched in TOF:
+  // if not, the track is accepted or rejected
+  // depending on the 'fRejectUnmatched' data member:
+  // -- kTRUE  --> all unmatched tracks are rejected
+  // -- kFALSE --> all unmatched tracks are accepted (it is assumed that other PIDs are done)
+  if (!IsMatched(vtrack))
   {
     AliDebug(AliLog::kDebug + 2, "Track is not matched with TOF");
-    if (fForceMatching)
-      return kFALSE;
-    else
-      return kTRUE;
+    return (!fRejectUnmatched);
   }
   
-  // retrieve real object type
+  // retrieve real object type and
+  // prepare some useful variables
+  Double_t     tof, sigma, times[5];
+  Double_t    &ref = times[(Int_t)fRefType];
   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
+
+  // cut check depends on the object type
   if (esdTrack) 
   {
-    AliDebug(AliLog::kDebug + 2, "Checking an ESD track");
-    ProcessCurrentEvent();
-    return CheckESD(esdTrack);
+    // setup the ESD PID object
+    AliESDEvent *esd = AliRsnTarget::GetCurrentEvent()->GetRefESD();
+    if (!esd)
+    {
+      AliError("Processing an ESD track, but target is not an ESD event");
+      return kFALSE;
+    }
+    fESDpid.SetTOFResponse(esd, AliESDpid::kTOF_T0);
+
+    // get time of flight, reference times and sigma
+    esdTrack->GetIntegratedTimes(times);
+    tof   = (Double_t)(esdTrack->GetTOFsignal() - fESDpid.GetTOFResponse().GetStartTime(esdTrack->P()));
+    sigma = (Double_t)fESDpid.GetTOFResponse().GetExpectedSigma(esdTrack->P(), ref, fRefMass);
+
+    // port values to standard AliRsnCut checker
+    fCutValueD = (tof - ref) / sigma;
+    return OkRangeD();
   }
   else if (aodTrack)
   {
-    AliDebug(AliLog::kDebug + 2, "Checking an AOD track");
-    return CheckAOD(aodTrack);
+    // for AOD tracks, all operations are done by the AOD PID utility
+    fCutValueD = (Double_t)fAODpid.NumberOfSigmasTOF(aodTrack, fRefType);
+    return OkRangeD();
   }
   else
   {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
+    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
     return kFALSE;
   }
 }
 
 //_________________________________________________________________________________________________
-void AliRsnCutPIDTOF::ProcessCurrentEvent()
-{
-//
-// Repeats the PID for current event.
-// In order to avoid to repeat the operation for each track
-// this function uses the data-member pointers to check
-// if current event was already processed or not.
-//
-
-  // get current event and skip if it is the same as before
-  AliESDEvent *esd = fgCurrentEvent->GetRefESD();
-  if (esd == fgLastEvent) return;
-  
-  // if event has changed, get run number and 
-  // reinitialize the calib and time maker
-  // if this has changed
-  Int_t run = esd->GetRunNumber();
-  if (run != fgLastRun)
-  {
-    AliInfo("============================================================================================");
-    AliInfo(Form("*** CHANGING RUN NUMBER: PREVIOUS = %d --> CURRENT = %d ***", fgLastRun, run));
-    AliInfo("============================================================================================");
-    fgLastRun = run;
-  
-    AliCDBManager::Instance()->SetDefaultStorage("raw://");
-    AliCDBManager::Instance()->SetRun(fgLastRun);
-    
-    if (fgTOFmaker) delete fgTOFmaker;
-    if (fgTOFcalib) delete fgTOFcalib;
-    
-    fgTOFcalib = new AliTOFcalib();
-    if (fIsMC)
-    {
-      fgTOFcalib->SetRemoveMeanT0(kFALSE);
-      fgTOFcalib->SetCalibrateTOFsignal(kFALSE);
-    }
-    else
-    {
-      fgTOFcalib->SetRemoveMeanT0(kTRUE);
-      fgTOFcalib->SetCalibrateTOFsignal(kTRUE);
-    }
-    if (fgTOFcorrectTExp) fgTOFcalib->SetCorrectTExp(kTRUE);
-    fgTOFcalib->Init();
-    
-    fgTOFmaker = new AliTOFT0maker(&fESDpid, fgTOFcalib);
-    fgTOFmaker->SetTimeResolution(fgTOFresolution);
-  }
-
-  // repeat the calibration and PID computations
-  /*if (fgTOFcalibrateESD)*/ fgTOFcalib->CalibrateESD(esd);
-  if (fgTOFtuneMC) fgTOFmaker->TuneForMC(esd);
-  if (fgTOFuseT0)
-  {
-    fgTOFmaker->ComputeT0TOF(esd);
-    fgTOFmaker->ApplyT0TOF(esd);
-    fESDpid.MakePID(esd, kFALSE, 0.);
-  }
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutPIDTOF::CheckESD(AliESDtrack *track)
-{
-//
-// Check TOF particle identification for ESD tracks.
-// Uses the AlifESDpid odata member.
-//
-
-  // require a minimum length to have meaningful match
-  if (track->GetIntegratedLength() < 350.) return kFALSE;
-  
-  // setup TOF PID response
-  AliTOFPIDResponse &tofrsp = fESDpid.GetTOFResponse();
-  
-  // get info for computation
-  Double_t momentum = track->P();
-  Double_t time     = track->GetTOFsignal();
-  Double_t timeint[AliPID::kSPECIES];
-  tofrsp.GetStartTime(momentum);
-  track->GetIntegratedTimes(timeint);
-  Double_t timeDiff = time - timeint[(Int_t)fPIDtype];
-  Double_t sigmaRef = tofrsp.GetExpectedSigma(momentum, timeint[(Int_t)fPIDtype], AliPID::ParticleMass(fPIDtype));
-  
-  // port values to standard AliRsnCut checker
-  fCutValueD = timeDiff / sigmaRef;
-  return OkRangeD();
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutPIDTOF::CheckAOD(AliAODTrack *track) 
-{
-//
-// check TOF particle identification for AOD tracks.
-// Uses the AliAODpidUtil data member.
-//
-
-  fCutValueD = (Double_t)fAODpid.NumberOfSigmasTOF(track, fPIDtype);
-  return OkRangeD();
-}
-
-//_________________________________________________________________________________________________
 void AliRsnCutPIDTOF::Print(const Option_t *) const
 {
 //
@@ -251,5 +150,5 @@ void AliRsnCutPIDTOF::Print(const Option_t *) const
 
   AliInfo(Form("Cut name, type            : %s %s", GetName(), ClassName()));
   AliInfo(Form("TOF PID cut range (sigmas): %.3f %.3f", fMinD, fMaxD));
-  AliInfo(Form("Unmatched tracks are      : %s", (fForceMatching ? "rejected" : "accepted")));
+  AliInfo(Form("Unmatched tracks are      : %s", (fRejectUnmatched ? "rejected" : "accepted")));
 }
index 803f227..8f64e11 100644 (file)
 #define ALIRSNCUTPIDTOF_H
 
 #include "AliPID.h"
+
+#include "AliVTrack.h"
+#include "AliESDtrack.h"
 #include "AliESDpid.h"
+#include "AliAODTrack.h"
 #include "AliAODpidUtil.h"
 
-class AliTOFT0maker;
-class AliTOFcalib;
-class AliESDtrack;
-class AliAODTrack;
-
+#include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
 class AliRsnCutPIDTOF : public AliRsnCut
 {
   public:
 
-    AliRsnCutPIDTOF(const char *name = "cutPIDTOF", AliPID::EParticleType pid = AliPID::kKaon, Bool_t isMC = kFALSE, Double_t min = -10.0, Double_t max = 10.0, Bool_t forceMatching = kFALSE);
+    AliRsnCutPIDTOF(const char *name            = "cutTOF",
+                    EPARTYPE    particle        = AliPID::kKaon,
+                    Double_t    nSigmaMin       = -3.,
+                    Double_t    nSigmaMax       =  3.,
+                    Bool_t      rejectUnmatched = kFALSE);
+                    
     AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy);
     AliRsnCutPIDTOF& operator=(const AliRsnCutPIDTOF& copy);
     virtual ~AliRsnCutPIDTOF() { }
+
+    AliESDpid*      ESDpid()  {return &fESDpid;}
+    AliAODpidUtil*  AODpid()  {return &fAODpid;}
     
-    void             SetMC(Bool_t yn = kTRUE) {fIsMC = yn;}
-    virtual Bool_t   IsSelected(TObject *object);
-    virtual void     Print(const Option_t *option = "") const;
+    void            SetRejectUnmatched(Bool_t yn = kTRUE)      {fRejectUnmatched = yn;}
+    void            SetNSigmaRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
+    void            SetRefType(EPARTYPE type)                  {fRefType = type; fRefMass = AliPID::ParticleMass(type);}
+
+    Bool_t          IsMatched(AliVTrack *vtrack);
+    virtual Bool_t  IsSelected(TObject *object);
+    virtual void    Print(const Option_t *option = "") const;
 
   protected:
   
-    void    ProcessCurrentEvent();
-    Bool_t  CheckESD(AliESDtrack *track);
-    Bool_t  CheckAOD(AliAODTrack *track);
-  
-    Bool_t                 fIsMC;             //  switch for MC analysis   
-    Bool_t                 fForceMatching;    //  decide if non TOF matched tracks pass the cut or not 
-    AliPID::EParticleType  fPIDtype;          //  particle type for which PID is checked   
-    AliESDpid              fESDpid;           //  PID utility for ESD
-    AliAODpidUtil          fAODpid;           //  PID utility for AOD
-    
-  //static Bool_t          fgTOFcalibrateESD; //! TOF settings
-    static Bool_t          fgTOFcorrectTExp;  //! TOF settings
-    static Bool_t          fgTOFuseT0;        //! TOF settings
-    static Bool_t          fgTOFtuneMC;       //! TOF settings
-    static Double_t        fgTOFresolution;   //! TOF settings
-    static AliTOFT0maker  *fgTOFmaker;        //! TOF time0 computator
-    static AliTOFcalib    *fgTOFcalib;        //! TOF calibration
-    static Int_t           fgLastRun;         //! last run number
-    static Int_t           fgLastEventID;     //! ID of last event processed
-    static AliESDEvent    *fgLastEvent;       //! pointer to last processed event
+    Bool_t            fRejectUnmatched;  //  decide if non TOF matched tracks pass the cut or not
+    EPARTYPE          fRefType;          //  particle type for which PID is checked   
+    Double_t          fRefMass;          //  reference mass used for computations
+    AliESDpid         fESDpid;           //  PID utility for ESD
+    AliAODpidUtil     fAODpid;           //  PID utility for AOD
 
     ClassDef(AliRsnCutPIDTOF, 1)
 };
 
+inline Bool_t AliRsnCutPIDTOF::IsMatched(AliVTrack *vtrack)
+{
+//
+// Checks if the track has the status flags required for an ITS standalone track
+//
+
+  if (!vtrack)
+  {
+    AliWarning("NULL argument: impossible to check status");
+    return kFALSE;
+  }
+
+  Bool_t isTOFout = ((vtrack->GetStatus() & AliESDtrack::kTOFout) != 0);
+  Bool_t isTIME   = ((vtrack->GetStatus() & AliESDtrack::kTIME) != 0);
+
+  // if flags are not set, track is not matched
+  if ( !isTOFout || !isTIME ) return kFALSE;
+
+  // do an additional check on integrated length for ESD tracks
+  AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(vtrack);
+  if (esdTrack) if (esdTrack->GetIntegratedLength() < 350.) return kFALSE;
+
+  // if we are here, flags are OK and length also
+  return kTRUE;
+}
+
 #endif
index bf1d605..906e000 100644 (file)
@@ -32,12 +32,12 @@ ClassImp(AliRsnCutPIDTPC)
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDTPC::AliRsnCutPIDTPC
-(const char *name, AliPID::EParticleType type, Double_t momLimit, Double_t cut1, Double_t cut2) :
-  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
-  fPIDtype(type),
-  fMomentumLimit(momLimit),
-  fLargeCut(TMath::Max(cut1, cut2)),
-  fSmallCut(TMath::Min(cut1, cut2)),
+(const char *name, AliPID::EParticleType type, Double_t min, Double_t max, Bool_t rejectOutside) :
+  AliRsnCut(name, AliRsnCut::kDaughter, min, max),
+  fRejectOutside(rejectOutside),
+  fMomMin(0.0),
+  fMomMax(1E+20),
+  fRefType(type),
   fESDpid(),
   fAODpid()
 {
@@ -50,10 +50,10 @@ AliRsnCutPIDTPC::AliRsnCutPIDTPC
 AliRsnCutPIDTPC::AliRsnCutPIDTPC
 (const AliRsnCutPIDTPC& copy) :
   AliRsnCut(copy),
-  fPIDtype(copy.fPIDtype),
-  fMomentumLimit(copy.fMomentumLimit),
-  fLargeCut(copy.fLargeCut),
-  fSmallCut(copy.fSmallCut),
+  fRejectOutside(copy.fRejectOutside),
+  fMomMin(copy.fMomMin),
+  fMomMax(copy.fMomMax),
+  fRefType(copy.fRefType),
   fESDpid(copy.fESDpid),
   fAODpid(copy.fAODpid)
 {
@@ -71,12 +71,12 @@ AliRsnCutPIDTPC& AliRsnCutPIDTPC::operator=(const AliRsnCutPIDTPC& copy)
 
   AliRsnCut::operator=(copy);
 
-  fPIDtype = copy.fPIDtype;
-  fMomentumLimit = copy.fMomentumLimit;
-  fLargeCut = copy.fLargeCut;
-  fSmallCut = copy.fSmallCut;
-  fESDpid = copy.fESDpid;
-  fAODpid = copy.fAODpid;
+  fRejectOutside = copy.fRejectOutside;
+  fMomMin  = copy.fMomMin;
+  fMomMax  = copy.fMomMax;
+  fRefType = copy.fRefType;
+  fESDpid  = copy.fESDpid;
+  fAODpid  = copy.fAODpid;
   
   return (*this);
 }
@@ -103,63 +103,44 @@ Bool_t AliRsnCutPIDTPC::IsSelected(TObject *object)
   if (!TargetOK(object)) return kFALSE;
   
   // reject not TPC tracks
-  // status is checked in the same way for all tracks
   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
-  if (!vtrack)
-  {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
-  ULong_t status = (ULong_t)vtrack->GetStatus();
-  if ((status & AliESDtrack::kTPCin) == 0)
+  if (!vtrack) return kFALSE;
+  if (!IsTPC(vtrack))
   {
     AliDebug(AliLog::kDebug + 2, "Track is not found in TPC");
     return kFALSE;
   }
   
   // common evaluation variables
-  Double_t mom;
-
-  // retrieve real object type
+  Double_t     mom;
   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
-  if (esdTrack) 
-  {
-    AliDebug(AliLog::kDebug + 2, "Checking an ESD track");
-    
+
+  // get inner momentum and check it w.r. to allowed range:
+  // all tracks outside it will pass the cut or not, depending on 'fRejectOutside'
+  if (esdTrack)
     mom = esdTrack->GetInnerParam()->P();
-    
-    AliTPCPIDResponse &tpcrsp = fESDpid.GetTPCResponse();
-    fCutValueD = tpcrsp.GetNumberOfSigmas(mom, esdTrack->GetTPCsignal(), esdTrack->GetTPCsignalN(), fPIDtype);
-  }
   else if (aodTrack)
-  {
-    AliDebug(AliLog::kDebug + 2, "Checking an AOD track");
-    
-    AliAODPid *pidObj = aodTrack->GetDetPid();
-    mom = pidObj->GetTPCmomentum();
-  
-    fCutValueD = fAODpid.NumberOfSigmasTPC(aodTrack, fPIDtype);
-  }
+    mom = aodTrack->GetDetPid()->GetTPCmomentum();
   else
   {
-    AliDebug(AliLog::kDebug + 2, Form("This object is not either an ESD nor AOD track, it is an %s", fDaughter->GetRef()->ClassName()));
+    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
     return kFALSE;
   }
-  
-  // determine cut range from the momentum
-  if (mom < fMomentumLimit)
+  if ((mom < fMomMin || mom > fMomMax))
   {
-    fMinD = -fLargeCut;
-    fMaxD =  fLargeCut;
+    AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
+    return (!fRejectOutside);
   }
+
+  // assign PID nsigmas to default cut check value
+  // since bad object types are rejected before, here we have an ESD track or AOD track
+  if (esdTrack) 
+    fCutValueD = fESDpid.GetTPCResponse().GetNumberOfSigmas(mom, esdTrack->GetTPCsignal(), esdTrack->GetTPCsignalN(), fRefType);
   else
-  {
-    fMinD = -fSmallCut;
-    fMaxD =  fSmallCut;
-  }
-  
-  // check the cut using the standard AliRsnCut facilities
+    fCutValueD = fAODpid.NumberOfSigmasTPC(aodTrack, fRefType);
+
+  // use AliRsnCut default method to check cut
   return OkRangeD();
 }
 
@@ -170,6 +151,8 @@ void AliRsnCutPIDTPC::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name, type                  : %s %s", GetName(), ClassName()));
-  AliInfo(Form("TPC PID cut: limit, large, small: %.3f %.3f %.3f", fMomentumLimit, fLargeCut, fSmallCut));
+  AliInfo(Form("Cut name                    : %s", GetName()));
+  AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
+  AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
+  AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
 }
index 9cae361..00c4251 100644 (file)
 #define ALIRSNCUTPIDTPC_H
 
 #include "AliPID.h"
+
 #include "AliESDtrack.h"
 #include "AliESDtrackCuts.h"
 #include "AliESDpid.h"
+
 #include "AliAODpidUtil.h"
+
+#include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
 class AliRsnCutPIDTPC : public AliRsnCut
 {
   public:
 
-    AliRsnCutPIDTPC(const char *name = "cutPIDTPC", AliPID::EParticleType type = AliPID::kKaon, Double_t momLimit = 0.350, Double_t cut1 = 5.0, Double_t cut2 = 3.0);
+    AliRsnCutPIDTPC(const char *name       = "cutTPC",
+                    EPARTYPE type          = AliPID::kKaon,
+                    Double_t nSigmaMin     = -3.,
+                    Double_t nSigmaMax     =  3.,
+                    Bool_t   rejectOutside = kTRUE);
+                    
     AliRsnCutPIDTPC(const AliRsnCutPIDTPC& copy);
     AliRsnCutPIDTPC& operator=(const AliRsnCutPIDTPC& copy);
     virtual ~AliRsnCutPIDTPC() { }
 
-    AliESDpid*       GetESDpid()                         {return &fESDpid;}    
-    void             SetPIDType(AliPID::EParticleType t) {fPIDtype = t;}
-        
-    void             SetMomentumLimit(Double_t v)        {fMomentumLimit = v;}
-    void             SetLargeCut(Double_t v)             {fLargeCut = v;}
-    void             SetSmallCut(Double_t v)             {fSmallCut = v;}
-    void             SetBBParam(Double_t *p)             {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
+    AliESDpid*       ESDpid()  {return &fESDpid;}
+    AliAODpidUtil*   AODpid()  {return &fAODpid;}
+
+    void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
+    void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
+    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
+    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
+    void             SetBBParam(Double_t *p)                       {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
     void             SetBBParam(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4);
-    
+
+    Bool_t           IsTPC(AliVTrack *vtrack);
     virtual Bool_t   IsSelected(TObject *object);
     virtual void     Print(const Option_t *option = "") const;
 
-  protected:
-  
-    AliPID::EParticleType   fPIDtype;          //  PID reference type used for checks
-    
-    Double_t                fMomentumLimit;    //  below this value, large cut is used; above, small one is used (value in GeV/c)
-    Double_t                fLargeCut;         //  range for TPC de/dx large cut
-    Double_t                fSmallCut;         //  range for TPC de/dx small cut
-    
-    AliESDpid               fESDpid;           //  ESD PID object
-    AliAODpidUtil           fAODpid;           //  AOD PID object
+  private:
+
+    Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
+    Double_t        fMomMin;         // min p in range where this cut is checked
+    Double_t        fMomMax;         // max p in range where this cut is checked
+    EPARTYPE        fRefType;        // particle type for which PID is checked
+    AliESDpid       fESDpid;         // ESD PID object
+    AliAODpidUtil   fAODpid;         // AOD PID object
 
     ClassDef(AliRsnCutPIDTPC, 1)
 };
 
+inline Bool_t AliRsnCutPIDTPC::IsTPC(AliVTrack *vtrack)
+{
+//
+// Checks if the track has the status flags required for a global track
+//
+
+  if (!vtrack)
+  {
+    AliWarning("NULL argument: impossible to check status");
+    return kFALSE;
+  }
+  
+  Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
+  Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
+  Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
+  
+  return ( isTPCin && isITSrefit && isITSpid );
+  
+  return kTRUE;
+}
+
 #endif