* Add full support for signal delta (signal-expected, signal/expected)
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 25 Mar 2013 12:23:37 +0000 (12:23 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 25 Mar 2013 12:23:37 +0000 (12:23 +0000)
* Fix bug in 'tune on data' introduced in rev61533
J. Wiechula

12 files changed:
STEER/AOD/AliAODpidUtil.cxx
STEER/AOD/AliAODpidUtil.h
STEER/ESD/AliESDpid.cxx
STEER/ESD/AliESDpid.h
STEER/STEERBase/AliHMPIDPIDResponse.cxx
STEER/STEERBase/AliHMPIDPIDResponse.h
STEER/STEERBase/AliITSPIDResponse.cxx
STEER/STEERBase/AliITSPIDResponse.h
STEER/STEERBase/AliPIDResponse.cxx
STEER/STEERBase/AliPIDResponse.h
STEER/STEERBase/AliTPCPIDResponse.cxx
STEER/STEERBase/AliTPCPIDResponse.h

index 4cfc10d..7e160fa 100644 (file)
@@ -105,7 +105,7 @@ Float_t AliAODpidUtil::GetTPCsignalTunedOnData(const AliVTrack *t) const {
 }
 
 //_________________________________________________________________________
-Float_t AliAODpidUtil::GetSignalDeltaTOFold(const AliVParticle *vtrack, AliPID::EParticleType type) const
+Float_t AliAODpidUtil::GetSignalDeltaTOFold(const AliVParticle *vtrack, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Number of sigma implementation for the TOF
@@ -129,8 +129,13 @@ Float_t AliAODpidUtil::GetSignalDeltaTOFold(const AliVParticle *vtrack, AliPID::
     AliError("pointer to AliAODEvent not found, please call GetTrack to set it");
     return -9999.;
   }
+
+  Double_t delta=-9999.;
+
+  if (!ratio) delta=tofTime-expTime;
+  else if (expTime>1.e-20) delta=tofTime/expTime;
   
-  return tofTime - expTime;
+  return delta;
 }
 
 //_________________________________________________________________________
index bd13dd9..a212ae7 100644 (file)
@@ -36,7 +36,7 @@ public:
   Float_t GetTPCsignalTunedOnData(const AliVTrack *t) const;
 
 protected:
-  virtual Float_t GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type) const;
+  virtual Float_t GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio=kFALSE) const;
   virtual Float_t GetNumberOfSigmasTOFold(const AliVParticle *vtrack, AliPID::EParticleType type) const;
   
 private:
index 8e3c077..584e1e7 100644 (file)
@@ -411,15 +411,21 @@ Bool_t AliESDpid::CheckTOFMatching(AliESDtrack *track) const{
 }
 
 //_________________________________________________________________________
-Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type) const
+Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // TOF signal - expected
   //
   AliVTrack *vtrack=(AliVTrack*)track;
   
-  Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
-  return (vtrack->GetTOFsignal() - fTOFResponse.GetStartTime(vtrack->P()) - expTime);
+  const Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
+  const Double_t tofTime=vtrack->GetTOFsignal() - fTOFResponse.GetStartTime(vtrack->P());
+  Double_t delta=-9999.;
+
+  if (!ratio) delta=tofTime-expTime;
+  else if (expTime>1.e-20) delta=tofTime/expTime;
+  
+  return delta;
 }
 
 //_________________________________________________________________________
index cd51b36..cce9f15 100644 (file)
@@ -50,7 +50,7 @@ AliESDpid(const AliESDpid&a): AliPIDResponse(a), fRangeTOFMismatch(a.fRangeTOFMi
 
   void SetEventHandler(AliVEventHandler *event){fEventHandler=event;};
 protected:
-  virtual Float_t GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type) const;
+  virtual Float_t GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio=kFALSE) const;
   virtual Float_t GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EParticleType type) const;
 
 private:
