Spectra: bug fix. Forgot to take the square root of the uncertainty on pT

TrackQA:
For follow up of High Pt tracking discussion yesterday and updates for 2011 PbPb QA
Adding histos: NClusF vs Phi, NCrossedRows(Fit) vs Rel1PtUncertainty, Storing bit number of ITS cluster map vs Rel1PtUncertainty (M. Verweij)

diff --git a/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx b/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
index 6ff712054f7eb7e20d6cebafb1f7a8ee5cc14826..1e305ca168d9179c5c22e1c19dfac96de4a804f9 100644 (file)
--- a/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
+++ b/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
@@ -453,7 +453,7 @@ void AliPWG4HighPtSpectra::Exec(Option_t *)
            }
 
            //Fill pT resolution plots for primaries
-           fPtRelUncertainty1PtPrim->Fill(containerInputRec[0],containerInputRec[0]*track->GetSigma1Pt2());
+           fPtRelUncertainty1PtPrim->Fill(containerInputRec[0],containerInputRec[0]*TMath::Sqrt(track->GetSigma1Pt2()));
 
          }
 
@@ -466,7 +466,7 @@ void AliPWG4HighPtSpectra::Exec(Option_t *)
              fCFManagerNeg->GetParticleContainer()->Fill(containerInputMC,kStepSecondaries);
            }
            //Fill pT resolution plots for primaries
-           fPtRelUncertainty1PtSec->Fill(containerInputRec[0],containerInputRec[0]*track->GetSigma1Pt2());
+           fPtRelUncertainty1PtSec->Fill(containerInputRec[0],containerInputRec[0]*TMath::Sqrt(track->GetSigma1Pt2()));
          }
        }
        

diff --git a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
index ec62ecbc4525887e021ba8c27606470e7ff2dfaa..517c165523950ea2157ff923f0f7dd5885371ba9 100644 (file)
--- a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
+++ b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
@@ -75,6 +75,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fCentClass(10),
   fNVariables(25),
   fVariables(0x0),
+  fITSClusterMap(0),
   fAvgTrials(1),
   fNEventAll(0),
   fNEventSel(0),
@@ -104,6 +105,8 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fPtRelUncertainty1Pt(0x0),
   fPtRelUncertainty1PtNClus(0x0),
   fPtRelUncertainty1PtNClusIter1(0x0),
+  fPtRelUncertainty1PtNPointITS(0x0),
+  fPtRelUncertainty1PtITSClusterMap(0x0),
   fPtRelUncertainty1PtChi2(0x0),
   fPtRelUncertainty1PtChi2Iter1(0x0),
   fPtRelUncertainty1PtPhi(0x0),
@@ -112,14 +115,16 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fPtChi2PerClusterTPCIter1(0x0),
   fPtNCrossedRows(0x0),
   fPtNCrossedRowsPhi(0x0),
-  fPtNCrossedRowsNClusF(0x0),
+  fPtNCrossedRowsNClusFPhi(0x0),
   fPtNCrRNCrRNClusF(0x0),
   fPtNCrossedRowsFit(0x0),
   fPtNCrossedRowsFitPhi(0x0),
-  fPtNCrossedRowsNClusFFit(0x0),
+  fPtNCrossedRowsNClusFFitPhi(0x0),
   fNCrossedRowsNCrossedRowsFit(0x0),
   fNClustersNCrossedRows(0x0),
   fNClustersNCrossedRowsFit(0x0),
+  fPtRelUncertainty1PtNCrossedRows(0x0),
+  fPtRelUncertainty1PtNCrossedRowsFit(0x0),
   fPtChi2Gold(0x0),
   fPtChi2GGC(0x0),
   fPtChi2GoldPhi(0x0),
@@ -167,6 +172,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fCentClass(10),
   fNVariables(25),
   fVariables(0x0),
+  fITSClusterMap(0),
   fAvgTrials(1),
   fNEventAll(0),
   fNEventSel(0),
@@ -196,6 +202,8 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fPtRelUncertainty1Pt(0x0),
   fPtRelUncertainty1PtNClus(0x0),
   fPtRelUncertainty1PtNClusIter1(0x0),
