delete constrained tracks for all filters
authorslindal <slindal@fys.uio.no>
Mon, 27 Jan 2014 02:38:01 +0000 (21:38 -0500)
committerslindal <slindal@fys.uio.no>
Mon, 27 Jan 2014 02:38:01 +0000 (21:38 -0500)
    updates to track cuts with tpc only track
    add trigger pt, track pt hist

     modified:   AliAnalysisTaskdPhi.cxx
     modified:   AliAnalysisTaskdPhi.h
     modified:   AliConversionTrackCuts.cxx
     modified:   AliConversionTrackCuts.h

PWGGA/GammaConv/AliAnalysisTaskdPhi.cxx
PWGGA/GammaConv/AliAnalysisTaskdPhi.h
PWGGA/GammaConv/AliConversionTrackCuts.cxx
PWGGA/GammaConv/AliConversionTrackCuts.h

index b88cad3..fc219c5 100644 (file)
@@ -68,6 +68,8 @@ AliAnalysisTaskdPhi::AliAnalysisTaskdPhi(const char *name) : AliAnalysisTaskSE(n
   fTracks(),
   hMEvents(NULL),
   hTrackCent(NULL),
+  hTrigPt(NULL),
+  hTrackPt(NULL),
   // fPhotonCorr(NULL),
   // fPionCorr(NULL), 
   fDeltaAODBranchName("AliAODGammaConversion_gamma"), 
@@ -311,10 +313,17 @@ void AliAnalysisTaskdPhi::UserCreateOutputObjects() {
    MEHistograms->Add(hMEvents);
 
    hTrackCent = new TH2I("hTrackCent", "N accepted tracks vs centrality",
-                        fAxisCent.GetNbins() > 2 ? 90 : 1, fAxisCent.GetBinLowEdge(1), fAxisCent.GetBinUpEdge(fAxisCent.GetNbins()),
-                        750, 0, 1500);
+                        fAxisCent.GetNbins() > 1 ? 10*(fAxisCent.GetXmax() - fAxisCent.GetXmin())  : 1, 
+                        fAxisCent.GetXmin(), fAxisCent.GetXmax(),
+                        fAxisCent.GetNbins() > 1 ? 900 : 50, 0,
+                        fAxisCent.GetNbins() > 1 ? 1800 : 50);
    MEHistograms->Add(hTrackCent);
 
+   hTrigPt = new TH2F("hTrigPt", "trigger pt", 100, 0, 10, fAxisCent.GetNbins(), fAxisCent.GetXmin(), fAxisCent.GetXmax()); 
+   MEHistograms->Add(hTrigPt);
+   hTrackPt = new TH2F("hTrackPt", "track pt", 100, 0, 10, fAxisCent.GetNbins(), fAxisCent.GetXmin(), fAxisCent.GetXmax()); 
+   MEHistograms->Add(hTrackPt);
+
    Int_t ntrackfilters[2] = {fTrackFilters[0].GetEntriesFast(), fTrackFilters[1].GetEntriesFast()};
    fkTrackAxis = kTRUE;
    fAxisTrackFilters.SetNameTitle("trackCuts", "trackCuts");
@@ -601,6 +610,7 @@ void AliAnalysisTaskdPhi::UserExec(Option_t *) {
     if(!photon) continue;
     if(!fV0Filter || fV0Filter->PhotonIsSelected(photon, fInputEvent)) {
       ggammas->Add(photon);
+      hTrigPt->Fill(photon->Pt(), centrality);
     } else {
       for(Int_t igf = 0; igf < fV0Filters[1].GetEntriesFast(); igf++) {
        AliConversionCuts * gfilter = dynamic_cast<AliConversionCuts*>(fV0Filters[1].At(igf));
@@ -642,6 +652,7 @@ void AliAnalysisTaskdPhi::UserExec(Option_t *) {
     if(track->Pt() < aptlim[0] || track->Pt() > aptlim[1]) continue;
     if(track->Eta() < aetalim[0] || track->Eta() > aetalim[1]) continue;
     if(fTrackFilter->IsSelected(track)) {
+      hTrackPt->Fill(track->Pt(), centrality);
       ttracks->Add(track);
     } else {
       ///upside cuts
index b3fd985..c8fd1d8 100644 (file)
@@ -111,6 +111,9 @@ private:
 
   TH2I * hMEvents; //event histrogam
   TH2I * hTrackCent; //event histrogam
+  TH2F * hTrigPt; // trigger pt
+  TH2F * hTrackPt; // track pt
+
 
   //AliAnaConvCorrBase * fPhotonCorr; //photon
   //AliAnaConvCorrPion * fPionCorr; //poin
@@ -143,7 +146,7 @@ private:
   AliAnalysisTaskdPhi(const AliAnalysisTaskdPhi&); // not implemented
   AliAnalysisTaskdPhi& operator=(const AliAnalysisTaskdPhi&); // not implemented
   
-  ClassDef(AliAnalysisTaskdPhi, 8); 
+  ClassDef(AliAnalysisTaskdPhi, 9); 
 };
 
 inline THnSparseF * AliAnalysisTaskdPhi::GetMEHistogram(Int_t binz, Int_t binc, TObjArray * array) {
index 4568e58..15b1243 100644 (file)
@@ -15,7 +15,7 @@
 
 /// @file   AliConversionTrackCuts.cxx
 /// @author Svein Lindal
-/// @brief  Base class for analysation of conversion particle - track correlations
+/// @brief  Base class for analysation of conversion particle - track correlations - track cuts
 
 
 #include "AliConversionTrackCuts.h"
@@ -51,8 +51,8 @@ AliConversionTrackCuts::AliConversionTrackCuts() :
   fEsdTrackCutsExtra2(NULL),
   fEvent(NULL),
   fFilterBit(2048),
-  fDCAZmax(-1),
-  fDCAXYmax(-1),
+  fDCAZmax(3.2*3.2),
+  fDCAXYmax(2.4*2.4),
   fOwnedTracks(),
   fInitialized(kFALSE),
   fhPhi(NULL),
@@ -127,25 +127,28 @@ void AliConversionTrackCuts::DefineESDCuts() {
   const Int_t filterbit = fFilterBit;
 
   if (filterbit == 128) {
-    fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
-    fEsdTrackCuts->SetMinNClustersTPC(70);
-    
+    if(!fEsdTrackCuts) {
+      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+      fEsdTrackCuts->SetMinNClustersTPC(70);
+    }
   }  else if (filterbit == 256) {
-    // syst study
-    fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
-    fEsdTrackCuts->SetMinNClustersTPC(80);
-    fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
-    fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
-    fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
-    
+    if(!fEsdTrackCuts) {
+      // syst study
+      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+      fEsdTrackCuts->SetMinNClustersTPC(80);
+      fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
+      fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
+      fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
+    }
   }  else if (filterbit == 512) {
-    // syst study
-    fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
-    fEsdTrackCuts->SetMinNClustersTPC(60);
-    fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
-    fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
-    fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
-    
+    if(!fEsdTrackCuts) {
+      // syst study
+      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+      fEsdTrackCuts->SetMinNClustersTPC(60);
+      fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
+      fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
+      fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
+    }
   } else if (filterbit == 1024) {
     if(!fEsdTrackCuts) {
       fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
@@ -194,38 +197,75 @@ void AliConversionTrackCuts::DefineESDCuts() {
   }
 }
 
+
 //______________________________________________________________________________
 Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
   //Check esd track
+  FillHistograms(kPreCut, track);
+
+
+  if( fFilterBit == 256) {
+
+    ///Standalone tpc tracks constrained
+    const AliExternalTrackParam * param = track->GetConstrainedParam();
+    if(param) {
+      AliESDtrack* esdTrack = new AliESDtrack(*track);
+      esdTrack->CopyFromVTrack(param);
+      track = esdTrack;
+      fOwnedTracks.Add(track);
+
+      if( !fEsdTrackCuts->IsSelected(track)) return kFALSE;
+
+      FillHistograms(1, track);
+
+      Double_t dca[2];
+      GetDCA(track, dca);
+      
+      FillDCAHist(dca[1], dca[0], track);
+      if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+      
+      return kTRUE;
+    } else {
+      return kFALSE;
+    }
+
+    return kFALSE;
+  }
+
 
   if(!fInitialized) {
     DefineESDCuts();
-    if(fDCAXYmax > 0) {
-      if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexXY(fDCAXYmax);
-    }
-    if(fDCAZmax > 0) {
-      if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexZ(fDCAZmax);
-    }
+    // if(fDCAXYmax > 0) {
+    //   if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexXY(fDCAXYmax);
+    // }
+    // if(fDCAZmax > 0) {
+    //   if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexZ(fDCAZmax);
+    // }
   
     fInitialized = kTRUE;
   }
 
-  FillHistograms(kPreCut, track);
 
+  Double_t dca[2];
+  GetDCA(track, dca);
 
   
-  if( !fEsdTrackCuts->IsSelected(track)) return kFALSE;
-
-
   ///If only one track cuts then it has passed the cuts
   if( !(fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2)) {
     FillHistograms(1, track);
+    FillDCAHist(dca[1], dca[0], track);
+    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
     return kTRUE;
   }
+
   ///If passing extra
   if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra1->IsSelected(track)) {
-    FillHistograms(2, track);
     FillHistograms(1, track);
+    FillHistograms(2, track);
+
+    FillDCAHist(dca[1], dca[0], track);
+    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+    
     return kTRUE;
   } 
 
@@ -240,6 +280,10 @@ Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
 
       FillHistograms(3, track);
       FillHistograms(1, track);
+
+      FillDCAHist(dca[1], dca[0], track);
+      if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+
       return kTRUE;
     } else {
       return kFALSE;
@@ -261,61 +305,124 @@ Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
   // ///Get impact parameters
   // Double_t extCov[15];
   // track->GetExternalCovariance(extCov);
-  // Float_t b[2];
-  // Float_t bCov[3];
-  // track->GetImpactParameters(b,bCov);
-  // if (bCov[0]<=0 || bCov[2]<=0) {
-  //   AliDebug(1, "Estimated b resolution lower or equal zero!");
-  //   bCov[0]=0; bCov[2]=0;
-  // }
-  
-  // Float_t dcaToVertexXY = b[0];
-  // Float_t dcaToVertexZ = b[1];
-  // FillDCAHist(dcaToVertexZ, dcaToVertexXY, track);
   // return kTRUE;
 }
 
 Bool_t AliConversionTrackCuts::AcceptTrack(AliAODTrack * track) {
   //Check aod track
-
+  
   FillHistograms(kPreCut, track);
+  
+  if (fFilterBit == 768) {
+    if(!track->IsHybridGlobalConstrainedGlobal()) return kFALSE;
+      
+    if (!(track->GetStatus() & AliVTrack::kITSrefit)) {
+      return kFALSE;
+    }
+      
+    //The cluster sharing cut can be done with:
+    Double_t frac = Double_t(track->GetTPCnclsS()) / Double_t(track->GetTPCncls());
+    if (frac > 0.4) return kFALSE;
+      
+    ///Do dca xy cut!
+    FillHistograms(1, track);
+      
+    ///DCA
+    Double_t dca[2] = { -999, -999};
+    //Bool_t dcaok = 
+    GetDCA(track, dca);
+    FillDCAHist(dca[1], dca[0], track);
+      
+      
+    if(track->IsGlobalConstrained()) {
+      FillHistograms(3, track);
+    } else {
+      FillHistograms(2, track);
+    }
+      
+    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+      
+    return kTRUE;
+    
+    ////////////////////////////////
+    //// Standalone
+    ////////////////////////////////
+  } else  if(fFilterBit == 256) {
+    if(!track->IsTPCConstrained()) return kFALSE;
 
-  if(!track->IsHybridGlobalConstrainedGlobal()) return kFALSE;
 
-   if (!(track->GetStatus() & AliVTrack::kITSrefit)) {
-     return kFALSE;
-   }
 
+    ///DCA
+    Double_t dca[2] = { -999, -999};
+    GetDCA(track, dca);
 
-  //The cluster sharing cut can be done with:
-  Double_t frac = Double_t(track->GetTPCnclsS()) / Double_t(track->GetTPCncls());
-  if (frac > 0.4) return kFALSE;
+    if( (dca[0]*dca[0]/fDCAXYmax + dca[1]*dca[1]/fDCAZmax) > 1 ) {
+      FillHistograms(3, track);
+      return kFALSE;
+    }
 
+    if(track->GetTPCncls() < 70) {
+      FillHistograms(4, track);
+      return kFALSE;
+    }
 
-  ///Do dca xy cut!
-  FillHistograms(1, track);
+    AliAODVertex * vtx = track->GetProdVertex();
+    if (vtx->GetType() == AliAODVertex::kKink ) {
+      FillHistograms(5, track);
+      return kFALSE;
+    }
 
-  ///DCA
-  Double_t dca[2] = { -999, -999};
-  //Bool_t dcaok = 
-  GetDCA(track, dca);
-  FillDCAHist(dca[1], dca[0], track);
-  
+    if(track->Chi2perNDF() > 36) {
+      FillHistograms(6, track);
+      return kFALSE;
+    }
+    if(track->Chi2perNDF() > 26) {
+      FillHistograms(7, track);
+      return kFALSE;
+    }
+    if(track->Chi2perNDF() > 16) {
+      FillHistograms(8, track);
+      return kFALSE;
+    }
+    if(track->Chi2perNDF() > 4) {
+      FillHistograms(9, track);
+      return kFALSE;
+    }
+
+
+
+    FillDCAHist(dca[1], dca[0], track);
 
-  if(track->IsGlobalConstrained()) {
-    FillHistograms(3, track);
-  } else {
     FillHistograms(2, track);
+    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+    return kTRUE;
+
   }
-  
-  if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
+  return kFALSE;
+}
+
 
+///______________________________________________________________________________
+Bool_t AliConversionTrackCuts::GetDCA(const AliESDtrack *track, Double_t dcaxyz[2]) {
+  ///Get track dca esd trck
+  Float_t dca[2];
+  Float_t bCov[3];
+  track->GetImpactParameters(dca,bCov);
+  if (bCov[0]<=0 || bCov[2]<=0) {
+    AliDebug(1, "Estimated b resolution lower or equal zero!");
+    bCov[0]=0; bCov[2]=0;
+    return kFALSE;
+  }
+
+  dcaxyz[0] = dca[0];
+  dcaxyz[1] = dca[1];
+  
   return kTRUE;
 }
 
-///______________________________________________________________________________
+///_____________________________________________________________________________
 Bool_t AliConversionTrackCuts::GetDCA(const AliAODTrack *track, Double_t dca[2]) {
+  ///Get track dca aod trck
   if(track->TestBit(AliAODTrack::kIsDCA)){
     dca[0]=track->DCA();
     dca[1]=track->ZAtDCA();
@@ -331,7 +438,7 @@ Bool_t AliConversionTrackCuts::GetDCA(const AliAODTrack *track, Double_t dca[2])
     Float_t xstart = etp.GetX();
     if(xstart>3.) {
       dca[0]=-999.;
-    dca[1]=-999.;
+      dca[1]=-999.;
     //printf("This method can be used only for propagation inside the beam pipe \n");
     return kFALSE;
     }
@@ -421,11 +528,6 @@ void AliConversionTrackCuts::FillDCAHist(Float_t dcaz, Float_t dcaxy, AliVTrack
 
 
 
-
-
-
-
-
 //_________________________________________________________________________________________________
 void AliConversionTrackCuts::Print(const Option_t *) const
 {
index 03a3f93..8e3c64b 100644 (file)
@@ -43,6 +43,7 @@ public:
   Bool_t AcceptTrack(AliAODTrack * track);
   Bool_t AcceptTrack(AliESDtrack * track);
   Bool_t GetDCA(const AliAODTrack * track, Double_t dca[2]);
+  Bool_t GetDCA(const AliESDtrack * track, Double_t dca[2]);
 
 
   void DeleteTracks() { fOwnedTracks.Delete(); }
@@ -52,8 +53,8 @@ public:
   ~AliConversionTrackCuts();
   
   void      SetEsdTrackCuts(AliESDtrackCuts * trackcuts) { fEsdTrackCuts = trackcuts; }
-  void      SetDCAZmax(Double_t value)  { fDCAZmax = value; }
-  void      SetDCAXYmax(Double_t value) { fDCAXYmax = value; }
+  void      SetDCAZmax(Double_t value)  { fDCAZmax = value*value; }
+  void      SetDCAXYmax(Double_t value) { fDCAXYmax = value*value; }
   void      SetFilterBit(Int_t value)   { fFilterBit = value; }
   void      SetEvent(AliVEvent * event)  { fEvent = event; }