trigger and new tracking scenario

diff --git a/PWG0/dNdPt/AlidNdPt.cxx b/PWG0/dNdPt/AlidNdPt.cxx
index 466b75d2c48db46022fa544753ef1d1935d4de56..b7a23edef64580bd5738a5dc7c3dbb058dfc9d69 100644 (file)
--- a/PWG0/dNdPt/AlidNdPt.cxx
+++ b/PWG0/dNdPt/AlidNdPt.cxx
@@ -31,6 +31,7 @@ AlidNdPt::AlidNdPt(): TNamed()
 , fAnalysisMode(AlidNdPtHelper::kTPC) \r
 , fTrigger(AliTriggerAnalysis::kMB1) \r
 , fTriggerClass(0) \r
+, fParticleMode(AlidNdPtHelper::kAllPart) \r
 {\r
   // default constructor\r
 }\r
@@ -44,6 +45,7 @@ AlidNdPt::AlidNdPt(Char_t* name, Char_t* title): TNamed(name,title)
 , fAnalysisMode(AlidNdPtHelper::kTPC) \r
 , fTrigger(AliTriggerAnalysis::kMB1) \r
 , fTriggerClass(0) \r
+, fParticleMode(AlidNdPtHelper::kAllPart) \r
 {\r
   // constructor\r
 }\r

diff --git a/PWG0/dNdPt/AlidNdPt.h b/PWG0/dNdPt/AlidNdPt.h
index e48680f00c106fea34f34ab97f7ce798cd733b76..3c6b4c3eacb0700856e1f137f0170ac5043483df 100644 (file)
--- a/PWG0/dNdPt/AlidNdPt.h
+++ b/PWG0/dNdPt/AlidNdPt.h
@@ -51,6 +51,7 @@ public:
   void SetAnalysisMode(const AlidNdPtHelper::AnalysisMode mode) { fAnalysisMode = mode; }
   void SetTrigger(const AliTriggerAnalysis::Trigger trigger)    { fTrigger = trigger; }
   void SetTriggerClass(const Char_t *triggerClass)              { fTriggerClass = triggerClass; }
+  void SetParticleMode(const AlidNdPtHelper::ParticleMode mode) { fParticleMode = mode; }
 
   AlidNdPtEventCuts* GetEventCuts() const                       { return fdNdPtEventCuts; }
   AlidNdPtAcceptanceCuts* GetAcceptanceCuts() const             { return fdNdPtAcceptanceCuts; }
@@ -59,6 +60,7 @@ public:
   AlidNdPtHelper::AnalysisMode GetAnalysisMode() const          { return fAnalysisMode; }
   AliTriggerAnalysis::Trigger GetTrigger() const                { return fTrigger; }
   const Char_t* GetTriggerClass() const                         { return fTriggerClass; }
+  AlidNdPtHelper::ParticleMode GetParticleMode() const          { return fParticleMode; }
 
 private:
 
@@ -70,6 +72,7 @@ private:
   AlidNdPtHelper::AnalysisMode fAnalysisMode;   // analysis mode TPC only, TPC + ITS
   AliTriggerAnalysis::Trigger fTrigger;         // trigger definition MB1, MB2 ...
   const Char_t * fTriggerClass;                 // trigger class
+  AlidNdPtHelper::ParticleMode fParticleMode;   // selected particle (pion, kaon, ...)
 
   ClassDef(AlidNdPt,1);
 };

diff --git a/PWG0/dNdPt/AlidNdPtAnalysis.cxx b/PWG0/dNdPt/AlidNdPtAnalysis.cxx
index 921e8ce13b946a79f8f15ef07fd38b3f579cf3e5..19300678acde7226574998f9aba9cf74faf4dd36 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtAnalysis.cxx
+++ b/PWG0/dNdPt/AlidNdPtAnalysis.cxx
@@ -679,7 +679,8 @@ void AlidNdPtAnalysis::Init(){
 \r
   //\r
   Double_t kFact = 1.0;\r
-  if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx) kFact = 0.05; \r
+  if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || \r
+     GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtxUpdate) kFact = 0.03; \r
 \r
   Int_t binsRecMCEventHist1[3]={100,100,100};\r
   Double_t minRecMCEventHist1[3]={-10.0*kFact,-10.0*kFact,-10.0*kFact}; \r
@@ -928,26 +929,27 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
     vtxESD = AlidNdPtHelper::GetVertex(esdEvent,evtCuts,accCuts,esdTrackCuts,GetAnalysisMode(),kFALSE,bRedoTPCVertex,bUseConstraints); \r
     isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, GetAnalysisMode(), kFALSE);\r
   }\r