+  fPtRelUncertainty1PtNPointITS(0x0),
+  fPtRelUncertainty1PtITSClusterMap(0x0),
   fPtRelUncertainty1PtChi2(0x0),
   fPtRelUncertainty1PtChi2Iter1(0x0),
   fPtRelUncertainty1PtPhi(0x0),
@@ -204,14 +212,16 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fPtChi2PerClusterTPCIter1(0x0),
   fPtNCrossedRows(0x0),
   fPtNCrossedRowsPhi(0x0),
-  fPtNCrossedRowsNClusF(0x0),
+  fPtNCrossedRowsNClusFPhi(0x0),
   fPtNCrRNCrRNClusF(0x0),
   fPtNCrossedRowsFit(0x0),
   fPtNCrossedRowsFitPhi(0x0),
-  fPtNCrossedRowsNClusFFit(0x0),
+  fPtNCrossedRowsNClusFFitPhi(0x0),
   fNCrossedRowsNCrossedRowsFit(0x0),
   fNClustersNCrossedRows(0x0),
   fNClustersNCrossedRowsFit(0x0),
+  fPtRelUncertainty1PtNCrossedRows(0x0),
+  fPtRelUncertainty1PtNCrossedRowsFit(0x0),
   fPtChi2Gold(0x0),
   fPtChi2GGC(0x0),
   fPtChi2GoldPhi(0x0),
@@ -343,6 +353,13 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
   for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
 
+  Int_t fgkNITSClusterMapBins=65;
+  Float_t fgkITSClusterMapMin = -0.5;
+  Float_t fgkITSClusterMapMax = 64.5;
+  Double_t *binsITSClusterMap=new Double_t[fgkNITSClusterMapBins+1];
+  for(Int_t i=0; i<=fgkNITSClusterMapBins; i++) binsITSClusterMap[i]=(Double_t)fgkITSClusterMapMin + (fgkITSClusterMapMax-fgkITSClusterMapMin)/fgkNITSClusterMapBins*(Double_t)i ;
+
+
   Int_t fgkNNSigmaToVertexBins=9;
   Float_t fgkNSigmaToVertexMin = 0.;
   Float_t fgkNSigmaToVertexMax = 9.;
@@ -379,9 +396,9 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   Double_t *binsChi2PerClus=new Double_t[fgkNChi2PerClusBins+1];
   for(Int_t i=0; i<=fgkNChi2PerClusBins; i++) binsChi2PerClus[i]=(Double_t)fgkChi2PerClusMin + (fgkChi2PerClusMax-fgkChi2PerClusMin)/fgkNChi2PerClusBins*(Double_t)i ;
 
-  Int_t fgkNCrossedRowsNClusFBins  = 50;
+  Int_t fgkNCrossedRowsNClusFBins  = 45;
   Float_t fgkNCrossedRowsNClusFMin = 0.;
-  Float_t fgkNCrossedRowsNClusFMax = 1.;
+  Float_t fgkNCrossedRowsNClusFMax = 1.5;
   Double_t *binsNCrossedRowsNClusF=new Double_t[fgkNCrossedRowsNClusFBins+1];
   for(Int_t i=0; i<=fgkNCrossedRowsNClusFBins; i++) binsNCrossedRowsNClusF[i]=(Double_t)fgkNCrossedRowsNClusFMin + (fgkNCrossedRowsNClusFMax-fgkNCrossedRowsNClusFMin)/fgkNCrossedRowsNClusFBins*(Double_t)i ;
 
