* add tuned on data functionality for TOF (non-gaussian tails)

Pietro Antonioli <pietro.antonioli@bo.infn.it>
* Patch to be able to compute the fraction of
shared clusters on AOD tracks.
This way we could use the old AODs where the HybridTracks are not exactly what they are on ESD level.
 Salvatore Aiola <salvoaiola@gmail.com>

diff --git a/STEER/AOD/AliAODHandler.cxx b/STEER/AOD/AliAODHandler.cxx
index 87a0c4c3fd7dbdefcb333441460f14348013d1bc..b10e87ecd46bc1b30182199d74a24abea466f49f 100644 (file)
--- a/STEER/AOD/AliAODHandler.cxx
+++ b/STEER/AOD/AliAODHandler.cxx
@@ -386,6 +386,7 @@ void AliAODHandler::StoreMCParticles(){
 
   // AODTracks
   TClonesArray* tracks = fAODEvent->GetTracks();
+  Int_t tofLabel[3];
   if(tracks){
     for(int it = 0; it < fAODEvent->GetNTracks();++it){
       AliAODTrack *track = fAODEvent->GetTrack(it);
@@ -396,7 +397,7 @@ void AliAODHandler::StoreMCParticles(){
        label *= -1;
        sign  = -1;
       }
-
+      
       if (label >= AliMCEvent::BgLabelOffset()) label =  mcEvent->BgLabelToIndex(label);
       if(label > np || track->GetLabel() == 0){
        AliWarning(Form("Wrong ESD track label %5d (%5d)",track->GetLabel(), label));
@@ -405,6 +406,23 @@ void AliAODHandler::StoreMCParticles(){
        AliWarning(Form("New label not found for %5d (%5d)",track->GetLabel(), label));
       }
       track->SetLabel(sign*fMCEventH->GetNewLabel(label));
+      
+      track->GetTOFLabel(tofLabel);
+      
+      for (Int_t i =0; i < 3; i++) {
+       label  = tofLabel[i]; // esd label
+       Int_t nlabel = label; // new label
+       if (label < 0) continue;
+       if (label >= AliMCEvent::BgLabelOffset()) nlabel =  mcEvent->BgLabelToIndex(label);
+       if(nlabel > np || label == 0) {
+         AliWarning(Form("Wrong TOF label %5d (%5d)", label, nlabel));
+       }
+       if(fMCEventH->GetNewLabel(label) == 0){
+         AliWarning(Form("New TOF label not found for %5d",label ));
+       }
+       tofLabel[i] = fMCEventH->GetNewLabel(label);
+      } 
+      track->SetTOFLabel(tofLabel);
     }
   }
   

diff --git a/STEER/AOD/AliAODTrack.cxx b/STEER/AOD/AliAODTrack.cxx
index cddaff2ee2a842b16204af553990fb1e105e5f37..11de9d15700c03473efe72e07c46a68681c82775 100644 (file)
--- a/STEER/AOD/AliAODTrack.cxx
+++ b/STEER/AOD/AliAODTrack.cxx
@@ -41,6 +41,7 @@ AliAODTrack::AliAODTrack() :
   fChi2MatchTrigger(0.),
   fFlags(0),
   fLabel(-999),
+  fTOFLabel(),
   fITSMuonClusterMap(0),
   fMUONtrigHitsMapTrg(0),
   fMUONtrigHitsMapTrk(0),
@@ -61,6 +62,7 @@ AliAODTrack::AliAODTrack() :
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTPCsignalTuned(0),
+  fTOFsignalTuned(99999),
   fAODEvent(NULL)
 {
   // default constructor
@@ -70,6 +72,7 @@ AliAODTrack::AliAODTrack() :
   SetXYAtDCA(-999., -999.);
   SetPxPyPzAtDCA(-999., -999., -999.);
   SetPID((Float_t*)NULL);
+  for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = -1;}
 }
 
 //______________________________________________________________________________
@@ -95,6 +98,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   fChi2MatchTrigger(0.),
   fFlags(0),
   fLabel(label),
+  fTOFLabel(),
   fITSMuonClusterMap(0),
   fMUONtrigHitsMapTrg(0),
   fMUONtrigHitsMapTrk(0),
@@ -115,6 +119,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTPCsignalTuned(0),
+  fTOFsignalTuned(99999),
   fAODEvent(NULL)
 {
   // constructor
@@ -128,6 +133,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   if(covMatrix) SetCovMatrix(covMatrix);
   SetPID(pid);
   SetITSClusterMap(itsClusMap);
+  for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
 }
 
 //______________________________________________________________________________
@@ -153,6 +159,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   fChi2MatchTrigger(0.),
   fFlags(0),
   fLabel(label),
+  fTOFLabel(),
   fITSMuonClusterMap(0),
   fMUONtrigHitsMapTrg(0),
   fMUONtrigHitsMapTrk(0),
@@ -173,6 +180,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTPCsignalTuned(0),
+  fTOFsignalTuned(99999),
   fAODEvent(NULL)
 {
   // constructor
@@ -186,6 +194,7 @@ AliAODTrack::AliAODTrack(Short_t id,
   if(covMatrix) SetCovMatrix(covMatrix);
   SetPID(pid);
   SetITSClusterMap(itsClusMap);
+  for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
 }
 
 //______________________________________________________________________________
@@ -206,6 +215,7 @@ AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
   fChi2MatchTrigger(trk.fChi2MatchTrigger),
   fFlags(trk.fFlags),
   fLabel(trk.fLabel),
+  fTOFLabel(),
   fITSMuonClusterMap(trk.fITSMuonClusterMap),
   fMUONtrigHitsMapTrg(trk.fMUONtrigHitsMapTrg),
   fMUONtrigHitsMapTrk(trk.fMUONtrigHitsMapTrk),
@@ -226,6 +236,7 @@ AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
   fTrackPhiOnEMCal(trk.fTrackPhiOnEMCal),
   fTrackEtaOnEMCal(trk.fTrackEtaOnEMCal),
   fTPCsignalTuned(trk.fTPCsignalTuned),
+  fTOFsignalTuned(trk.fTOFsignalTuned),
   fAODEvent(trk.fAODEvent)
 {
   // Copy constructor
@@ -240,6 +251,7 @@ AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
   if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
   SetPID(trk.fPID);
   if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
+  for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}  
 }
 
 //______________________________________________________________________________
@@ -276,6 +288,7 @@ AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
     fTrackPhiOnEMCal   = trk.fTrackPhiOnEMCal;
     fTrackEtaOnEMCal   = trk.fTrackEtaOnEMCal;
     fTPCsignalTuned    = trk.fTPCsignalTuned;
+    fTOFsignalTuned    = trk.fTOFsignalTuned;
 
     delete fCovMatrix;
     if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
@@ -295,6 +308,7 @@ AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
     delete fDetectorPID;
     fDetectorPID=0x0;
     if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
+    for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}  
   }
 
   return *this;