+\r
   if( IsUseMCInfo() && !evtCuts->IsRecVertexRequired() ) {\r
     vtxESD = new AliESDVertex(vtxMC[2],10.,genHeader->NProduced(),"smearMC");\r
     isRecVertex = kTRUE;\r
   }\r
+\r
   Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD) && isRecVertex; \r
   //printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);\r
+  //printf("GetAnalysisMode() %d \n",GetAnalysisMode());\r
 \r
-  // MB bias tracks\r
+  // vertex contributors\r
   Int_t multMBTracks = 0; \r
-  if(GetAnalysisMode() == AlidNdPtHelper::kTPC || GetAnalysisMode() == AlidNdPtHelper::kMCPion ||  \r
-     GetAnalysisMode() == AlidNdPtHelper::kMCKaon ||  GetAnalysisMode() == AlidNdPtHelper::kMCProton || \r
-     GetAnalysisMode() ==AlidNdPtHelper::kPlus || GetAnalysisMode() ==AlidNdPtHelper::kMinus) {  \r
-\r
+  if(GetAnalysisMode() == AlidNdPtHelper::kTPC) \r
+  {  \r
      multMBTracks = AlidNdPtHelper::GetTPCMBTrackMult(esdEvent,evtCuts,accCuts,esdTrackCuts);\r
   } \r
-  else if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || GetAnalysisMode() == AlidNdPtHelper::kMCPion || \r
-          GetAnalysisMode() == AlidNdPtHelper::kMCKaon || GetAnalysisMode() == AlidNdPtHelper::kMCProton || \r
-         GetAnalysisMode() ==AlidNdPtHelper::kPlus || GetAnalysisMode() == AlidNdPtHelper::kMinus) {\r
-\r
-           multMBTracks = AlidNdPtHelper::GetSPDMBTrackMult(esdEvent,0.0);\r
+  else if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || GetAnalysisMode()==AlidNdPtHelper::kTPCSPDvtxUpdate) \r
+  {\r
+     //multMBTracks = AlidNdPtHelper::GetSPDMBTrackMult(esdEvent,0.0);\r
+     if(vtxESD)\r
+       multMBTracks = vtxESD->GetNContributors();\r
   } \r
   else {\r
     AliDebug(AliLog::kError, Form("Found analysis type %s", GetAnalysisMode()));\r
@@ -967,6 +969,8 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
     if(!allChargedTracks) return;\r
 \r
     Int_t entries = allChargedTracks->GetEntries();\r
+    //printf("entries %d \n",entries);\r
+\r
     labelsAll = new Int_t[entries];\r
     labelsAcc = new Int_t[entries];\r
     labelsRec = new Int_t[entries];\r
@@ -975,22 +979,52 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
       AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
       if(!track) continue;\r
       if(track->Charge()==0) continue;\r
-        \r
-       FillHistograms(track,stack,AlidNdPtHelper::kAllTracks); \r
-       labelsAll[multAll] = TMath::Abs(track->GetLabel());\r
-       multAll++;\r
-\r
-       if(accCuts->AcceptTrack(track)) {\r
-         FillHistograms(track,stack,AlidNdPtHelper::kAccTracks); \r
-        labelsAcc[multAcc] = TMath::Abs(track->GetLabel());\r
-        multAcc++;\r
-\r
-         if(esdTrackCuts->AcceptTrack(track)) {\r
-           FillHistograms(track,stack,AlidNdPtHelper::kRecTracks); \r
-          labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
-          multRec++;\r
+\r
+      // cosmics analysis\r
+      if( GetParticleMode()==AlidNdPtHelper::kCosmics  && \r
+          AlidNdPtHelper::IsCosmicTrack(allChargedTracks, track, i, accCuts, esdTrackCuts)==kFALSE ) \r
+        continue;\r
+\r
+      // only postive charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0) \r
+        continue;\r
+      \r
+      // only negative charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0) \r
+        continue;\r
+\r
+      FillHistograms(track,stack,AlidNdPtHelper::kAllTracks); \r
+      labelsAll[multAll] = TMath::Abs(track->GetLabel());\r
+      multAll++;\r
+\r
+       //if(accCuts->AcceptTrack(track)) {\r
+         //FillHistograms(track,stack,AlidNdPtHelper::kAccTracks); \r
+        //labelsAcc[multAcc] = TMath::Abs(track->GetLabel());\r
+        //multAcc++;\r
+\r
+         if(esdTrackCuts->AcceptTrack(track)) \r
+        {\r
+          if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtxUpdate) {\r
+            // update track parameters\r
+             AliExternalTrackParam cParam;\r
+            track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(),esdEvent->GetMagneticField(),kVeryBig,&cParam);\r
+            track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());\r
+\r
+             if(accCuts->AcceptTrack(track)) {\r
+               FillHistograms(track,stack,AlidNdPtHelper::kRecTracks); \r
+              labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
+              multRec++;\r
+            }  \r
+          }\r
+           else {\r
+             if(accCuts->AcceptTrack(track)) {\r
+               FillHistograms(track,stack,AlidNdPtHelper::kRecTracks); \r
+              labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
+              multRec++;\r
+            }\r
+          }\r
          }\r