@@ -539,6 +556,12 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   fPtRelUncertainty1PtNClusIter1 = new TH3F("fPtRelUncertainty1PtNClusIter1","fPtRelUncertainty1PtNClusIter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
   fHistList->Add(fPtRelUncertainty1PtNClusIter1);
 
+  fPtRelUncertainty1PtNPointITS = new TH3F("fPtRelUncertainty1PtNPointITS","fPtRelUncertainty1PtNPointITS",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNPointITSBins,binsNPointITS);
+  fHistList->Add(fPtRelUncertainty1PtNPointITS);
+
+  fPtRelUncertainty1PtITSClusterMap = new TH3F("fPtRelUncertainty1PtITSClusterMap","fPtRelUncertainty1PtITSClusterMap",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNITSClusterMapBins,binsITSClusterMap);
+  fHistList->Add(fPtRelUncertainty1PtITSClusterMap);
+
   fPtRelUncertainty1PtChi2 = new TH3F("fPtRelUncertainty1PtChi2","fPtRelUncertainty1PtChi2",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
   fHistList->Add(fPtRelUncertainty1PtChi2);
 
@@ -563,8 +586,8 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   fPtNCrossedRowsPhi = new TH3F("fPtNCrossedRowsPhi","fPtNCrossedRowsPhi",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNPhiBins,binsPhi);
   fHistList->Add(fPtNCrossedRowsPhi);
 
-  fPtNCrossedRowsNClusF = new TH2F("fPtNCrossedRowsNClusF","fPtNCrossedRowsNClusF",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
-  fHistList->Add(fPtNCrossedRowsNClusF);
+  fPtNCrossedRowsNClusFPhi = new TH3F("fPtNCrossedRowsNClusFPhi","fPtNCrossedRowsNClusFPhi",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF,fgkNPhiBins,binsPhi);
+  fHistList->Add(fPtNCrossedRowsNClusFPhi);
  
   fPtNCrRNCrRNClusF = new TH3F("fPtNCrRNCrRNClusF","fPtNCrRNCrRNClusF",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
   fHistList->Add(fPtNCrRNCrRNClusF);
@@ -575,8 +598,8 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   fPtNCrossedRowsFitPhi = new TH3F("fPtNCrossedRowsFitPhi","fPtNCrossedRowsFitPhi",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNPhiBins,binsPhi);
   fHistList->Add(fPtNCrossedRowsFitPhi);
 
-  fPtNCrossedRowsNClusFFit = new TH2F("fPtNCrossedRowsNClusFFit","fPtNCrossedRowsNClusFFit",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
-  fHistList->Add(fPtNCrossedRowsNClusFFit);
+  fPtNCrossedRowsNClusFFitPhi = new TH3F("fPtNCrossedRowsNClusFFitPhi","fPtNCrossedRowsNClusFFitPhi",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF,fgkNPhiBins,binsPhi);
+  fHistList->Add(fPtNCrossedRowsNClusFFitPhi);
 
   fNCrossedRowsNCrossedRowsFit = new TH2F("fNCrossedRowsNCrossedRowsFit","fNCrossedRowsNCrossedRowsFit",fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
   fHistList->Add(fNCrossedRowsNCrossedRowsFit);
@@ -587,6 +610,12 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   fNClustersNCrossedRowsFit = new TH2F("fNClustersNCrossedRowsFit","fNClustersNCrossedRowsFit",fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
   fHistList->Add(fNClustersNCrossedRowsFit);
 
+  fPtRelUncertainty1PtNCrossedRows = new TH3F("fPtRelUncertainty1PtNCrossedRows","fPtRelUncertainty1PtNCrossedRows",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
+  fHistList->Add(fPtRelUncertainty1PtNCrossedRows);
+
+  fPtRelUncertainty1PtNCrossedRowsFit = new TH3F("fPtRelUncertainty1PtNCrossedRowsFit","fPtRelUncertainty1PtNCrossedRowsFit",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
+  fHistList->Add(fPtRelUncertainty1PtNCrossedRowsFit);
+
   fPtChi2Gold = new TH2F("fPtChi2Gold","fPtChi2Gold",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
   fHistList->Add(fPtChi2Gold);
 
@@ -1100,6 +1129,7 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
     fVariables->SetAt((float)track->GetTPCNcls(),5);
 
     Int_t nPointITS = 0;
+    fITSClusterMap = track->GetITSClusterMap();
     UChar_t itsMap = track->GetITSClusterMap();
     for (Int_t i=0; i < 6; i++) {
       if (itsMap & (1 << i))
@@ -1254,6 +1284,10 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
   fPtRelUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
   fPtRelUncertainty1PtNClus->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(5));
   fPtRelUncertainty1PtNClusIter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(18));
+  fPtRelUncertainty1PtNPointITS->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(6));
+
+  fPtRelUncertainty1PtITSClusterMap->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),(int)fITSClusterMap);
+
   fPtRelUncertainty1PtChi2->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(10));
   if(fVariables->At(18)>0.)
     fPtRelUncertainty1PtChi2Iter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(19)/fVariables->At(18));
@@ -1277,7 +1311,7 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
   fPtChi2PerClusterTPC->Fill(fVariables->At(0),fVariables->At(10));
   fPtNCrossedRows->Fill(fVariables->At(0),fVariables->At(11));
   fPtNCrossedRowsPhi->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(1));
-  fPtNCrossedRowsNClusF->Fill(fVariables->At(0),fVariables->At(12));
+  fPtNCrossedRowsNClusFPhi->Fill(fVariables->At(0),fVariables->At(12),fVariables->At(1));
   fPtNCrRNCrRNClusF->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(12));
 
   fPtChi2Gold->Fill(fVariables->At(0),fVariables->At(21));
@@ -1290,12 +1324,15 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
 
   fPtNCrossedRowsFit->Fill(fVariables->At(0),fVariables->At(23));
   fPtNCrossedRowsFitPhi->Fill(fVariables->At(0),fVariables->At(23),fVariables->At(1));
-  fPtNCrossedRowsNClusFFit->Fill(fVariables->At(0),fVariables->At(24));
+  fPtNCrossedRowsNClusFFitPhi->Fill(fVariables->At(0),fVariables->At(24),fVariables->At(1));
   fNCrossedRowsNCrossedRowsFit->Fill(fVariables->At(11),fVariables->At(23));
 
   fNClustersNCrossedRows->Fill(fVariables->At(5),fVariables->At(11));
   fNClustersNCrossedRowsFit->Fill(fVariables->At(5),fVariables->At(23));
 
+  fPtRelUncertainty1PtNCrossedRows->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(11));
+  fPtRelUncertainty1PtNCrossedRowsFit->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(23));
+
 }
 
 //________________________________________________________________________

