Updated AOD cuts according to help given in FAQ. Corrected the computation of dip...

diff --git a/PWG2/RESONANCES/AliRsnCutAOD2010.cxx b/PWG2/RESONANCES/AliRsnCutAOD2010.cxx
index 2b88bf89d8b1a8339441973efa88388cfd90e992..238035895c879cd07e669dcfe60cbbfecb099393 100644 (file)
--- a/PWG2/RESONANCES/AliRsnCutAOD2010.cxx
+++ b/PWG2/RESONANCES/AliRsnCutAOD2010.cxx
@@ -29,47 +29,9 @@
 
 ClassImp(AliRsnCutAOD2010)
 
-//_________________________________________________________________________________________________
-AliRsnCutAOD2010::AliRsnCutAOD2010() :
-  AliRsnCut(AliRsnCut::kDaughter),
-  
-  fIsMC(kFALSE),
-  fCheckITS(kTRUE),
-  fCheckTPC(kTRUE),
-  fCheckTOF(kTRUE),
-  fUseGlobal(kTRUE),
-  fUseITSSA(kTRUE),
-    
-  fPIDtype(AliPID::kKaon),
-  
-  fTPCminNclusters(70),
-  fTPCmaxChi2(4.0),
-  fTPCmaxNSigmaDCA(7.0),
-  fTPClowBand(5.0),
-  fTPChighBand(3.0),
-  fTPClowLimit(0.35),
-  
-  fITSminNclusters(4),
-  fITSmaxChi2(2.5),
-  fITSmaxNSigmaDCA(7.0),
-  fITSband(3.0),
-  
-  fTOFlowLimit(-2.5),
-  fTOFhighLimit(3.5),
-  fPID()
-{
-//
-// Default constructor.
-//
-  
-  Int_t i = 0;
-  for (i = 0; i < 3; i++) fTPCparamDCA[i] = fITSparamDCA[i] = 0.0;
-  for (i = 0; i < 5; i++) fTPCparamBB[i] = 0.0;
-}
 
 //_________________________________________________________________________________________________
-AliRsnCutAOD2010::AliRsnCutAOD2010
-(const char *name) :
+AliRsnCutAOD2010::AliRsnCutAOD2010(const char *name, Bool_t isMC) :
   AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
 
   fIsMC(kFALSE),
@@ -78,6 +40,8 @@ AliRsnCutAOD2010::AliRsnCutAOD2010
   fCheckTOF(kTRUE),
   fUseGlobal(kTRUE),
   fUseITSSA(kTRUE),
+  
+  fMaxEta(1E6),
     
   fPIDtype(AliPID::kKaon),
   
@@ -95,15 +59,24 @@ AliRsnCutAOD2010::AliRsnCutAOD2010
   
   fTOFlowLimit(-2.5),
   fTOFhighLimit(3.5),
+  
   fPID()
 {
 //
-// Main constructor.
+// Default constructor.
+// Sets all parameters to the currently used values, and requires
+// to know if we are running on data or MonteCarlo to set some others.
 //
 
-  Int_t i = 0;
-  for (i = 0; i < 3; i++) fTPCparamDCA[i] = fITSparamDCA[i] = 0.0;
-  for (i = 0; i < 5; i++) fTPCparamBB[i] = 0.0;
+  fTPCparamDCA[0] = 0.0050;
+  fTPCparamDCA[1] = 0.0070;
+  fTPCparamDCA[2] = 1.0000;
+  
+  fITSparamDCA[0] = 0.0085;
+  fITSparamDCA[1] = 0.0026;
+  fITSparamDCA[2] = 1.5500;
+  
+  SetMC(isMC);
 }
 
 //_________________________________________________________________________________________________
@@ -118,6 +91,8 @@ AliRsnCutAOD2010::AliRsnCutAOD2010
   fUseGlobal(copy.fUseGlobal),
   fUseITSSA(copy.fUseITSSA),
   
+  fMaxEta(copy.fMaxEta),
+  
   fPIDtype(copy.fPIDtype),
   
   fTPCminNclusters(copy.fTPCminNclusters),
@@ -134,6 +109,7 @@ AliRsnCutAOD2010::AliRsnCutAOD2010
   
   fTOFlowLimit(copy.fTOFlowLimit),
   fTOFhighLimit(copy.fTOFhighLimit),