-       }\r
+       //}\r
      } \r
      // fill track multiplicity histograms\r
      FillHistograms(allChargedTracks,labelsAll,multAll,labelsAcc,multAcc,labelsRec,multRec);\r
@@ -1066,11 +1100,11 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
         continue;\r
 \r
        // only postive charged \r
-       if(GetAnalysisMode() == AlidNdPtHelper::kPlus && charge < 0.) \r
+       if(GetParticleMode() == AlidNdPtHelper::kPlus && charge < 0.) \r
         continue;\r
        \r
        // only negative charged \r
-       if(GetAnalysisMode() == AlidNdPtHelper::kMinus && charge > 0.) \r
+       if(GetParticleMode() == AlidNdPtHelper::kMinus && charge > 0.) \r
        continue;\r
       \r
        // physical primary\r
@@ -1163,7 +1197,7 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
 \r
         // all genertated primaries including neutral\r
          if( iMc < stack->GetNprimary() ) {\r
-           fGenTrackMatrix->Fill(vTrackMatrix);\r
+           //fGenTrackMatrix->Fill(vTrackMatrix);\r
         }\r
 \r
          // only charged particles\r
@@ -1172,11 +1206,11 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
          continue;\r
 \r
          // only postive charged \r
-         if(GetAnalysisMode() == AlidNdPtHelper::kPlus && charge < 0.) \r
+         if(GetParticleMode() == AlidNdPtHelper::kPlus && charge < 0.) \r
         continue;\r
        \r
          // only negative charged \r
-         if(GetAnalysisMode() == AlidNdPtHelper::kMinus && charge > 0.) \r
+         if(GetParticleMode() == AlidNdPtHelper::kMinus && charge > 0.) \r
         continue;\r
       \r
          // physical primary\r
@@ -1186,7 +1220,7 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
          if(accCuts->AcceptTrack(particle)) \r
         {\r
 \r
-           if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetAnalysisMode()) ) fGenPrimTrackMatrix->Fill(vTrackMatrix);\r
+           if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetParticleMode()) ) fGenPrimTrackMatrix->Fill(vTrackMatrix);\r
 \r
           // fill control histograms\r
            if(fHistogramsOn) \r
@@ -1219,7 +1253,7 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
              if(iMc == labelsRec[iRec]) \r
             {\r
                fRecTrackMatrix->Fill(vTrackMatrix);\r
-               if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetAnalysisMode()) ) fRecPrimTrackMatrix->Fill(vTrackMatrix);\r
+               if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetParticleMode()) ) fRecPrimTrackMatrix->Fill(vTrackMatrix);\r
                if(!prim) fRecSecTrackMatrix->Fill(vTrackMatrix);\r
 \r
               // fill control histograms\r
@@ -1347,6 +1381,7 @@ void AlidNdPtAnalysis::FillHistograms(AliESDtrack *const esdTrack, AliStack *con
   //Float_t gphi = particle->Phi();\r
 \r
   Double_t dpt=0;\r
+  //printf("pt %f, gpt %f \n",pt,gpt);\r
   if(gpt) dpt = (pt-gpt)/gpt;\r
   Double_t deta = (eta-geta);\r
  \r
@@ -1915,6 +1950,7 @@ void AlidNdPtAnalysis::Analyse()
   aFolderObj->Add(h);\r
 \r
   // efficiency\r
+\r
   h = AlidNdPtHelper::GenerateCorrMatrix(fRecPrimTrackMatrix->Projection(1), fGenPrimTrackMatrix->Projection(1),"pt_track_eff_matrix");\r
   aFolderObj->Add(h);\r
 \r
@@ -1940,6 +1976,7 @@ void AlidNdPtAnalysis::Analyse()
   h = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(0),fRecTrackMatrix->Projection(0),"zv_track_cont_matrix");\r
   aFolderObj->Add(h);\r
 \r
+\r
   h = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(1),fRecTrackMatrix->Projection(1),"pt_track_cont_matrix");\r
   aFolderObj->Add(h);\r
 \r