diff --git a/PWG4/JetTasks/AliPWG4HighPtTrackQA.h b/PWG4/JetTasks/AliPWG4HighPtTrackQA.h
index f0ab8d0b95c3499bd8a2f9372aef3cae45d3f3c5..e9c9c1d301bdd5e8d15e8756d5903b24a1975a33 100644 (file)
--- a/PWG4/JetTasks/AliPWG4HighPtTrackQA.h
+++ b/PWG4/JetTasks/AliPWG4HighPtTrackQA.h
@@ -150,6 +150,8 @@ class AliPWG4HighPtTrackQA: public AliAnalysisTaskSE {
   Int_t fNVariables;             // Number of variables
   TArrayF *fVariables;           // QA variables
 
+  UChar_t fITSClusterMap;  // map of clusters, one bit per a layer
+
   Float_t fAvgTrials;             // Average number of trials
   
   TH1F *fNEventAll;                            //! Event counter
@@ -181,9 +183,14 @@ class AliPWG4HighPtTrackQA: public AliAnalysisTaskSE {
   TH2F *fPtNPointITS;                          //! Pt vs nPointITS
   TH2F *fPtChi2C;                              //! Pt vs Chi2C
   TH2F *fPtNSigmaToVertex;                     //! Pt vs nSigmaToVertex
+
   TH2F *fPtRelUncertainty1Pt;                  //! Pt vs relUncertainty1Pt
   TH3F *fPtRelUncertainty1PtNClus;             //! Pt vs relUncertainty1Pt vs NClustersTPC
   TH3F *fPtRelUncertainty1PtNClusIter1;        //! Pt vs relUncertainty1Pt vs NClustersTPCIter1
+  TH3F *fPtRelUncertainty1PtNPointITS;         //! Pt vs relUncertainty1Pt vs NPointITS
+  TH3F *fPtRelUncertainty1PtITSClusterMap;     //! Pt vs relUncertainty1Pt vs byte of ITS clustermap
+
+
   TH3F *fPtRelUncertainty1PtChi2;              //! Pt vs relUncertainty1Pt vs Chi2TPC/NClus
   TH3F *fPtRelUncertainty1PtChi2Iter1;         //! Pt vs relUncertainty1Pt vs Chi2TPC/NClusIter1
   TH3F *fPtRelUncertainty1PtPhi;               //! Pt vs relUncertainty1PtPhi
@@ -192,14 +199,16 @@ class AliPWG4HighPtTrackQA: public AliAnalysisTaskSE {
   TH2F *fPtChi2PerClusterTPCIter1;             //! Pt vs Chi2PerClusterTPCIter1
   TH2F *fPtNCrossedRows;                       //! Pt vs NCrossedRows
   TH3F *fPtNCrossedRowsPhi;                    //! Pt vs NCrossedRows vs Phi
-  TH2F *fPtNCrossedRowsNClusF;                 //! Pt vs NCrossedRows/NClusF
+  TH3F *fPtNCrossedRowsNClusFPhi;              //! Pt vs NCrossedRows/NClusF vs Phi
   TH3F *fPtNCrRNCrRNClusF;                     //! Pt vs NCrossedRows vs NCrossedRows/NClusF 
   TH2F *fPtNCrossedRowsFit;                    //! Pt vs NCrossedRows from NClusterFitMap
   TH3F *fPtNCrossedRowsFitPhi;                 //! Pt vs NCrossedRows from FitMap vs Phi
-  TH2F *fPtNCrossedRowsNClusFFit;              //! Pt vs NCrossedRows/NClusF from NClusterFitMap
+  TH3F *fPtNCrossedRowsNClusFFitPhi;              //! Pt vs NCrossedRows/NClusF from NClusterFitMap
   TH2F *fNCrossedRowsNCrossedRowsFit;          //! NCrossedRows from ClusterMap vs NCrossedRows from NClusterFitMap
   TH2F *fNClustersNCrossedRows;                //! NClusters vs NCrossedRows
   TH2F *fNClustersNCrossedRowsFit;             //! NClusters vs NCrossedRows from fit map
+  TH3F *fPtRelUncertainty1PtNCrossedRows;       //! Pt vs relUncertainty1Pt vs NCrossedRows
+  TH3F *fPtRelUncertainty1PtNCrossedRowsFit;    //! Pt vs relUncertainty1Pt vs NCrossedRowsFitMap
 
   TH2F *fPtChi2Gold;                           //! Pt vs Chi2 between global and TPC constrained track
   TH2F *fPtChi2GGC;                            //! Pt vs Chi2 between global and global constrained track

diff --git a/PWG4/macros/AnalysisTrainPWG4Jets.C b/PWG4/macros/AnalysisTrainPWG4Jets.C
index 70d7abecb4aa9db92d2246331caeca94cc4fbe54..08dc76df7536939b74dc17a456a1f4b9bcd2ec47 100644 (file)
--- a/PWG4/macros/AnalysisTrainPWG4Jets.C
+++ b/PWG4/macros/AnalysisTrainPWG4Jets.C
@@ -1800,6 +1800,7 @@ Bool_t LoadAnalysisLibraries(const char *mode)
      if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE;
    }
    if(iPWG4JetTasks){
+     if (!LoadLibrary("PWG4Base", mode, kTRUE)) return kFALSE;
      if (!LoadLibrary("PWG4JetTasks", mode, kTRUE)) return kFALSE;
    }
 

diff --git a/PWG4/macros/ConfigTrainGrid.C b/PWG4/macros/ConfigTrainGrid.C
index d281a4c75e569b1a1b4d5d8c1bb57cbcbfb3a6e0..371aeb8aaf49f20d692c5f0b328e7a94aad3ece1 100644 (file)
--- a/PWG4/macros/ConfigTrainGrid.C
+++ b/PWG4/macros/ConfigTrainGrid.C
@@ -39,7 +39,8 @@
   // bextra == 0 4 plus
   // bextra == 1 large pass1 split..
   // bextra == 2 3 plus
-  Int_t bRun = 802; Int_t bExtra = 0;  char* cDate = "111018b";
+  //  Int_t bRun = 802; Int_t bExtra = 0;  char* cDate = "111018b";
+  Int_t bRun = 5014; Int_t bExtra = 0;  char* cDate = "120104a";
   //  Int_t bRun = 8102; Int_t bExtra = 1;  char* cDate = "110725a";
   iAODanalysis = 0; 
   // 1 == Read Jets and tracks form the input AOD
@@ -49,10 +50,32 @@
   // 1 =  write the Full AOD for all events 
   // 2 =  write the Full AOD for triggered events
   // 3 =  write the deltaAOD for all events
+  iFilterAnalysis = 1;
   //  iFilterAnalysis = 2;kJetTriggerPtCut = 40; 
-  iFilterAnalysis = 3;
+  //  iFilterAnalysis = 3;
   // iFilterAnalysis = 2;
+
+  if(iFilterAnalysis==1){
+    kSaveAOD            = 1;
+    kGridFilesPerJob       = 5;
+    kDeltaAODJetName   = "";
+    kFilterAOD = false;
+  }
+  else if(iFilterAnalysis==2){
+    kSaveAOD            = 1;
+    kGridFilesPerJob    = 20;
+    kDeltaAODJetName   = "";
+    kFilterAOD = true;
+  }
+  else if(iFilterAnalysis == 3){
+    kSaveAOD            = 2;
+    kGridFilesPerJob    = 20;
+      kDeltaAODJetName   = "AliAOD.Jets.root";
+      kFilterAOD = true;
+  }
   
+
+
   if (kPluginMode.Contains("merge")){
     // currently merging this one...
     //       cDate = "110717a";
@@ -534,25 +557,6 @@
     }
     if(iAODanalysis)kTrainName  = Form("tAOD_10h_pass2_%s",cDate);
 
-    if(iFilterAnalysis==1){
-      kSaveAOD            = 1;
-      kGridFilesPerJob       = 5;
-      kDeltaAODJetName   = "";
-      kFilterAOD = false;
-    }
-    else if(iFilterAnalysis==2){
-      kSaveAOD            = 1;
-      kGridFilesPerJob    = 20;
-      kDeltaAODJetName   = "";
-      kFilterAOD = true;
-    }
-    else if(iFilterAnalysis == 3){
-      kSaveAOD            = 2;
-      kGridFilesPerJob    = 20;
-      kDeltaAODJetName   = "AliAOD.Jets.root";
-      kFilterAOD = true;
-    }
-
     if(iAODanalysis==0){
       // select what is running in the spectrum task, list of jet names is filles automatically
       kGridFilesPerJob       = 30;
@@ -921,6 +925,37 @@
     iPWG4CaloConv    = 0;  // 25.08. off: Output size 03.09 crashes 
     iPWG4omega3pi     = 0; // OFF no feedback
     iPWGPPQASym = 0; // excluded since also on QA train         
+    iPWG4Minijet  = 0;
+      iPWG4ThreeJets    = 0; // tmp off mem leak
+      iPWG4KMeans       = 0;  // OFF no FEEDBACK
+      iPWG4Tagged       = 0; // OFF crashes on MC 
+      iPWG4CaloQA       = 0; // OFF not needed on MC   
+      iPWG4JetCorr      = 0; 
+      iPWG4JCORRAN      = 0;  // TMP OFF: Writes a Tree
+      iPWG4omega3pi     = 0; // OFF no feedback
+      
+      // swtich off most tasks for Pb+Pb
+      iDIJETAN = 0; // only run on one JetFinder for the moment
+      iPWG4LeadingUE = 0; 
+      iPWG4JetChem      = 0;
+      iPWG4QGSep  = 0;
+      iPWG4Minijet  = 0;
+      iPWG4PartCorr     = 0;
+      iPWG4GammaConv    = 0; 
+      
+      // running as light a possible 
+      
+      iPWG4PtQAMC     = 0;  // 
+      iPWG4PtQATPC   = 0;  // 
+      iPWG4PtSpectra   = 0;  //  
+      iPWG4PtTrackQA    = 0; // currently not needed 08.09.2011
+      iPWG4JetSpectrum = 1; 
+      iPWG4JetServices  = 1; // !!!!!!!!!!! 
+      iPWG4Cluster      = 1;// not 5....
+      kHighPtFilterMask = 1<<4|1<<8; // Global tracks with SPD requirment global constraitn for the rest
+      iPWG4Fragmentation = 1;
+    //
+
 
     kDeltaAODJetName   = ""; // for OTF we do not need to write a delta/saves some extension gymnastics in the tasks       
 
@@ -1074,23 +1109,6 @@
     kHighPtFilterMask = 1<<4|1<<8;     
 
 
-
-    if(iFilterAnalysis==1){
-      kSaveAOD            = 1;
-      kDeltaAODJetName   = "";
-      kFilterAOD = false;
-    }
-    else if(iFilterAnalysis==2){
-      kJetTriggerPtCut = 20; //pt 
-      kSaveAOD            = 1;
-      kDeltaAODJetName   = "";
-      kFilterAOD = true;
-    }
-    else if(iFilterAnalysis == 3){
-      kSaveAOD            = 2;
-      kDeltaAODJetName   = "AliAOD.Jets.root";
-      kFilterAOD = true;
-    }
     kGridFilesPerJob       = 100;
     /*
 ############# Possible jet branches ###################
@@ -1181,25 +1199,28 @@
       // local
       if(iAODanalysis)kNumberOfEvents     = 2000;
       kUseSysInfo = 1;
-       kUseDebug = kTRUE;
-       kTrainName             = Form("pwg4train_test_local");
-       kLocalDataList = "local_esd_lhc10d_pass2.txt";
-       kUsePAR              = kFALSE; // cannot patch the macro for local test, need to laod FASTjet libs before loading FASTJETA.so
-       kUseCPAR            = kFALSE;
-               if(bRun==802){
-         kLocalDataList = "local_esd_lhc10h.txt";
-         if(iAODanalysis)        kLocalDataList = "local_aod_lhc10h.txt";
-       }
-       //      iPWG4PtTrackQA    = 0;
-       //      iPWG4PtQAMC       = 0;
-       //      iPWG4PtSpectra    = 0;
-       //      iPWG4PtQATPC      = 0;
-       //      iPWG4PtTrackQA    = 0;
-       //      iPWG4Cluster      = 0;
-       kUseCPAR            = kFALSE;
-       kUsePAR            = kFALSE;
-       //      kNumberOfEvents     = 200;
-       // all OFF
+      kUseDebug = kTRUE;
+      kTrainName             = Form("pwg4train_test_local");
+      kLocalDataList = "local_esd_lhc10d_pass2.txt";
+      kUsePAR              = kFALSE; // cannot patch the macro for local test, need to laod FASTjet libs before loading FASTJETA.so
+      kUseCPAR            = kFALSE;
+      if(bRun==802){
+       kLocalDataList = "local_esd_lhc10h.txt";
+       if(iAODanalysis)          kLocalDataList = "local_aod_lhc10h.txt";
+      }
+      else if (bRun == 5014){
+       kLocalDataList = "local_esd_lhc10e14.txt";
+      }
+      //       iPWG4PtTrackQA    = 0;
+      //       iPWG4PtQAMC       = 0;
+      //       iPWG4PtSpectra    = 0;
+      //       iPWG4PtQATPC      = 0;
+      //       iPWG4PtTrackQA    = 0;
+      //       iPWG4Cluster      = 0;
+      kUseCPAR            = kFALSE;
+      kUsePAR            = kFALSE;
+      //      kNumberOfEvents     = 70;
+      // all OFF
     }
   }
   if(kPluginAliRootVersion.Length()==0){