+  
   fPID(copy.fPID)
 {
 //
@@ -146,7 +122,30 @@ AliRsnCutAOD2010::AliRsnCutAOD2010
     fTPCparamDCA[i] = copy.fTPCparamDCA[i];
     fITSparamDCA[i] = copy.fITSparamDCA[i];
   }
-  for (i = 0; i < 5; i++) fTPCparamBB[i] = copy.fTPCparamBB[i];
+}
+
+//_________________________________________________________________________________________________
+void AliRsnCutAOD2010::SetMC(Bool_t yn)
+{
+//
+// Sets some parameters depending on MC or dataanalysis
+//
+  
+  fIsMC = yn;
+  
+  if (fIsMC)
+  {
+    AliDebug(AliLog::kDebug + 2, "Setting for MC");
+    fPID.GetTPCResponse().SetBetheBlochParameters(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
+  }
+  else
+  {
+    AliDebug(AliLog::kDebug + 2, "Setting for DATA");
+    fPID.GetTPCResponse().SetBetheBlochParameters(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);
+  }
+  
+  AliITSPIDResponse itsrsp(fIsMC);
+  fPID.GetITSResponse() = itsrsp;
 }
 
 //_________________________________________________________________________________________________
@@ -174,40 +173,48 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
   }
 
   // step #1: check status flags and reject track if it does not match any possibility
-  Bool_t  isTPC   = track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kTPCrefit) && track->IsOn(AliESDtrack::kITSrefit);
-  Bool_t  isITSSA = !track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kITSrefit) && (!track->IsOn(AliESDtrack::kITSpureSA)) && track->IsOn(AliESDtrack::kITSpid);
-  Bool_t  isTOF   = track->IsOn(AliESDtrack::kTOFout) && track->IsOn(AliESDtrack::kTIME);
-  if (!isTPC && !isITSSA) 
+  Bool_t isTPC, isTOF;
+  if (!track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kITSrefit) && (!track->IsOn(AliESDtrack::kITSpureSA)))
   {
-    AliDebug(AliLog::kDebug + 2, "Track is not either a TPC track or a ITS standalone. Rejected");
-    return kFALSE;
+    isTPC = kFALSE;
+    isTOF = kFALSE;
+    if (!fUseITSSA)
+    {
+      AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
+      return kFALSE;
+    }
   }
-  else if (isTPC && !fUseGlobal)
+  else if (track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kTPCrefit) && track->IsOn(AliESDtrack::kITSrefit))
   {
-    AliDebug(AliLog::kDebug + 2, "Global tracks not used. Rejected");
-    return kFALSE;
+    isTPC = kTRUE;
+    if (!fUseGlobal)
+    {
+      AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
+      return kFALSE;
+    }
+    if (track->IsOn(AliESDtrack::kTOFout) && track->IsOn(AliESDtrack::kTIME))
+      isTOF = kTRUE;
+    else
+      isTOF = kFALSE;
   }
-  else if (isITSSA && !fUseITSSA)
+  else
   {
-    AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
+    AliDebug(AliLog::kDebug + 2, "Track is not either a TPC track or a ITS standalone. Rejected");
     return kFALSE;
   }
   
   // step #2: check number of clusters
-  Int_t count = 0;
   if (isTPC)
   {
-    count = track->GetTPCNcls();
-    if (count < fTPCminNclusters)
+    if (track->GetTPCNcls() < fTPCminNclusters)
     {
       AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
       return kFALSE;
     }
   }