@@ -2174,7 +2211,7 @@ void AlidNdPtAnalysis::Analyse()
   c->cd();\r
 \r
   //\r
-  fRecMCTrackHist1->GetAxis(1)->SetRangeUser(-0.9,0.89); \r
+  fRecMCTrackHist1->GetAxis(1)->SetRangeUser(-0.8,0.79); \r
 \r
   h2F = (TH2F*)fRecMCTrackHist1->Projection(2,0);\r
   h = AlidNdPtHelper::MakeResol(h2F,1,0,kTRUE,10);\r

diff --git a/PWG0/dNdPt/AlidNdPtCorrection.cxx b/PWG0/dNdPt/AlidNdPtCorrection.cxx
index 743dad890bca38a9557a38c769ce96e7a00c7029..10d3c9892df28a648ff97655f0379ac853d9b249 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtCorrection.cxx
+++ b/PWG0/dNdPt/AlidNdPtCorrection.cxx
@@ -593,7 +593,7 @@ void AlidNdPtCorrection::Process(AliESDEvent *esdEvent, AliMCEvent *mcEvent)
     Bool_t bRedoTPCVertex = evtCuts->IsRedoTPCVertex();\r
     Bool_t bUseConstraints = evtCuts->IsUseBeamSpotConstraint();\r
     vtxESD = AlidNdPtHelper::GetVertex(esdEvent,evtCuts,accCuts,esdTrackCuts,GetAnalysisMode(),kFALSE,bRedoTPCVertex,bUseConstraints); \r