@@ -402,6 +416,17 @@ Double_t AliAODTrack::Y(Double_t m) const
   }
 }
 
+void AliAODTrack::SetTOFLabel(const Int_t *p) {  
+  // Sets  (in TOF)
+  for (Int_t i = 0; i < 3; i++) fTOFLabel[i]=p[i];
+}
+
+//_______________________________________________________________________
+void AliAODTrack::GetTOFLabel(Int_t *p) const {
+  // Gets (in TOF)
+  for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
+}
+
 //______________________________________________________________________________
 AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const 
 {

diff --git a/STEER/AOD/AliAODTrack.h b/STEER/AOD/AliAODTrack.h
index d429f41ab04c63de0a0682c278cefccc20d62fa0..98d7d40d2b0bf08e7ed23742fe673de1d54845a9 100644 (file)
--- a/STEER/AOD/AliAODTrack.h
+++ b/STEER/AOD/AliAODTrack.h
@@ -127,12 +127,20 @@ class AliAODTrack : public AliVTrack {
   virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
 
   Double_t Chi2perNDF()  const { return fChi2perNDF; }
-  UShort_t GetTPCNcls()  const { 
-    UShort_t cl = fTPCFitMap.CountBits();
-    if(cl==0)cl = fTPCClusterMap.CountBits();// backward compatibility
+
+  UShort_t GetTPCnclsS(Int_t i0=0,Int_t i1=159)  const { 
+    UShort_t cl = fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
     return cl;
   }
   
+  UShort_t GetTPCncls(Int_t i0=0,Int_t i1=159)  const { 
+    UShort_t cl = fTPCFitMap.CountBits(i0)-fTPCFitMap.CountBits(i1);
+    if(cl==0)cl = fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);// backward compatibility
+    return cl;
+  }
+  
+  UShort_t GetTPCNcls()  const { return GetTPCncls(); }
+
   virtual Double_t M() const { return M(GetMostProbablePID()); }
   Double_t M(AODTrkPID_t pid) const;
   virtual Double_t E() const { return E(GetMostProbablePID()); }
@@ -168,6 +176,9 @@ class AliAODTrack : public AliVTrack {
 
   Int_t   GetID() const { return (Int_t)fID; }
   Int_t   GetLabel() const { return fLabel; } 
+  void    GetTOFLabel(Int_t *p) const;
+
+
   Char_t  GetType() const { return fType;}
   Bool_t  IsPrimaryCandidate() const;
   Bool_t  GetUsedForVtxFit() const { return TestBit(kUsedForVtxFit); }
@@ -284,6 +295,8 @@ class AliAODTrack : public AliVTrack {
   virtual AliTPCdEdxInfo* GetTPCdEdxInfo() const {return fDetPid?fDetPid->GetTPCdEdxInfo():0;}
   Double_t  GetTPCmomentum()     const { return fDetPid?fDetPid->GetTPCmomentum():0.;  }
   Double_t  GetTOFsignal()       const { return fDetPid?fDetPid->GetTOFsignal():0.;    }
+  Double_t  GetTOFsignalTunedOnData() const { return fTOFsignalTuned;}
+  void      SetTOFsignalTunedOnData(Double_t signal) {fTOFsignalTuned = signal;}
   Double_t  GetHMPIDsignal()     const; 
   Double_t  GetHMPIDoccupancy()  const;
 
@@ -321,7 +334,7 @@ class AliAODTrack : public AliVTrack {
 
   void SetID(Short_t id) { fID = id; }
   void SetLabel(Int_t label) { fLabel = label; }
-
+  void SetTOFLabel(const Int_t* p);
   template <typename T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
   void SetDCA(Double_t d, Double_t z);
   void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
@@ -406,7 +419,7 @@ class AliAODTrack : public AliVTrack {
 
   ULong_t       fFlags;             // reconstruction status flags 
   Int_t         fLabel;             // track label, points back to MC track
-  
+  Int_t         fTOFLabel[3];       // TOF label   
   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32) 
   UInt_t        fMUONtrigHitsMapTrg; // Muon trigger hits map from trigger
@@ -437,10 +450,11 @@ class AliAODTrack : public AliVTrack {
   Double_t      fTrackEtaOnEMCal;   // eta of track after being propagated to 430cm
 
   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
+  Double_t      fTOFsignalTuned;    //! TOF signal tuned on data when using MC
 
   const AliAODEvent* fAODEvent;     //! 
 
-  ClassDef(AliAODTrack, 19);
+  ClassDef(AliAODTrack, 20);
 };
 
 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const

diff --git a/STEER/AOD/AliAODpidUtil.cxx b/STEER/AOD/AliAODpidUtil.cxx
index 7e160fa5903847b450a17c0b50b2d3cae62b4355..f5d31fb1bc556a40d8cea3e5c3c961fe0945bffe 100644 (file)
--- a/STEER/AOD/AliAODpidUtil.cxx
+++ b/STEER/AOD/AliAODpidUtil.cxx
@@ -103,6 +103,17 @@ Float_t AliAODpidUtil::GetTPCsignalTunedOnData(const AliVTrack *t) const {
     track->SetTPCsignalTunedOnData(dedx);
     return dedx;
 }
+//_________________________________________________________________________
+Float_t AliAODpidUtil::GetTOFsignalTunedOnData(const AliVTrack *t) const {
+    AliAODTrack *track = (AliAODTrack *) t;
+    Double_t tofSignal = track->GetTOFsignalTunedOnData();
+
+    if(tofSignal <  99999) return (Float_t)tofSignal; // it has been already set
+    AliAODPid *pidObj = track->GetDetPid();
+    tofSignal = pidObj->GetTOFsignal() + fTOFResponse.GetTailRandomValue();
+    track->SetTOFsignalTunedOnData(tofSignal);
+    return (Float_t)tofSignal;
+}
 
 //_________________________________________________________________________
 Float_t AliAODpidUtil::GetSignalDeltaTOFold(const AliVParticle *vtrack, AliPID::EParticleType type, Bool_t ratio/*=kFALSE*/) const
@@ -112,10 +123,11 @@ Float_t AliAODpidUtil::GetSignalDeltaTOFold(const AliVParticle *vtrack, AliPID::
   //
   
   AliAODTrack *track=(AliAODTrack*)vtrack;
-  
   AliAODPid *pidObj = track->GetDetPid();
   if (!pidObj) return -9999.;
-  Double_t tofTime=pidObj->GetTOFsignal();
+  Double_t tofTime = 99999;
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
+  else tofTime=pidObj->GetTOFsignal();
   const Double_t expTime=fTOFResponse.GetExpectedSignal((AliVTrack*)vtrack,type);
   Double_t sigmaTOFPid[AliPID::kSPECIES];
   pidObj->GetTOFpidResolution(sigmaTOFPid);
@@ -151,7 +163,9 @@ Float_t AliAODpidUtil::GetNumberOfSigmasTOFold(const AliVParticle *vtrack, AliPI
   Double_t sigTOF=0.;
   AliAODPid *pidObj = track->GetDetPid();
   if (!pidObj) return -999.;
-  Double_t tofTime=pidObj->GetTOFsignal();
+  Double_t tofTime = 99999;
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
+  else tofTime=pidObj->GetTOFsignal();
   Double_t expTime=fTOFResponse.GetExpectedSignal((AliVTrack*)vtrack,type);
   Double_t sigmaTOFPid[AliPID::kSPECIES];
   pidObj->GetTOFpidResolution(sigmaTOFPid);

diff --git a/STEER/AOD/AliAODpidUtil.h b/STEER/AOD/AliAODpidUtil.h
index a212ae7a34419037681b12ee560c73452b7703c2..db765c54cf3f65c9bfa56e6201eada7c52d9385d 100644 (file)
--- a/STEER/AOD/AliAODpidUtil.h
+++ b/STEER/AOD/AliAODpidUtil.h
@@ -34,6 +34,7 @@ public:
 
 
   Float_t GetTPCsignalTunedOnData(const AliVTrack *t) const;
+  Float_t GetTOFsignalTunedOnData(const AliVTrack *t) const;
 
 protected:
   virtual Float_t GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio=kFALSE) const;

diff --git a/STEER/ESD/AliESDCaloCluster.h b/STEER/ESD/AliESDCaloCluster.h
index eed1737b7222ac7e59a9cdce3305000d7c7d686f..1fe02e2d2994234b47933086d8d8c1cf7c1f5b87 100644 (file)
--- a/STEER/ESD/AliESDCaloCluster.h
+++ b/STEER/ESD/AliESDCaloCluster.h
@@ -92,10 +92,16 @@ class AliESDCaloCluster : public AliVCluster
     else *fTracksMatched = array;
   }
   void AddLabels(TArrayI & array)         { 
-    if(!fLabels)fLabels = new TArrayI(array) ; 
+    if(!fLabels)fLabels = new TArrayI(array) ;
     else *fLabels = array;
   }
   
+  void SetLabel(Int_t *array, UInt_t size)
+  {
+    if(fLabels) delete fLabels ;
+    fLabels = new TArrayI(size,array);
+  }
+
   TArrayI * GetTracksMatched() const  {return  fTracksMatched;}
   TArrayI * GetLabelsArray() const    {return  fLabels;}
   Int_t   * GetLabels() const         {if (fLabels) return  fLabels->GetArray(); else return 0;}

diff --git a/STEER/ESD/AliESDpid.cxx b/STEER/ESD/AliESDpid.cxx
index 584e1e76928e6fbf9d0facee1a9e76b84ba49076..7c39219f931d42c3477bde28c942f8108fb7c15d 100644 (file)
--- a/STEER/ESD/AliESDpid.cxx
+++ b/STEER/ESD/AliESDpid.cxx
@@ -135,6 +135,17 @@ Float_t AliESDpid::GetTPCsignalTunedOnData(const AliVTrack *t) const {
     return dedx;
 }
 //_________________________________________________________________________
+Float_t AliESDpid::GetTOFsignalTunedOnData(const AliVTrack *t) const {
+    AliESDtrack *track = (AliESDtrack *) t;
+    Double_t tofSignal = track->GetTOFsignalTunedOnData();
+
+    if(tofSignal <  99999) return (Float_t)tofSignal; // it has been already set
+
+    tofSignal = t->GetTOFsignal() + fTOFResponse.GetTailRandomValue();
+    track->SetTOFsignalTunedOnData(tofSignal);
+    return (Float_t)tofSignal;
+}
+//_________________________________________________________________________
 void AliESDpid::MakeTPCPID(AliESDtrack *track) const
 {
   //
@@ -419,7 +430,10 @@ Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EPart
   AliVTrack *vtrack=(AliVTrack*)track;
   
   const Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
-  const Double_t tofTime=vtrack->GetTOFsignal() - fTOFResponse.GetStartTime(vtrack->P());
+  Double_t tofTime = 99999;
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
+  else tofTime=vtrack->GetTOFsignal();
+  tofTime = tofTime  - fTOFResponse.GetStartTime(vtrack->P());
   Double_t delta=-9999.;
 
   if (!ratio) delta=tofTime-expTime;
@@ -436,7 +450,10 @@ Float_t AliESDpid::GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EP
   //
 
   AliVTrack *vtrack=(AliVTrack*)track;
+  Double_t tofTime = 99999;
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
+  else tofTime=vtrack->GetTOFsignal();
   
   Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
-  return (vtrack->GetTOFsignal() - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
+  return (tofTime - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
 }

diff --git a/STEER/ESD/AliESDpid.h b/STEER/ESD/AliESDpid.h
index cce9f15790083424db5c8a2a0f6949104b429c35..414649f9eaaa8d87d78fcb70de42655ed3ce1dce 100644 (file)
--- a/STEER/ESD/AliESDpid.h
+++ b/STEER/ESD/AliESDpid.h
@@ -47,6 +47,7 @@ AliESDpid(const AliESDpid&a): AliPIDResponse(a), fRangeTOFMismatch(a.fRangeTOFMi
   Float_t GetNMaxSigmaTOFTPCMismatch() const {return fRangeTOFMismatch;}
 
   Float_t GetTPCsignalTunedOnData(const AliVTrack *t) const;
+  Float_t GetTOFsignalTunedOnData(const AliVTrack *t) const;
 
   void SetEventHandler(AliVEventHandler *event){fEventHandler=event;};
 protected:

diff --git a/STEER/ESD/AliESDtrack.cxx b/STEER/ESD/AliESDtrack.cxx
index c876213d1050dbd42b96aed21b396309345b998d..82ea2cb4c48da159e733ffc3f01ed6bda890d89f 100644 (file)
--- a/STEER/ESD/AliESDtrack.cxx
+++ b/STEER/ESD/AliESDtrack.cxx
@@ -208,6 +208,7 @@ AliESDtrack::AliESDtrack() :
   fTRDQuality(0),
   fTRDBudget(0),
   fTOFsignal(99999),
+  fTOFsignalTuned(99999),
   fTOFsignalToT(99999),
   fTOFsignalRaw(99999),
   fTOFsignalDz(999),
@@ -324,6 +325,7 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fTRDQuality(track.fTRDQuality),
   fTRDBudget(track.fTRDBudget),
   fTOFsignal(track.fTOFsignal),
+  fTOFsignalTuned(track.fTOFsignalTuned),
   fTOFsignalToT(track.fTOFsignalToT),
   fTOFsignalRaw(track.fTOFsignalRaw),
   fTOFsignalDz(track.fTOFsignalDz),
@@ -453,6 +455,7 @@ AliESDtrack::AliESDtrack(const AliVTrack *track) :
   fTRDQuality(0),
   fTRDBudget(0),
   fTOFsignal(99999),
+  fTOFsignalTuned(99999),
   fTOFsignalToT(99999),
   fTOFsignalRaw(99999),
   fTOFsignalDz(999),
@@ -642,6 +645,7 @@ AliESDtrack::AliESDtrack(TParticle * part) :
   fTRDQuality(0),
   fTRDBudget(0),
   fTOFsignal(99999),
+  fTOFsignalTuned(99999),
   fTOFsignalToT(99999),
   fTOFsignalRaw(99999),
   fTOFsignalDz(999),
@@ -993,6 +997,7 @@ AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
   fTRDQuality =   source.fTRDQuality;     
   fTRDBudget  =   source.fTRDBudget;      
   fTOFsignal  =   source.fTOFsignal;     
+  fTOFsignalTuned  = source.fTOFsignalTuned;
   fTOFsignalToT = source.fTOFsignalToT;   
   fTOFsignalRaw = source.fTOFsignalRaw;  
   fTOFsignalDz  = source.fTOFsignalDz;      

diff --git a/STEER/ESD/AliESDtrack.h b/STEER/ESD/AliESDtrack.h
index 68177e834baa055da2eef215a17d7664d427ceab..15fa5d3a02f7130266eeba9064494b87e049cd8b 100644 (file)
--- a/STEER/ESD/AliESDtrack.h
+++ b/STEER/ESD/AliESDtrack.h
@@ -325,6 +325,8 @@ public:
   Int_t   GetTOFcluster() const {return fTOFindex;}
   void    SetTOFcluster(Int_t index) {fTOFindex=index;}
   void    SetTOFCalChannel(Int_t index) {fTOFCalChannel=index;}
+  void    SetTOFsignalTunedOnData(Double_t signal){fTOFsignalTuned=signal;}
+  Double_t GetTOFsignalTunedOnData() const {return fTOFsignalTuned;}
 
 // HMPID methodes +++++++++++++++++++++++++++++++++ (kir)
   void    SetHMPIDsignal(Double_t theta) {fHMPIDsignal=theta;}
@@ -498,6 +500,7 @@ protected:
   Double32_t fTRDBudget;      // trd material budget
 
   Double32_t fTOFsignal;      // detector's PID signal
+  Double32_t fTOFsignalTuned; //! detector's PID signal tuned on data when using MC
   Double32_t fTOFsignalToT;   // detector's ToT signal
   Double32_t fTOFsignalRaw;   // detector's uncorrected time signal
   Double32_t fTOFsignalDz;    // local z  of track's impact on the TOF pad 
@@ -550,7 +553,7 @@ protected:
   static bool fgkOnlineMode; //! indicate the online mode to skip some of the functionality
 
   AliESDtrack & operator=(const AliESDtrack & );
-  ClassDef(AliESDtrack,66)  //ESDtrack 
+  ClassDef(AliESDtrack,67)  //ESDtrack 
 };
 
 

diff --git a/STEER/STEERBase/AliPIDResponse.cxx b/STEER/STEERBase/AliPIDResponse.cxx
index 345b294299cb4f1fe2f01ac7610e1193ea9d47f5..df92c4fd6fcde1b049926347d830ff8d352b626c 100644 (file)
--- a/STEER/STEERBase/AliPIDResponse.cxx
+++ b/STEER/STEERBase/AliPIDResponse.cxx
@@ -87,7 +87,8 @@ fHMPIDPIDParams(NULL),
 fEMCALPIDParams(NULL),
 fCurrentEvent(NULL),
 fCurrCentrality(0.0),
-fTuneMConData(kFALSE)
+fTuneMConData(kFALSE),
+fTuneMConDataMask(kDetTOF|kDetTPC)
 {
   //
   // default ctor
@@ -147,7 +148,8 @@ fHMPIDPIDParams(NULL),
 fEMCALPIDParams(NULL),
 fCurrentEvent(NULL),
 fCurrCentrality(0.0),
-fTuneMConData(kFALSE)
+fTuneMConData(kFALSE),
+fTuneMConDataMask(kDetTOF|kDetTPC)
 {
   //
   // copy ctor
@@ -891,7 +893,7 @@ void AliPIDResponse::SetTPCEtaMaps(Double_t refineFactorMapX, Double_t refineFac
   }
 
   Int_t recopass = fRecoPass;
-  if (fTuneMConData)
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) )
     recopass = fRecoPassUser;
   
   TString defaultObj = Form("Default_%s_pass%d", dataType.Data(), recopass);
@@ -1097,7 +1099,7 @@ void AliPIDResponse::SetTPCParametrisation()
   if (fIsMC && !fTuneMConData) period=fMCperiodTPC;
 
   Int_t recopass = fRecoPass;
-  if(fTuneMConData) recopass = fRecoPassUser;
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) recopass = fRecoPassUser;
     
   AliInfo(Form("Searching splines for: %s %s PASS%d %s",datatype.Data(),period.Data(),recopass,fBeamType.Data()));
   Bool_t found=kFALSE;
@@ -1802,8 +1804,7 @@ Float_t AliPIDResponse::GetNumberOfSigmasTPC(const AliVParticle *vtrack, AliPID:
   // 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);
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) this->GetTPCsignalTunedOnData(track);
   
   return fTPCResponse.GetNumberOfSigmas(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
 }
@@ -1884,7 +1885,7 @@ AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTPC(const AliVPartic
   // 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)
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) 
     this->GetTPCsignalTunedOnData(track);
   
   val=fTPCResponse.GetSignalDelta(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, ratio);
@@ -1900,7 +1901,6 @@ AliPIDResponse::EDetPidStatus AliPIDResponse::GetSignalDeltaTOF(const AliVPartic
   //
   AliVTrack *track=(AliVTrack*)vtrack;
   val=GetSignalDeltaTOFold(track, type, ratio);
-  
   return GetTOFPIDStatus(track);
 }
 
@@ -2004,7 +2004,7 @@ AliPIDResponse::EDetPidStatus AliPIDResponse::GetComputeTPCProbability  (const A
   Double_t dedx=track->GetTPCsignal();
   Bool_t mismatch=kTRUE/*, heavy=kTRUE*/;
   
-  if(fTuneMConData) dedx = this->GetTPCsignalTunedOnData(track);
+  if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) dedx = this->GetTPCsignalTunedOnData(track);
   
   Double_t bethe = 0.;
   Double_t sigma = 0.;

diff --git a/STEER/STEERBase/AliPIDResponse.h b/STEER/STEERBase/AliPIDResponse.h
index b9820e4eb7aa01318511662829d62e9e1a6c035a..97cbe5d85daba66ff6258f62cbeb12be3eda8af4 100644 (file)
--- a/STEER/STEERBase/AliPIDResponse.h
+++ b/STEER/STEERBase/AliPIDResponse.h
@@ -155,8 +155,11 @@ public:
   void SetTOFResponse(AliVEvent *vevent,EStartTimeType_t option);
 
   virtual Float_t GetTPCsignalTunedOnData(const AliVTrack *t) const {return t->GetTPCsignal();};
+  virtual Float_t GetTOFsignalTunedOnData(const AliVTrack *t) const {return t->GetTOFsignal();};
   Bool_t IsTunedOnData() const {return fTuneMConData;};
   void SetTunedOnData(Bool_t flag=kTRUE,Int_t recoPass=0){fTuneMConData = flag; if(recoPass>0) fRecoPassUser = recoPass;};
+  Int_t GetTunedOnDataMask() const {return fTuneMConDataMask;};
+  void SetTunedOnDataMask(Int_t detMask) {fTuneMConDataMask = detMask;}
 
   AliPIDResponse(const AliPIDResponse &other);
   AliPIDResponse& operator=(const AliPIDResponse &other);
@@ -180,6 +183,10 @@ protected:
   EDetPidStatus GetComputeTRDProbability  (const AliVTrack *track, Int_t nSpecies, Double_t p[],AliTRDPIDResponse::ETRDPIDMethod PIDmethod=AliTRDPIDResponse::kLQ1D) const;
   EDetPidStatus GetTOFPIDStatus(const AliVTrack *track) const;
 
+  Bool_t fTuneMConData;                // switch to force the MC to be similar to data
+  Int_t fTuneMConDataMask;             // select for which detectors enable MC tuning on data
+
+
 private:
   Bool_t fIsMC;                        //  If we run on MC data
   Bool_t fCachePID;
@@ -218,7 +225,6 @@ private:
 
   Float_t fCurrCentrality;             //! current centrality
   
-  Bool_t fTuneMConData;                // switch to force the MC to be similar to data (dE/dx)
   
   void ExecNewRun();
   

diff --git a/STEER/STEERBase/AliTOFPIDResponse.cxx b/STEER/STEERBase/AliTOFPIDResponse.cxx
index cc32e09242df5ee09f420f75be87ea9d4ebcc83f..bafccabe68dd9d8e5e6bf1156707715f91323dbd 100644 (file)
--- a/STEER/STEERBase/AliTOFPIDResponse.cxx
+++ b/STEER/STEERBase/AliTOFPIDResponse.cxx
@@ -22,11 +22,14 @@
 
 #include "TMath.h"
 #include "AliLog.h"
+#include "TF1.h"
 
 #include "AliTOFPIDResponse.h"
 
 ClassImp(AliTOFPIDResponse)
 
+TF1 *AliTOFPIDResponse::fTOFtailResponse = NULL; // function to generate a TOF tail
+
 //_________________________________________________________________________
 AliTOFPIDResponse::AliTOFPIDResponse(): 
   fSigma(0),
@@ -38,6 +41,16 @@ AliTOFPIDResponse::AliTOFPIDResponse():
   fPar[2] = 0.002;
   fPar[3] = 40.0;
 
+  if(!fTOFtailResponse){
+    fTOFtailResponse = new TF1("fTOFtail","[0]*TMath::Exp(-(x-[1])*(x-[1])/2/[2]/[2])* (x < [1]+[3]*[2]) + (x > [1]+[3]*[2])*[0]*TMath::Exp(-(x-[1]-[3]*[2]*0.5)*[3]/[2] * 0.0111)*0.01818",-1000,1000);
+    fTOFtailResponse->SetParameter(0,1);
+    fTOFtailResponse->SetParameter(1,-25);
+    fTOFtailResponse->SetParameter(2,1);
+    fTOFtailResponse->SetParameter(3,1.1);
+    fTOFtailResponse->SetNpx(10000);
+  }
+    
+
   // Reset T0 info
   ResetT0info();
   SetMomBoundary();
@@ -194,3 +207,11 @@ Int_t AliTOFPIDResponse::GetStartTimeMask(Float_t mom) const {
   return GetT0binMask(ibin);
 
 }
+//_________________________________________________________________________
+Double_t AliTOFPIDResponse::GetTailRandomValue() const // generate a random value to add a tail to TOF time (for MC analyses)
+{
+  if(fTOFtailResponse)
+    return fTOFtailResponse->GetRandom();
+  else
+    return 0.0;
+}

diff --git a/STEER/STEERBase/AliTOFPIDResponse.h b/STEER/STEERBase/AliTOFPIDResponse.h
index 4648cb6aa3063b24afbdaaf61dd746fa0592e840..6e7cdd21116be954feadfaa168ea161c8631c909 100644 (file)
--- a/STEER/STEERBase/AliTOFPIDResponse.h
+++ b/STEER/STEERBase/AliTOFPIDResponse.h
@@ -15,6 +15,7 @@
 #include "AliVTrack.h"
 
 class AliTOFPIDParams;
+class TF1;
 
 class AliTOFPIDResponse : public TObject {
 public:
@@ -36,6 +37,8 @@ public:
 
   Double_t GetMismatchProbability(Double_t p,Double_t mass) const;
 
+  Double_t GetTailRandomValue() const; // generate a random value to add a tail to TOF time (for MC analyses)
+
   void     SetT0event(Float_t *t0event){for(Int_t i=0;i < fNmomBins;i++) fT0event[i] = t0event[i];};
   void     SetT0resolution(Float_t *t0resolution){for(Int_t i=0;i < fNmomBins;i++) fT0resolution[i] = t0resolution[i];};
   void     ResetT0info(){ for(Int_t i=0;i < fNmomBins;i++){ fT0event[i] = 0.0; fT0resolution[i] = 0.0; fMaskT0[i] = 0;} };
@@ -76,7 +79,9 @@ public:
   Int_t fMaskT0[fNmomBins]; // mask withthe T0 used (0x1=T0-TOF,0x2=T0A,0x3=TOC) for p bins
   Float_t fPar[4]; // parameter for expected times resolution
 
-  ClassDef(AliTOFPIDResponse,4)   // TOF PID class
+  static TF1 *fTOFtailResponse; // function to generate a TOF tail
+
+  ClassDef(AliTOFPIDResponse,5)   // TOF PID class
 };
 
 #endif

diff --git a/STEER/STEERBase/AliVTrack.h b/STEER/STEERBase/AliVTrack.h
index c954912a24df53af9216b4f41276a3fbad8e8251..711c0f67e337d9c4649447bedd4d4d4fbaafe2ff 100644 (file)
--- a/STEER/STEERBase/AliVTrack.h
+++ b/STEER/STEERBase/AliVTrack.h
@@ -91,6 +91,7 @@ public:
   virtual UShort_t  GetTPCsignalN()      const {return 0 ;}
   virtual Double_t  GetTPCmomentum()     const {return 0.;}
   virtual Double_t  GetTOFsignal()       const {return 0.;}
+  virtual Double_t  GetTOFsignalTunedOnData() const {return 0.;}
   virtual Double_t  GetHMPIDsignal()     const {return 0.;}
   virtual Double_t  GetTRDsignal()       const {return 0.;}