-  else // then is ITS-SA
+  else
   {
-    count = track->GetITSNcls();
-    if (count < fITSminNclusters)
+    if (track->GetITSNcls() < fITSminNclusters)
     {
       AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
       return kFALSE;
@@ -236,7 +243,7 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
   AliAODVertex *vertex = track->GetProdVertex();
   if (isTPC && vertex != 0x0)
   {
-    if (vertex->GetType() == AliAODVertex::kKink && vertex->HasDaughter(track))
+    if (vertex->GetType() == AliAODVertex::kKink)
     {
       AliDebug(AliLog::kDebug + 2, "Kink daughter. Rejected");
       return kFALSE;
@@ -244,7 +251,19 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
   }
   
   // step #5: DCA cut (transverse)
-  Double_t sigmaDCA = 0.0, nsigma = 0.0;
+  Double_t dz[2], cov[3], sigmaDCA = 0.0, nsigma = 0.0;
+  vertex = fEvent->GetRefAOD()->GetPrimaryVertex();
+  if (!vertex)
+  {
+    AliDebug(AliLog::kDebug + 2, "NULL vertex");
+    return kFALSE;
+  }
+  if (!track->PropagateToDCA(vertex, fEvent->GetRefAOD()->GetMagneticField(), kVeryBig, dz, cov))
+  {
+    AliDebug(AliLog::kDebug + 2, "Failed propagation to vertex");
+    return kFALSE;
+  }
+  // compute the pt-dependent sigma
   if (isTPC)
   {
     sigmaDCA = fTPCparamDCA[0] + fTPCparamDCA[1] / TMath::Power(track->Pt(), fTPCparamDCA[2]);
@@ -255,45 +274,30 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
     sigmaDCA = fITSparamDCA[0] + fITSparamDCA[1] / TMath::Power(track->Pt(), fITSparamDCA[2]);
     nsigma = fITSmaxNSigmaDCA;
   }
-  if (track->DCA() > nsigma * sigmaDCA)
+  // check the DCA
+  if (dz[0] > nsigma * sigmaDCA)
   {
     AliDebug(AliLog::kDebug + 2, "Excceeded cut in DCA. Rejected");
     return kFALSE;
   }
   
-  // step #6 PID cuts
-  Double_t bandTPC   = 0.0;
-  Double_t nsigmaTPC = 0.0;
-  Double_t nsigmaITS = 0.0;
-  Double_t nsigmaTOF = 0.0;
-  // initialize response functions
-  AliITSPIDResponse itsrsp(fIsMC);
-  fPID.GetTPCResponse().SetBetheBlochParameters(fTPCparamBB[0],fTPCparamBB[1],fTPCparamBB[2],fTPCparamBB[3],fTPCparamBB[4]);
-  fPID.GetITSResponse() = itsrsp;
-  if (isTPC)   nsigmaTPC = fPID.NumberOfSigmasTPC(track, fPIDtype);
-  if (isITSSA) nsigmaITS = fPID.NumberOfSigmasITS(track, fPIDtype);
-  if (isTOF)   nsigmaTOF = fPID.NumberOfSigmasTOF(track, fPIDtype);
-  if (isITSSA && fCheckITS)
+  // step #6: check eta range
+  if (TMath::Abs(track->Eta()) >= fMaxEta)
   {
-    if (nITS < 3) return kFALSE;
-    if (TMath::Abs(nsigmaITS) > fITSband)
-    {
-      AliDebug(AliLog::kDebug + 2, "Bad ITS PID. Rejected");
-      return kFALSE;
-    }
-    else
-    {
-      AliDebug(AliLog::kDebug + 2, "Good ITS PID. Accepted");
-      return kFALSE;
-    }
+    AliDebug(AliLog::kDebug + 2, "Outside ETA acceptance");
+    return kFALSE;
   }
-  else
+  
+  // step #7: PID cuts
+  if (isTPC)
   {
     if (fCheckTPC)
     {
-      AliAODPid *pidObj = track->GetDetPid();
-      Double_t   mom    = pidObj->GetTPCmomentum();
-      if (mom > fTPClowLimit) bandTPC = fTPChighBand; else bandTPC = fTPClowBand;
+      AliAODPid *pidObj    = track->GetDetPid();
+      Double_t   mom       = pidObj->GetTPCmomentum();
+      Double_t   nsigmaTPC = fPID.NumberOfSigmasTPC(track, fPIDtype);
+      Double_t   bandTPC   = fTPChighBand;
+      if (mom <= fTPClowLimit) bandTPC = fTPClowBand;
       if (TMath::Abs(nsigmaTPC) > bandTPC) 
       {
         AliDebug(AliLog::kDebug + 2, "Bad TPC PID. Rejected");
@@ -304,6 +308,7 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
         AliDebug(AliLog::kDebug + 2, "Good TPC PID");
         if (fCheckTOF && isTOF)
         {
+          Double_t nsigmaTOF = (Double_t)fPID.NumberOfSigmasTOF(track, fPIDtype);
           if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
           {
             AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
@@ -326,6 +331,7 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
     {
       if (fCheckTOF && isTOF)
       {
+        Double_t nsigmaTOF = (Double_t)fPID.NumberOfSigmasTOF(track, fPIDtype);
         if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
         {
           AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
@@ -344,6 +350,27 @@ Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
       }
     }
   }
-  
-  return kTRUE;
+  else
+  {
+    if (fCheckITS)
+    {
+      if (nITS < 3 || !track->IsOn(AliESDtrack::kITSpid)) return kFALSE;
+      Double_t nsigmaITS = (Double_t)fPID.NumberOfSigmasITS(track, fPIDtype);
+      if (TMath::Abs(nsigmaITS) > fITSband)
+      {
+        AliDebug(AliLog::kDebug + 2, "Bad ITS PID. Rejected");
+        return kFALSE;
+      }
+      else
+      {
+        AliDebug(AliLog::kDebug + 2, "Good ITS PID. Accepted");
+        return kFALSE;
+      }
+    }
+    else
+    {
+      AliDebug(AliLog::kDebug + 2, "No PID checked. Accepted");
+      return kTRUE;
+    }
+  }
 }

diff --git a/PWG2/RESONANCES/AliRsnCutAOD2010.h b/PWG2/RESONANCES/AliRsnCutAOD2010.h
index f8355d0c4e96a76927b01e27740ba37d94589d37..9e93800eb0ef9cde743d2e38b440309647f1df1e 100644 (file)
--- a/PWG2/RESONANCES/AliRsnCutAOD2010.h
+++ b/PWG2/RESONANCES/AliRsnCutAOD2010.h
@@ -22,26 +22,25 @@ class AliRsnCutAOD2010 : public AliRsnCut
 {
   public:
 
-    AliRsnCutAOD2010();
-    AliRsnCutAOD2010(const char *name);
+    AliRsnCutAOD2010(const char *name = "cutAOD2010", Bool_t isMC = kFALSE);
     AliRsnCutAOD2010(const AliRsnCutAOD2010& copy);
     virtual ~AliRsnCutAOD2010() {;};
 
     virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
     
-    void             SetMC       (Bool_t yn = kTRUE) {fIsMC = yn;}
+    void             SetMC       (Bool_t yn = kTRUE);
     void             SetCheckITS (Bool_t yn = kTRUE) {fCheckITS = yn;}
     void             SetCheckTPC (Bool_t yn = kTRUE) {fCheckTPC = yn;}
     void             SetCheckTOF (Bool_t yn = kTRUE) {fCheckTOF = yn;}
     void             SetUseGlobal(Bool_t yn = kTRUE) {fUseGlobal = yn;}
     void             SetUseITSSA (Bool_t yn = kTRUE) {fUseITSSA = yn;}
     void             SetPIDtype  (AliPID::EParticleType pid) {fPIDtype = pid;}
+    void             SetMaxEta   (Double_t eta) {fMaxEta = eta;}
     
     void             SetTPCminNclusters(Int_t v)         {fTPCminNclusters = v;}
     void             SetTPCmaxChi2(Double_t v)           {fTPCmaxChi2 = v;}     
     void             SetTPCmaxNSigmaDCA(Double_t v)      {fTPCmaxNSigmaDCA = v;}
     void             SetTPCparamDCA(Int_t i, Double_t v) {if (i >= 0 && i < 3) fTPCparamDCA[i] = v;} 
-    void             SetTPCparamBB(Int_t i, Double_t v)  {if (i >= 0 && i < 3) fTPCparamBB[i] = v;}  
     void             SetTPClowBand(Double_t v)           {fTPClowBand = v;}     
     void             SetTPChighBand(Double_t v)          {fTPChighBand = v;}    
     void             SetTPClowLimit(Double_t v)          {fTPClowLimit = v;}    
@@ -54,6 +53,8 @@ class AliRsnCutAOD2010 : public AliRsnCut
     void             SetITSband(Double_t v)              {fITSband = v;}    
 
     void             SetTOFrange(Double_t v1, Double_t v2) {fTOFlowLimit = v1; fTOFhighLimit = v2;}
+    
+    AliAODpidUtil*   GetPIDUtil() {return &fPID;}
 
   protected:
   
@@ -66,13 +67,14 @@ class AliRsnCutAOD2010 : public AliRsnCut
     Bool_t                fUseGlobal;        // switch to use TPC global tracks
     Bool_t                fUseITSSA;         // switch to use ITS standalone tracks
     
+    Double_t              fMaxEta;           // eta range for tracks
+    
     AliPID::EParticleType fPIDtype;          // particle type for which PID is checked   
     
     Int_t                 fTPCminNclusters;  // minimum number of clusters in TPC
     Double_t              fTPCmaxChi2;       // maximum chi2 / number of clusters in TPC
     Double_t              fTPCmaxNSigmaDCA;  // cut in DCA (transv) in numbers of sigma (pt-dependent)
     Double_t              fTPCparamDCA[3];   // parameters to compute sigma for DCA
-    Double_t              fTPCparamBB[5];    // parameters for TPC Bethe-Bloch parameterization
     Double_t              fTPClowBand;       // large band for low momentum PID
     Double_t              fTPChighBand;      // large band for low momentum PID
     Double_t              fTPClowLimit;      // limit of low momentum region

diff --git a/PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx b/PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
index c41847c21978e1dc5712a476f38018f44c6c1676..c6f22bfc6ea0c57d3e0eaa786cd21c867ed493d2 100644 (file)
--- a/PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
+++ b/PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
@@ -105,11 +105,13 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(TObject *obj1, TObject* /*obj2*/)
   }
   else if (aod)
   {
-    AliAODVertex *prim = aod->GetPrimaryVertex();
-    if (!prim || prim->GetNContributors() < 1) prim = aod->GetPrimaryVertexSPD();
-    if (!prim || prim->GetNContributors() < 1) return kFALSE;
+    // lines suggested by Andrea to reject TPC-only events
+    if(!aod->GetPrimaryVertexSPD()) return kFALSE;
+    if(!aod->GetPrimaryVertexSPD()->Status()) return kFALSE;
+    
+    AliAODVertex *prim = (AliAODVertex*)aod->GetPrimaryVertex();
     fCutValueI = prim->GetNContributors();
-    fCutValueD = prim->GetZ();
+    fCutValueD = prim->Zv();
   }
   else
     return kFALSE;

diff --git a/PWG2/RESONANCES/AliRsnCutStd.cxx b/PWG2/RESONANCES/AliRsnCutStd.cxx
index 6f26217199ff7153151a7ff27eea9dfc2e5c9ce4..06c3242a7f4e1c1a0212c0922b35adce1fc44960 100644 (file)
--- a/PWG2/RESONANCES/AliRsnCutStd.cxx
+++ b/PWG2/RESONANCES/AliRsnCutStd.cxx
@@ -243,11 +243,9 @@ Bool_t AliRsnCutStd::IsMotherSelected(AliRsnMother * const mother)
       fCutValueD = ref.Rapidity();
       return OkRange();
     case kDipAngle:
-      fCutValueD  = mother->GetDaughter(0)->P().Perp() * mother->GetDaughter(1)->P().Perp();
-      fCutValueD += mother->GetDaughter(0)->P().Pz() * mother->GetDaughter(1)->P().Pz();
-      fCutValueD += mother->GetDaughter(0)->P().Mag() * mother->GetDaughter(1)->P().Mag();
-      fCutValueD  = TMath::ACos(fCutValueD);
-      return OkRange();
+      fCutValueD = mother->GetDaughter(0)->P().Angle(mother->GetDaughter(1)->P().Vect());
+      fCutValueD = TMath::Abs(TMath::ACos(fCutValueD));
+      return OkRangeD();
     case kSameLabel:
       return mother->IsLabelEqual();
     default:

diff --git a/PWG2/RESONANCES/AliRsnValue.cxx b/PWG2/RESONANCES/AliRsnValue.cxx
index ceba9da58ccc6781c5fe80e1062218f53c88a848..6531fe4acd45a3d7adb53e702abbbe06f5e2d7f4 100644 (file)
--- a/PWG2/RESONANCES/AliRsnValue.cxx
+++ b/PWG2/RESONANCES/AliRsnValue.cxx
@@ -206,10 +206,8 @@ Bool_t AliRsnValue::Eval(AliRsnMother * const mother, AliRsnPairDef * const pair
       fValue /= TMath::Abs(mother->GetDaughter(0)->P().Perp() + mother->GetDaughter(1)->P().Perp());
       break;
     case kPairDipAngle:
-      fValue  = mother->GetDaughter(0)->P().Perp() * mother->GetDaughter(1)->P().Perp();
-      fValue += mother->GetDaughter(0)->P().Pz() * mother->GetDaughter(1)->P().Pz();
-      fValue += mother->GetDaughter(0)->P().Mag() * mother->GetDaughter(1)->P().Mag();
-      fValue  = TMath::ACos(fValue);
+      fValue = mother->GetDaughter(0)->P().Angle(mother->GetDaughter(1)->P().Vect());
+      fValue = TMath::Abs(TMath::ACos(fValue));
       break;
     case kPairCosThetaStar:
       fValue = mother->CosThetaStar();