-    isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, GetAnalysisMode(), kFALSE); // should be moved to AcceptEvent\r
+    isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, GetAnalysisMode(), kFALSE); \r
   }\r
   if( IsUseMCInfo() &&  !evtCuts->IsRecVertexRequired() ) {\r
     vtxESD = new AliESDVertex(vtxMC[2],10.,genHeader->NProduced());\r
@@ -603,14 +603,15 @@ void AlidNdPtCorrection::Process(AliESDEvent *esdEvent, AliMCEvent *mcEvent)
   //printf("isEventOK %d \n",isEventOK);\r
 \r
   //\r
-  // get multiplicity of min. bias tracks\r
+  // get multiplicity vertex contributors\r
   //\r
   Int_t multMBTracks = 0; \r
   if(GetAnalysisMode() == AlidNdPtHelper::kTPC || GetAnalysisMode() == AlidNdPtHelper::kMCRec) {  \r
     multMBTracks = AlidNdPtHelper::GetTPCMBTrackMult(esdEvent,evtCuts,accCuts,esdTrackCuts);\r
   } \r
-  else if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || GetAnalysisMode() == AlidNdPtHelper::kMCRec) {\r
-    multMBTracks = AlidNdPtHelper::GetSPDMBTrackMult(esdEvent,0.0);\r
+  else if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtxUpdate || GetAnalysisMode() == AlidNdPtHelper::kMCRec) {\r
+    //multMBTracks = AlidNdPtHelper::GetSPDMBTrackMult(esdEvent,0.0);\r
+    multMBTracks = vtxESD->GetNContributors();\r
   } \r
   else {\r
     AliDebug(AliLog::kError, Form("Found analysis type %s", GetAnalysisMode()));\r
@@ -639,34 +640,75 @@ void AlidNdPtCorrection::Process(AliESDEvent *esdEvent, AliMCEvent *mcEvent)
     {\r
       AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
       if(!track) continue;\r
-      if(accCuts->AcceptTrack(track)) \r
-      {\r
-        if(esdTrackCuts->AcceptTrack(track)) \r
-       {\r
-         multRecTemp++;\r
-        }\r
-      }\r
+      if(track->Charge()==0) continue;\r
+\r
+      // only postive charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0) \r
+        continue;\r
+      \r
+      // only negative charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0) \r
+        continue;\r
+\r
+      if(esdTrackCuts->AcceptTrack(track) && accCuts->AcceptTrack(track)) \r
+        multRecTemp++;\r
     }  \r
 \r
+    //\r
     for(Int_t i=0; i<entries;++i) \r
     {\r
       AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
       if(!track) continue;\r
+      if(track->Charge()==0) continue;\r
+\r
+      // only postive charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0) \r
+      continue;\r
+      \r
+      // only negative charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0) \r
+      continue;\r
         \r
-      if(accCuts->AcceptTrack(track)) \r
+      // track-level corrections\r
+      if(esdTrackCuts->AcceptTrack(track)) \r
       {\r
-        if(esdTrackCuts->AcceptTrack(track)) \r
-       {\r
-         // track-level corrections\r
-          if(GetAnalysisMode()==AlidNdPtHelper::kMCRec && IsUseMCInfo()) { \r
-            FillHistograms(track,stack,AlidNdPtHelper::kRecTracks,vtxMC[2],multRecTemp); \r
-         } else {\r
-            FillHistograms(track,stack,AlidNdPtHelper::kRecTracks,vtxESD->GetZv(),multRecTemp); \r
-         }\r
-         labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
-         multRec++;\r
-        }\r
-      }\r
+         if (GetAnalysisMode()==AlidNdPtHelper::kTPCSPDvtxUpdate) \r
+        {\r
+          //\r
+          // update track parameters\r
+          //\r
+           AliExternalTrackParam cParam;\r
+          track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(),esdEvent->GetMagneticField(),kVeryBig,&cParam);\r
+          track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());\r
+\r
+           if(accCuts->AcceptTrack(track)) { \r
+             FillHistograms(track,stack,AlidNdPtHelper::kRecTracks,vtxESD->GetZv(),multRecTemp); \r
+            labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
+            multRec++;\r
+          }\r
+         }\r
+         else if (GetAnalysisMode()==AlidNdPtHelper::kMCRec && IsUseMCInfo()) \r
+         { \r
+          //\r
+          // Replace rec with MC\r
+          //\r
+           if(accCuts->AcceptTrack(track)) { \r
+            FillHistograms(track,stack,AlidNdPtHelper::kRecTracks,vtxMC[2],multRecTemp); \r
+            labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
+            multRec++;\r
+           }\r
+        } \r
+        else  {\r
+          //\r
+          // all the rest tracking scenarios\r
+          //\r
+           if(accCuts->AcceptTrack(track)) { \r
+             FillHistograms(track,stack,AlidNdPtHelper::kRecTracks,vtxESD->GetZv(),multRecTemp); \r
+            labelsRec[multRec] = TMath::Abs(track->GetLabel());\r
+            multRec++;\r
+          }\r
+         }\r
+       }\r
     }\r
     // event-level corrections\r
     if(GetAnalysisMode()==AlidNdPtHelper::kMCRec && IsUseMCInfo()) { \r
@@ -729,6 +771,14 @@ void AlidNdPtCorrection::Process(AliESDEvent *esdEvent, AliMCEvent *mcEvent)
         Double_t charge = particle->GetPDG()->Charge()/3.;\r
         if (charge == 0.0)\r
           continue;\r
+\r
+        // only postive charged \r
+        if(GetParticleMode() == AlidNdPtHelper::kPlus && charge  < 0.) \r
+        continue;\r
+      \r
+        // only negative charged \r
+        if(GetParticleMode() == AlidNdPtHelper::kMinus && charge > 0.) \r
+        continue;\r
       \r
         // physical primary\r
         Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
@@ -1102,10 +1152,10 @@ void AlidNdPtCorrection::Analyse()
   //\r
   // set min and max values\r
   //\r
-  Double_t minPt = accCuts->GetMinPt();\r
-  Double_t maxPt = accCuts->GetMaxPt();\r
-  Double_t minEta = accCuts->GetMinEta();\r
-  Double_t maxEta = accCuts->GetMaxEta()-0.00001;\r
+  //Double_t minPt = accCuts->GetMinPt();\r
+  //Double_t maxPt = accCuts->GetMaxPt();\r
+  //Double_t minEta = accCuts->GetMinEta();\r
+  //Double_t maxEta = accCuts->GetMaxEta()-0.00001;\r
 \r
   //\r
   // pt profile\r

diff --git a/PWG0/dNdPt/AlidNdPtCutAnalysis.cxx b/PWG0/dNdPt/AlidNdPtCutAnalysis.cxx
index ed9325f48e5c02359a921dc477bac7f9cf60419c..46a9f9867377835a90b7e010a76b40a123454581 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtCutAnalysis.cxx
+++ b/PWG0/dNdPt/AlidNdPtCutAnalysis.cxx
@@ -120,9 +120,10 @@ void AlidNdPtCutAnalysis::Init(){
   fMCEventHist->Sumw2();\r
 \r
   //Xv-mcXv:Yv-mcYv:Zv-mcZv:Mult\r
+  Float_t fact = 0.1;\r
   Int_t binsRecMCEventHist[4]={100,100,100,150};\r
-  Double_t minRecMCEventHist[4]={-10.0,-10.0,-10.0,0.}; \r
-  Double_t maxRecMCEventHist[4]={10.0,10.0,10.0,150.}; \r
+  Double_t minRecMCEventHist[4]={-10.0*fact,-10.0*fact,-10.0*fact,0.}; \r
+  Double_t maxRecMCEventHist[4]={10.0*fact,10.0*fact,10.0*fact,150.}; \r
   fRecMCEventHist = new THnSparseF("fRecMCEventHist","mcXv-Xv:mcYv-Yv:mcZv-Zv:Mult",4,binsRecMCEventHist,minRecMCEventHist,maxRecMCEventHist);\r
   fRecMCEventHist->GetAxis(0)->SetTitle("mcXv-Xv (cm)");\r
   fRecMCEventHist->GetAxis(1)->SetTitle("mcYv-Yv (cm)");\r
@@ -273,6 +274,17 @@ void AlidNdPtCutAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent * cons
       AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
       if(!track) continue;\r
 \r
+      //\r
+      if (GetAnalysisMode()==AlidNdPtHelper::kTPCSPDvtxUpdate) \r
+      {\r
+        //\r
+        // update track parameters\r
+       //\r
+           AliExternalTrackParam cParam;\r
+          track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(),esdEvent->GetMagneticField(),kVeryBig,&cParam);\r
+          track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());\r
+      }\r
+\r
       FillHistograms(track, stack);\r
       multAll++;\r
     }\r