index 45295f8..0285553 100644 (file)
@@ -328,15 +328,19 @@ void AliHMPIDPIDResponse::GetProbability(const AliVTrack *vTrk,Int_t nSpecies,Do
   delete [] h;
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Double_t AliHMPIDPIDResponse::GetSignalDelta(const AliVTrack *vTrk, AliPID::EParticleType specie) const {
+Double_t AliHMPIDPIDResponse::GetSignalDelta(const AliVTrack *vTrk, AliPID::EParticleType specie, Bool_t ratio/*=kFALSE*/) const {
   
   //
   // calculation of Experimental Cherenkov angle - Theoretical Cherenkov angle  
   //
-  const Double_t delta = vTrk->GetHMPIDsignal() - GetExpectedSignal(vTrk,specie);
+  const Double_t signal    = vTrk->GetHMPIDsignal();
+  const Double_t expSignal = GetExpectedSignal(vTrk,specie);
+
+  Double_t delta = -9999.;
+  if (!ratio) delta=signal-expSignal;
+  else if (expSignal>1.e-20) delta=signal/expSignal;
   
   return delta;
-  
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 TVector2 AliHMPIDPIDResponse::TracePhot(Double_t xRa, Double_t yRa, Double_t thRa, Double_t phRa, Double_t ckovThe,Double_t ckovPhi) const {
index 566118e..754b308 100644 (file)
@@ -39,7 +39,7 @@ public :
     Double_t GetExpectedSigma   (const AliVTrack *vTrk, AliPID::EParticleType specie                 ) const;                                                                     //Find the sigma for a given ThetaCerTh
     Double_t GetNumberOfSigmas  (const AliVTrack *vTrk, AliPID::EParticleType specie                 ) const;                                                                     //Find the expected Cherenkov angle for a given track
     void     GetProbability     (const AliVTrack *vTrk, Int_t nSpecies,Double_t *prob                ) const;                                                                     //Find the PID probability array
-    Double_t GetSignalDelta     (const AliVTrack *vTrk, AliPID::EParticleType specie                 ) const;    
+    Double_t GetSignalDelta     (const AliVTrack *vTrk, AliPID::EParticleType specie, Bool_t ratio=kFALSE) const;    
     void     Propagate          (const TVector3  dir,   TVector3 &pos,  Double_t z                   ) const;                                                                     //propagate photon alogn the line  
     void     Refract            (TVector3 &dir,         Double_t n1,    Double_t n2                  ) const;                                                                     //refract photon on the boundary
     TVector2 TracePhot          (Double_t xRa, Double_t yRa,  Double_t thRa, Double_t phRa, Double_t ckovThe,Double_t ckovPhi) const;                                             //trace photon created by track to PC 
index 52430c6..756faaf 100644 (file)
@@ -299,7 +299,7 @@ Double_t AliITSPIDResponse::GetNumberOfSigmas( const AliVTrack* track, AliPID::E
 }
 
 //_________________________________________________________________________
-Double_t AliITSPIDResponse::GetSignalDelta( const AliVTrack* track, AliPID::EParticleType type) const
+Double_t AliITSPIDResponse::GetSignalDelta( const AliVTrack* track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Signal - expected
@@ -315,8 +315,13 @@ Double_t AliITSPIDResponse::GetSignalDelta( const AliVTrack* track, AliPID::EPar
   //      this needs to be changed if ITS provides a parametrisation
   //      for electrons also for ITS+TPC tracks
   
-  Float_t bethe = Bethe(mom,AliPID::ParticleMassZ(type), isSA || (type==AliPID::kElectron))*chargeFactor;
-  return (dEdx - bethe);
+  const Float_t bethe = Bethe(mom,AliPID::ParticleMassZ(type), isSA || (type==AliPID::kElectron))*chargeFactor;
+
+  Double_t delta=-9999.;
+  if (!ratio) delta=dEdx-bethe;
+  else if (bethe>1.e-20) delta=dEdx/bethe;
+  
+  return delta;
 }
 
 //_________________________________________________________________________
index 6dd6543..a9bc73e 100644 (file)
@@ -45,7 +45,7 @@ public:
 
  Double_t GetNumberOfSigmas( const AliVTrack* track, AliPID::EParticleType species) const;
 
- Double_t GetSignalDelta( const AliVTrack* track, AliPID::EParticleType species) const;
+ Double_t GetSignalDelta( const AliVTrack* track, AliPID::EParticleType species, Bool_t ratio=kFALSE) const;
  
  Float_t GetNumberOfSigmas(Float_t mom, Float_t signal, AliPID::EParticleType type, Int_t nPtsForPid=4, Bool_t isSA=kFALSE) const {
    const Double_t chargeFactor = TMath::Power(AliPID::ParticleCharge(type),2.);
index 6f71e1c..345b294 100644 (file)
@@ -374,30 +374,30 @@ Float_t  AliPIDResponse::NumberOfSigmasEMCAL(const AliVParticle *vtrack, AliPID:
 }
 
 //______________________________________________________________________________
-AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDelta(EDetector detector, const AliVParticle *track, AliPID::EParticleType type, Double_t &val) const
+AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDelta(EDetector detector, const AliVParticle *track, AliPID::EParticleType type, Double_t &val, Bool_t ratio/*=kFALSE*/) const
 {
   //
   //
   //
   val=-9999.;
   switch (detector){
-    case kITS:   return GetSignalDeltaITS(track,type,val); break;
-    case kTPC:   return GetSignalDeltaTPC(track,type,val); break;
-    case kTOF:   return GetSignalDeltaTOF(track,type,val); break;
-    case kHMPID: return GetSignalDeltaHMPID(track,type,val); break;
+    case kITS:   return GetSignalDeltaITS(track,type,val,ratio); break;
+    case kTPC:   return GetSignalDeltaTPC(track,type,val,ratio); break;
+    case kTOF:   return GetSignalDeltaTOF(track,type,val,ratio); break;
+    case kHMPID: return GetSignalDeltaHMPID(track,type,val,ratio); break;
     default: return kDetNoSignal;
   }
   return kDetNoSignal;
 }
 
 //______________________________________________________________________________
-Double_t AliPIDResponse::GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type) const
+Double_t AliPIDResponse::GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
 {
   //
   //
   //
   Double_t val=-9999.;
-  EDetPidStatus stat=GetSignalDelta(detCode, track, type, val);
+  EDetPidStatus stat=GetSignalDelta(detCode, track, type, val, ratio);
   if ( stat==kDetNoSignal ) val=-9999.;
   return val;
 }
@@ -1798,6 +1798,12 @@ Float_t AliPIDResponse::GetNumberOfSigmasTPC(const AliVParticle *vtrack, AliPID:
 
   const EDetPidStatus pidStatus=GetTPCPIDStatus(track);
   if (pidStatus!=kDetPidOk) return -999.;
+
+  // the following call is needed in order to fill the transient data member
+  // fTPCsignalTuned which is used in the TPCPIDResponse to judge
+  // if using tuned on data
+  if (fTuneMConData)
+    this->GetTPCsignalTunedOnData(track);
   
   return fTPCResponse.GetNumberOfSigmas(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
 }
@@ -1856,49 +1862,56 @@ Float_t AliPIDResponse::GetNumberOfSigmasEMCAL(const AliVParticle *vtrack, AliPI
 }
 
 //______________________________________________________________________________
-AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaITS(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val) const
+AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaITS(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Signal minus expected Signal for ITS
   //
   AliVTrack *track=(AliVTrack*)vtrack;
-  val=fITSResponse.GetSignalDelta(track,type);
+  val=fITSResponse.GetSignalDelta(track,type,ratio);
   
   return GetITSPIDStatus(track);
 }
 
 //______________________________________________________________________________
-AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTPC(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val) const
+AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTPC(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Signal minus expected Signal for TPC
   //
   AliVTrack *track=(AliVTrack*)vtrack;
-  val=fTPCResponse.GetSignalDelta(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
+  
+  // the following call is needed in order to fill the transient data member
+  // fTPCsignalTuned which is used in the TPCPIDResponse to judge
+  // if using tuned on data
+  if (fTuneMConData)
+    this->GetTPCsignalTunedOnData(track);
+  
+  val=fTPCResponse.GetSignalDelta(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, ratio);
   
   return GetTPCPIDStatus(track);
 }
 
 //______________________________________________________________________________
-AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTOF(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val) const
+AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTOF(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Signal minus expected Signal for TOF
   //
   AliVTrack *track=(AliVTrack*)vtrack;
-  val=GetSignalDeltaTOFold(track, type);
+  val=GetSignalDeltaTOFold(track, type, ratio);
   
   return GetTOFPIDStatus(track);
 }
 
 //______________________________________________________________________________
-AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaHMPID(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val) const
+AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaHMPID(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val, Bool_t ratio/*=kFALSE*/) const
 {
   //
   // Signal minus expected Signal for HMPID
   //
   AliVTrack *track=(AliVTrack*)vtrack;
-  val=fHMPIDResponse.GetSignalDelta(track, type);
+  val=fHMPIDResponse.GetSignalDelta(track, type, ratio);
   
   return GetHMPIDPIDStatus(track);
 }
index 85897d7..b9820e4 100644 (file)
 //   Origin: Jens Wiechula, Uni Tuebingen, jens.wiechula@cern.ch //
 //---------------------------------------------------------------//
 
+#include "AliVParticle.h"
+#include "AliVTrack.h"
+
 #include "AliITSPIDResponse.h"
 #include "AliTPCPIDResponse.h"
 #include "AliTRDPIDResponse.h"
 #include "AliTOFPIDResponse.h"
 #include "AliHMPIDPIDResponse.h"
 #include "AliEMCALPIDResponse.h"
-
-
-#include "AliVParticle.h"
-#include "AliVTrack.h"
+#include "AliPID.h"
 
 #include "TNamed.h"
 
@@ -98,8 +98,8 @@ public:
   Bool_t IdentifiedAsElectronTRD(const AliVTrack *track, Double_t efficiencyLevel,Double_t centrality=-1,AliTRDPIDResponse::ETRDPIDMethod PIDmethod=AliTRDPIDResponse::kLQ1D) const;
 
   // Signal delta
-  EDetPidStatus GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type, Double_t &val) const;
-  Double_t GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type) const;
+  EDetPidStatus GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type, Double_t &val, Bool_t ratio=kFALSE) const;
+  Double_t GetSignalDelta(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio=kFALSE) const;
   
   // Probabilities
   EDetPidStatus ComputePIDProbability  (EDetCode  detCode, const AliVTrack *track, Int_t nSpecies, Double_t p[]) const;
@@ -175,7 +175,7 @@ protected:
 
   //unbuffered PID calculation
   virtual Float_t GetNumberOfSigmasTOFold  (const AliVParticle */*track*/, AliPID::EParticleType /*type*/) const {return 0;}
-  virtual Float_t GetSignalDeltaTOFold(const AliVParticle */*track*/, AliPID::EParticleType /*type*/) const {return -9999.;}
+  virtual Float_t GetSignalDeltaTOFold(const AliVParticle */*track*/, AliPID::EParticleType /*type*/, Bool_t /*ratio*/=kFALSE) const {return -9999.;}
   
   EDetPidStatus GetComputeTRDProbability  (const AliVTrack *track, Int_t nSpecies, Double_t p[],AliTRDPIDResponse::ETRDPIDMethod PIDmethod=AliTRDPIDResponse::kLQ1D) const;
   EDetPidStatus GetTOFPIDStatus(const AliVTrack *track) const;
@@ -276,10 +276,10 @@ private:
   Float_t GetBufferedNumberOfSigmas(EDetector detCode, const AliVParticle *track, AliPID::EParticleType type) const;
 
   // Signal deltas
-  EDetPidStatus GetSignalDeltaITS(const AliVParticle *track, AliPID::EParticleType type, Double_t &val) const;
-  EDetPidStatus GetSignalDeltaTPC(const AliVParticle *track, AliPID::EParticleType type, Double_t &val) const;
-  EDetPidStatus GetSignalDeltaTOF(const AliVParticle *track, AliPID::EParticleType type, Double_t &val) const;
-  EDetPidStatus GetSignalDeltaHMPID(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val) const;
+  EDetPidStatus GetSignalDeltaITS(const AliVParticle *track, AliPID::EParticleType type, Double_t &val, Bool_t ratio=kFALSE) const;
+  EDetPidStatus GetSignalDeltaTPC(const AliVParticle *track, AliPID::EParticleType type, Double_t &val, Bool_t ratio=kFALSE) const;
+  EDetPidStatus GetSignalDeltaTOF(const AliVParticle *track, AliPID::EParticleType type, Double_t &val, Bool_t ratio=kFALSE) const;
+  EDetPidStatus GetSignalDeltaHMPID(const AliVParticle *vtrack, AliPID::EParticleType type, Double_t &val, Bool_t ratio=kFALSE) const;
   
   // Probabilities
   EDetPidStatus GetComputePIDProbability  (EDetector detCode,  const AliVTrack *track, Int_t nSpecies, Double_t p[]) const;
index 2de82b0..bbf370f 100644 (file)
@@ -536,7 +536,8 @@ Float_t AliTPCPIDResponse::GetNumberOfSigmas(const AliVTrack* track,
 Float_t AliTPCPIDResponse::GetSignalDelta(const AliVTrack* track,
                                           AliPID::EParticleType species,
                                           ETPCdEdxSource dedxSource,
-                                          Bool_t correctEta) const
+                                          Bool_t correctEta,
+                                          Bool_t ratio/*=kFALSE*/) const
 {
   //Calculates the number of sigmas of the PID signal from the expected value
   //for a given particle species in the presence of multiple gain scenarios
@@ -550,9 +551,13 @@ Float_t AliTPCPIDResponse::GetSignalDelta(const AliVTrack* track,
   if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
     return -9999.; //TODO: Better handling!
 
-  Double_t bethe = GetExpectedSignal(track, species, dEdx, responseFunction, correctEta);
-  // 999 will be returned by GetExpectedSigma e.g. in case of 0 dEdx clusters
-  return dEdx-bethe;
+  const Double_t bethe = GetExpectedSignal(track, species, dEdx, responseFunction, correctEta);
+
+  Double_t delta=-9999.;
+  if (!ratio) delta=dEdx-bethe;
+  else if (bethe>1.e-20) delta=dEdx/bethe;
+
+  return delta;
 }
 
 //_________________________________________________________________________
index b78c751..6dc5a98 100644 (file)
@@ -117,7 +117,7 @@ public:
   Float_t GetSignalDelta( const AliVTrack* track,
                           AliPID::EParticleType species,
                           ETPCdEdxSource dedxSource = kdEdxDefault,
-                          Bool_t correctEta = kFALSE) const;
+                          Bool_t correctEta = kFALSE, Bool_t ratio=kFALSE) const;
   
   void SetResponseFunction(TObject* o,
                            AliPID::EParticleType type,