diff --git a/PWG0/dNdPt/AlidNdPtHelper.cxx b/PWG0/dNdPt/AlidNdPtHelper.cxx
index 0a9343dfe01fb14082757e308f62692b32b4ba8c..d64237093ab15b46abd019a63538e78688a8a252 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtHelper.cxx
+++ b/PWG0/dNdPt/AlidNdPtHelper.cxx
@@ -26,12 +26,12 @@
 #include <TLeaf.h>
 #include <TArrayI.h>
 #include <TF1.h>
+#include <TLorentzVector.h>
 
 #include <AliHeader.h>
 #include <AliStack.h>
 #include <AliLog.h>
 
-#include <AliLog.h>
 #include <AliESD.h>
 #include <AliESDEvent.h>
 #include <AliMCEvent.h>
@@ -74,17 +74,13 @@ const AliESDVertex* AlidNdPtHelper::GetVertex(AliESDEvent* aEsd, AlidNdPtEventCu
 
   const AliESDVertex* vertex = 0;
   AliESDVertex *initVertex = 0;
-  if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx ||  
-      analysisMode == kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon || 
-      analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus )
+  if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate)
   {
     vertex = aEsd->GetPrimaryVertexSPD();
     if (debug)
       Printf("AlidNdPtHelper::GetVertex: Returning SPD vertex");
   }
-  else if (analysisMode == kTPC || analysisMode == kMCRec || 
-           analysisMode == kMCPion || analysisMode == kMCKaon || analysisMode == kMCProton || 
-          analysisMode == kPlus || analysisMode == kMinus)
+  else if (analysisMode == kTPC)
   {
     if(bRedoTPC) {
 
@@ -170,13 +166,11 @@ Bool_t AlidNdPtHelper::TestRecVertex(const AliESDVertex* vertex, AnalysisMode an
   if(!vertex) return kFALSE;
 
   Float_t requiredZResolution = -1;
-  if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx)
+  if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate)
   {
     requiredZResolution = 0.1;
   }
-  else if (analysisMode == kTPC || analysisMode == kMCRec || 
-           analysisMode == kMCPion || analysisMode == kMCKaon || 
-          analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus)
+  else if (analysisMode == kTPC)
     requiredZResolution = 10.;
 
   // check Ncontributors
@@ -206,10 +200,10 @@ Bool_t AlidNdPtHelper::TestRecVertex(const AliESDVertex* vertex, AnalysisMode an
 }
 
 //____________________________________________________________________
-Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* stack, Int_t idx, AnalysisMode analysisMode)
+Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* stack, Int_t idx, ParticleMode particleMode)
 {
 // check primary particles 
-// depending on the analysis mode
+// depending on the particle mode
 //
   if(!stack) return kFALSE;
 
@@ -225,17 +219,17 @@ Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* stack, Int_t idx, AnalysisMod
   // physical primary
   Bool_t prim = stack->IsPhysicalPrimary(idx);
 
-  if(analysisMode==kMCPion) {
+  if(particleMode==kMCPion) {
     if(prim && pdg==kPiPlus) return kTRUE;
     else return kFALSE;
   } 
 
-  if (analysisMode==kMCKaon) {
+  if (particleMode==kMCKaon) {
     if(prim && pdg==kKPlus) return kTRUE;
     else return kFALSE;
   }
     
-  if (analysisMode==kMCProton) {
+  if (particleMode==kMCProton) {
     if(prim && pdg==kProton) return kTRUE;
     else return kFALSE;
   }
@@ -243,6 +237,59 @@ Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* stack, Int_t idx, AnalysisMod
 return prim;
 }
 
+//____________________________________________________________________
+Bool_t AlidNdPtHelper::IsCosmicTrack(TObjArray *allChargedTracks, AliESDtrack *track1, Int_t trackIdx, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
+{
+//
+// check cosmic tracks
+//
+  if(!allChargedTracks) return kFALSE;
+  if(!track1) return kFALSE;
+  if(!accCuts) return kFALSE;
+  if(!trackCuts) return kFALSE;
+
+  Int_t entries = allChargedTracks->GetEntries();
+  for(Int_t i=0; i<entries;++i) 
+  {
+      //
+      // exclude the same tracks
+      //
+      if(i == trackIdx) continue;
+
+      AliESDtrack *track2 = (AliESDtrack*)allChargedTracks->At(i);
+      if(!track2) continue;
+      if(track2->Charge()==0) continue;
+
+      /*
+      if(track1->Pt() > 6. && track2->Pt() > 6. && (track1->Charge() + track2->Charge()) == 0 ) 
+      {
+        printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
+        printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
+
+        printf("deta %f, dphi %f, dq %d  \n", track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge()); 
+
+      }
+      */
+
+      //
+      // cosmic tracks in TPC
+      //
+      //if( TMath::Abs( track1->Theta() - track2->Theta() ) < 0.004  && 
+      //  ((TMath::Abs(track1->Phi()-track2->Phi()) - TMath::Pi() )<0.004) && 
+      if( (track1->Pt()-track2->Pt()) < 0.1 && track1->Pt() > 6.0 && 
+            (track1->Charge()+track2->Charge()) == 0 )
+      {
+        //printf("COSMIC  candidate \n");
+        printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
+        printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
+        printf("dtheta %f, deta %f, dphi %f, dq %d  \n", track1->Theta()-track2->Theta(),  track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge()); 
+       return kTRUE;
+      }
+   }
+     
+return kFALSE; 
+}
+
 //____________________________________________________________________
 void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger)
 {
@@ -259,12 +306,8 @@ void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Tr
     case kTPC : str += "TPC-only"; break;
     case kTPCITS : str += "Global tracking"; break;
     case kTPCSPDvtx : str += "TPC tracking + SPD event vertex"; break;
+    case kTPCSPDvtxUpdate : str += "TPC tracks updated with SPD event vertex point"; break;
     case kMCRec : str += "TPC tracking + Replace rec. with MC values"; break;
-    case kMCPion : str += "TPC tracking + only pion MC tracks"; break;
-    case kMCKaon : str += "TPC tracking + only kaon MC tracks"; break;
-    case kMCProton : str += "TPC tracking + only proton MC tracks"; break;
-    case kPlus: str += "TPC tracking + only positive charged tracks"; break;
-    case kMinus : str += "TPC tracking + only negative charge tracks"; break;
   }
   str += " and trigger ";
 
@@ -426,22 +469,26 @@ TObjArray* AlidNdPtHelper::GetAllChargedTracks(AliESDEvent *esdEvent, AnalysisMo
   AliESDtrack *track=0;
   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) 
   { 
-    if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx || 
-       analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon || 
-       analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) { 
-
-      // track must be deleted by the user 
+    if(analysisMode == AlidNdPtHelper::kTPC) { 
+      // track must be deleted by user 
       track = AliESDtrackCuts::GetTPCOnlyTrack(esdEvent,iTrack);
-    } else {
+      if(!track) continue;
+    } 
+    else if (analysisMode == AlidNdPtHelper::kTPCSPDvtx || AlidNdPtHelper::kTPCSPDvtxUpdate)
+    {
+      // track must be deleted by the user 
+      track = AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(esdEvent,iTrack,kFALSE);
+      if(!track) continue;
+    }
+    else {
       track=esdEvent->GetTrack(iTrack);
     }
     if(!track) continue;
 
     if(track->Charge()==0) { 
-      if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||  
-         analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon || 
-        analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) {
-
+      if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx || 
+         analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate) 
+      {
         delete track; continue; 
       } else {
         continue;
@@ -452,8 +499,7 @@ TObjArray* AlidNdPtHelper::GetAllChargedTracks(AliESDEvent *esdEvent, AnalysisMo
   }
 
   if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx || 
-     analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon || 
-     analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) {
+     analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate) {
      
      allTracks->SetOwner(kTRUE);
   }
@@ -461,6 +507,56 @@ TObjArray* AlidNdPtHelper::GetAllChargedTracks(AliESDEvent *esdEvent, AnalysisMo
 return allTracks;
 }
 
+//_____________________________________________________________________________
+AliESDtrack *AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(AliESDEvent* esdEvent, Int_t iTrack, Bool_t bUpdate)
+{
+//
+// Create ESD tracks from TPCinner parameters.
+// Propagte to DCA to SPD vertex.
+// Update using SPD vertex point (parameter)
+//
+// It is user responsibility to delete these tracks
+//
+
+  if (!esdEvent) return NULL;
+  if (!esdEvent->GetPrimaryVertexSPD() ) { return NULL; }
+  if (!esdEvent->GetPrimaryVertexSPD()->GetStatus() ) { return  NULL; }
+   
+  // 
+  AliESDtrack* track = esdEvent->GetTrack(iTrack);
+  if (!track)
+    return NULL;
+
+  // create new ESD track
+  AliESDtrack *tpcTrack = new AliESDtrack();
+ 
+  // relate TPC-only tracks (TPCinner) to SPD vertex
+  AliExternalTrackParam cParam;
+  if(bUpdate) {  
+    track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(),esdEvent->GetMagneticField(),kVeryBig,&cParam);
+    track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());
+
+    // reject fake tracks
+    if(track->Pt() > 10000.)  {
+      ::Error("Exclude no physical tracks","pt>10000. GeV");
+      delete tpcTrack; 
+      return NULL;
+    }
+  }
+  else {
+    track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(), esdEvent->GetMagneticField(), kVeryBig);
+  }
+
+  // only true if we have a tpc track
+  if (!track->FillTPCOnlyTrack(*tpcTrack))
+  {
+    delete tpcTrack;
+    return NULL;
+  }
+
+return tpcTrack;
+} 
+
 //_____________________________________________________________________________
 Int_t AlidNdPtHelper::GetTPCMBTrackMult(AliESDEvent *esdEvent, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
 {

diff --git a/PWG0/dNdPt/AlidNdPtHelper.h b/PWG0/dNdPt/AlidNdPtHelper.h
index 411773f0ba8297934ccce5d7dc0e693551740cb3..8d0f72a12d61a29985099358386ef168c8525405 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtHelper.h
+++ b/PWG0/dNdPt/AlidNdPtHelper.h
@@ -38,14 +38,17 @@ class AlidNdPtEventCuts;
 class AlidNdPtHelper : public TObject
 {
   public:
-    enum AnalysisMode { kInvalid = -1, kSPD = 0, kTPC, kTPCITS, kTPCSPDvtx, kMCRec, kMCPion, kMCKaon, kMCProton, kPlus, kMinus };
+    enum AnalysisMode { kInvalid = -1, kSPD = 0, kTPC, kTPCITS, kTPCSPDvtx, kTPCSPDvtxUpdate, kMCRec };
+    enum ParticleMode { kAllPart = 0, kMCPion, kMCKaon, kMCProton, kPlus, kMinus, kCosmics};
+
     static const AliESDVertex* GetVertex(AliESDEvent* aEsd, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts,  AnalysisMode analysisMethod, Bool_t debug = kFALSE,Bool_t bRedoTPC = kFALSE, Bool_t bUseMeanVertex = kFALSE);
 
     static const AliESDVertex* GetTPCVertexZ(AliESDEvent* aEsd, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts, Float_t fraction=0.8, Int_t ntracksMin=2);
 
     static Bool_t TestRecVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug = kFALSE);
 
-    static Bool_t IsPrimaryParticle(AliStack *stack, Int_t idx, AnalysisMode analysisMode);
+    static Bool_t IsPrimaryParticle(AliStack *stack, Int_t idx, ParticleMode particleMode);
+    static Bool_t IsCosmicTrack(TObjArray *allChargedTracks, AliESDtrack *track, Int_t trackIdx, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts);
     static void PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger);
     static Int_t ConvertPdgToPid(TParticle *particle);
 
@@ -66,6 +69,8 @@ class AlidNdPtHelper : public TObject
     static Int_t GetSPDMBPrimTrackMult(AliESDEvent* esdEvent, AliStack * stack, Float_t deltaThetaCut =0.025, Float_t deltaPhiCut = 0.08);
     static Int_t GetMCTrueTrackMult(AliMCEvent *mcEvent, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts);
 
+    static AliESDtrack* GetTPCOnlyTrackSPDvtx(AliESDEvent* esdEvent, Int_t iTrack, Bool_t bUpdate);
+
     static void PrintMCInfo(AliStack *pStack, Int_t label);
 
     static TH1* ScaleByBinWidth(TH1 *hist=0);