BxByBz and error handling added

diff --git a/PWG1/AliComparisonDCA.cxx b/PWG1/AliComparisonDCA.cxx
index 63c9e84e38470af955499e22d77f72c39943ebe7..24f3ac61d59a51d0b6fcc563638a11c5d8ebdb80 100644 (file)
--- a/PWG1/AliComparisonDCA.cxx
+++ b/PWG1/AliComparisonDCA.cxx
@@ -201,7 +201,7 @@ void AliComparisonDCA::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo * const
 {
   // Fill DCA comparison information
   AliExternalTrackParam *track = 0;
-  Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
+  //Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
   Double_t kMaxD      = 123456.0; // max distance
 
   Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
@@ -234,7 +234,10 @@ void AliComparisonDCA::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo * const
   {
     if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0 )
     {
-      Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+      
+      //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+      Double_t field[3];  track->GetBxByBz(field); 
+      Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov);
 
       if(bDCAStatus) {
         Double_t vDCAHisto[4]={dca[0],dca[1],mceta,mcpt};

diff --git a/PWG1/AliComparisonEff.cxx b/PWG1/AliComparisonEff.cxx
index 2a2be73d34c3e0b84ee293079c4126a45a0b5aa7..2867ef60f2124fc651aa68a338888bf2c9f982d0 100644 (file)
--- a/PWG1/AliComparisonEff.cxx
+++ b/PWG1/AliComparisonEff.cxx
@@ -153,7 +153,7 @@ void AliComparisonEff::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const
   // Fill efficiency comparison information\r
 \r
   AliExternalTrackParam *track = 0;\r
-  Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]\r
+  //Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]\r
   Double_t kMaxD      = 123456.0; // max distance\r
   Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
   AliESDVertex vertexMC;  // MC primary vertex\r
@@ -192,7 +192,9 @@ void AliComparisonEff::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const
   {\r
     if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0)\r
     {\r
-      Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);\r
+      //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);\r
+      Double_t field[3];  track->GetBxByBz(field); \r
+      Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov);\r
       if(bDCAStatus) {\r
         if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
         {\r
@@ -261,7 +263,7 @@ void AliComparisonEff::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo
 {\r
   // Fill efficiency comparison information\r
   AliExternalTrackParam *track = 0;\r
-  Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]\r
+  //Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]\r
   Double_t kMaxD      = 123456.0; // max distance\r
   Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
   AliESDVertex vertexMC;  // MC primary vertex\r
@@ -303,7 +305,9 @@ void AliComparisonEff::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo
 \r
   if ((track = new AliExternalTrackParam(*cparam)) != 0)\r
   {\r
-    Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);\r
+    //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);\r
+    Double_t field[3];  track->GetBxByBz(field); \r
+    Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov);\r
     if(bDCAStatus) {\r
       if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
       {\r

diff --git a/PWG1/AliComparisonRes.cxx b/PWG1/AliComparisonRes.cxx
index 61ce53a54f68017be6a85cae26bbc9430688c261..f21bf727886ff7994b4213edd7b2b8c0d5c558a8 100644 (file)
--- a/PWG1/AliComparisonRes.cxx
+++ b/PWG1/AliComparisonRes.cxx
@@ -179,7 +179,7 @@ void AliComparisonRes::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo *const
 {
   // Fill resolution comparison information 
   AliExternalTrackParam *track = 0;
-  Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
+  //Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
   Double_t kMaxD      = 123456.0; // max distance
   AliESDVertex vertexMC;  // MC primary vertex
 
@@ -216,7 +216,9 @@ void AliComparisonRes::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo *const
   {
     if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0 )
     {
-      Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+      //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+      Double_t field[3];  track->GetBxByBz(field); 
+      Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov);
 
       // Fill parametrisation histograms (only TPC track)
       if(bDCAStatus) 
@@ -332,7 +334,7 @@ void AliComparisonRes::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo
   // Fill resolution comparison information (constarained parameters) 
   //
   AliExternalTrackParam *track = 0;
-  Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
+  //Double_t field      = AliTracker::GetBz(); // nominal Bz field [kG]
   Double_t kMaxD      = 123456.0; // max distance
   AliESDVertex vertexMC;  // MC primary vertex
 
@@ -368,7 +370,9 @@ void AliComparisonRes::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo
 
   if ((track = new AliExternalTrackParam(*cparam)) != 0)
   {
-    Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+    //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov);
+    Double_t field[3];  track->GetBxByBz(field); 
+    Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov);
     if(bDCAStatus) {
       if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())
       {

diff --git a/PWG1/AliPerformanceDCA.cxx b/PWG1/AliPerformanceDCA.cxx
index 7bcf0b32322e0278e7b8612ca8e9363edfdbd218..e330ab9847ecc1f821a96152dabbd1bad62aff24 100644 (file)
--- a/PWG1/AliPerformanceDCA.cxx
+++ b/PWG1/AliPerformanceDCA.cxx
@@ -240,49 +240,49 @@ return count;
 //_____________________________________________________________________________
 void AliPerformanceDCA::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)
 {
-  // Process comparison information
+  // Process comparison information 
+  //
   if(!esdEvent) 
   {
-      AliDebug(AliLog::kError, "esdEvent not available");
-      return;
+    Error("Exec","esdEvent not available");
+    return;
   }
   AliHeader* header = 0;
   AliGenEventHeader* genHeader = 0;
   AliStack* stack = 0;
   TArrayF vtxMC(3);
-
+  
   if(bUseMC)
   {
     if(!mcEvent) {
-      AliDebug(AliLog::kError, "mcEvent not available");
+      Error("Exec","mcEvent not available");
       return;
     }
     // get MC event header
     header = mcEvent->Header();
     if (!header) {
-      AliDebug(AliLog::kError, "Header not available");
+      Error("Exec","Header not available");
       return;
     }
     // MC particle stack
     stack = mcEvent->Stack();
     if (!stack) {
-      AliDebug(AliLog::kError, "Stack not available");
+      Error("Exec","Stack not available");
       return;
     }
     // get MC vertex
     genHeader = header->GenEventHeader();
     if (!genHeader) {
-      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
+      Error("Exec","Could not retrieve genHeader from Header");
       return;
     }
     genHeader->PrimaryVertex(vtxMC);
-
-  } // end bUseMC
-
+  } 
+  
   // use ESD friends
   if(bUseESDfriend) {
     if(!esdFriend) {
-      AliDebug(AliLog::kError, "esdFriend not available");
+      Error("Exec","esdFriend not available");
       return;
     }
   }

diff --git a/PWG1/AliPerformanceEff.cxx b/PWG1/AliPerformanceEff.cxx
index b947050cf289ef6081eb0dd3deae0f99648d8701..0c5ff001fd118c026a0aea60648ecdd82356c117 100644 (file)
--- a/PWG1/AliPerformanceEff.cxx
+++ b/PWG1/AliPerformanceEff.cxx
@@ -211,6 +211,7 @@ void AliPerformanceEff::ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const
   // \r
   // MC histograms for efficiency studies\r
   //\r
+  if(!mcEvent) return;\r
  \r
   AliStack *stack = mcEvent->Stack();\r
   if (!stack) {\r
@@ -307,6 +308,7 @@ void AliPerformanceEff::ProcessTPCSec(AliMCEvent* const mcEvent, AliESDEvent *co
   // \r
   // MC histograms for efficiency studies\r
   //\r
+  if(!mcEvent) return;\r
  \r
   AliStack *stack = mcEvent->Stack();\r
   if (!stack) {\r
@@ -420,6 +422,7 @@ void AliPerformanceEff::ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *co
   // \r
   // MC histograms for efficiency studies\r
   //\r
+  if(!mcEvent) return;\r
  \r
   AliStack *stack = mcEvent->Stack();\r
   if (!stack) {\r
@@ -512,6 +515,7 @@ void AliPerformanceEff::ProcessConstrained(AliMCEvent* const mcEvent, AliESDEven
   // \r
   // MC histograms for efficiency studies\r
   //\r
+  if(!mcEvent) return;\r
  \r
   AliStack *stack = mcEvent->Stack();\r
   if (!stack) {\r
@@ -580,8 +584,8 @@ void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   //\r
   if(!esdEvent) \r
   {\r
-      AliDebug(AliLog::kError, "esdEvent not available");\r
-      return;\r
+    Error("Exec","esdEvent not available");\r
+    return;\r
   }\r
   AliHeader* header = 0;\r
   AliGenEventHeader* genHeader = 0;\r
@@ -591,35 +595,38 @@ void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   if(bUseMC)\r
   {\r
     if(!mcEvent) {\r
-      AliDebug(AliLog::kError, "mcEvent not available");\r
+      Error("Exec","mcEvent not available");\r
       return;\r
     }\r
     // get MC event header\r
     header = mcEvent->Header();\r
     if (!header) {\r
-      AliDebug(AliLog::kError, "Header not available");\r
+      Error("Exec","Header not available");\r
       return;\r
     }\r
     // MC particle stack\r
     stack = mcEvent->Stack();\r
     if (!stack) {\r
-      AliDebug(AliLog::kError, "Stack not available");\r
+      Error("Exec","Stack not available");\r
       return;\r
     }\r
     // get MC vertex\r
     genHeader = header->GenEventHeader();\r
     if (!genHeader) {\r
-      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");\r
+      Error("Exec","Could not retrieve genHeader from Header");\r
       return;\r
     }\r
     genHeader->PrimaryVertex(vtxMC);\r
-\r
-  } // end bUseMC\r
+  } \r
+  else {\r
+    Error("Exec","MC information required!");\r
+    return;\r
+  } \r
 \r
   // use ESD friends\r
   if(bUseESDfriend) {\r
     if(!esdFriend) {\r
-      AliDebug(AliLog::kError, "esdFriend not available");\r
+      Error("Exec","esdFriend not available");\r
       return;\r
     }\r
   }\r

diff --git a/PWG1/AliPerformanceMC.cxx b/PWG1/AliPerformanceMC.cxx
index 44de992a506c4803e0e4143dcf416655d5ec1fe0..ac119fee17d89203178d2d607c8376c0f9c283e5 100644 (file)
--- a/PWG1/AliPerformanceMC.cxx
+++ b/PWG1/AliPerformanceMC.cxx
@@ -186,8 +186,7 @@ void AliPerformanceMC::Init(){
 //_____________________________________________________________________________
 void AliPerformanceMC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const /*esdEvent*/, AliESDfriend *const /*esdFriend*/, const Bool_t bUseMC, const Bool_t /*bUseESDfriend*/)
 {
-  //
-  // Process pure MC information
+  // Process pure MC information 
   //
   AliHeader* header = 0;
   AliGenEventHeader* genHeader = 0;
@@ -197,32 +196,33 @@ void AliPerformanceMC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const /*esdE
   if(bUseMC)
   {
     if(!mcEvent) {
-      AliDebug(AliLog::kError, "mcEvent not available");
+      Error("Exec","mcEvent not available");
       return;
     }
-
     // get MC event header
     header = mcEvent->Header();
     if (!header) {
-      AliDebug(AliLog::kError, "Header not available");
+      Error("Exec","Header not available");
       return;
     }
     // MC particle stack
     stack = mcEvent->Stack();
     if (!stack) {
-      AliDebug(AliLog::kError, "Stack not available");
+      Error("Exec","Stack not available");
       return;
     }
-
     // get MC vertex
     genHeader = header->GenEventHeader();
     if (!genHeader) {
-      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
+      Error("Exec","Could not retrieve genHeader from Header");
       return;
     }
     genHeader->PrimaryVertex(vtxMC);
-
-  } // end bUseMC
+  } 
+  else {
+    Error("Exec","MC information required!");
+    return;
+  }
   
   Int_t nPart = mcEvent->GetNumberOfTracks();
   if (nPart==0) return;
@@ -322,14 +322,14 @@ void AliPerformanceMC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const /*esdE
     }
 
     if(GetAnalysisMode() == 3) {
-      // Propagate refTPCOut to refTPCIn using AliTrack::PropagateTrackTo()
+      // Propagate refTPCOut to refTPCIn using AliTrack::PropagateTrackToBxByBz()
       //
       if(refTPCIn && refTPCOut) 
         ProcessInnerTPC(refTPCIn,refTPCOut,particle); 
     }
 
     if(GetAnalysisMode() == 4) { 
-      // propagate refTPCIn to refTPCOut using AliExternalTrackParam::PropagateTo()
+      // propagate refTPCIn to refTPCOut using AliExternalTrackParam::PropagateToBxByBz()
       ProcessOuterTPCExt(part,trefs); 
     }
   }
@@ -354,13 +354,17 @@ void AliPerformanceMC::ProcessTPC(AliTrackReference* const refIn, TParticle *con
   track=MakeTrack(refIn,particle);
   if (!track) return;
   //
-  AliTracker::PropagateTrackTo(track, radius+step, mass, step, kTRUE,0.99);
-  AliTracker::PropagateTrackTo(track, radius+0.5, mass, step*0.1, kTRUE,0.99);
+  //AliTracker::PropagateTrackTo(track, radius+step, mass, step, kTRUE,0.99);
+  //AliTracker::PropagateTrackTo(track, radius+0.5, mass, step*0.1, kTRUE,0.99);
+  AliTracker::PropagateTrackToBxByBz(track, radius+step, mass, step, kTRUE,0.99);
+  AliTracker::PropagateTrackToBxByBz(track, radius+0.5, mass, step*0.1, kTRUE,0.99);
   Double_t xyz[3] = {particle->Vx(),particle->Vy(),particle->Vz()};
   Double_t sxyz[3]={0.0,0.0,0.0};
   AliESDVertex vertex(xyz,sxyz);
   Double_t dca[2], cov[3];
-  Bool_t isOK = track->PropagateToDCA(&vertex,AliTracker::GetBz(),10,dca,cov);
+  //Bool_t isOK = track->PropagateToDCA(&vertex,AliTracker::GetBz(),10,dca,cov);
+  Double_t field[3];  track->GetBxByBz(field); 
+  Bool_t isOK = track->PropagateToDCABxByBz(&vertex,field,10,dca,cov);
   if(!isOK) return;
 
   // Fill histogram
@@ -433,7 +437,8 @@ void AliPerformanceMC::ProcessInnerTPC(AliTrackReference* const refIn,  AliTrack
 
   //
   //Bool_t isOK = AliTracker::PropagateTrackTo(track, refIn->R(), mass, step, kTRUE,0.99);
-  Bool_t isOK = AliTracker::PropagateTrackTo(track, refIn->R(), mass, step, kFALSE,0.99);
+  //Bool_t isOK = AliTracker::PropagateTrackTo(track, refIn->R(), mass, step, kFALSE,0.99);
+  Bool_t isOK = AliTracker::PropagateTrackToBxByBz(track, refIn->R(), mass, step, kFALSE,0.99);
   if(!isOK) return;
 
   // calculate alpha angle
@@ -536,11 +541,15 @@ void AliPerformanceMC::ProcessOuterTPCExt(TParticle *const part, TClonesArray *
     isOKP&=paramPropagate->Rotate(alphaC);
     isOKU&=paramUpdate->Rotate(alphaC);
     for (Float_t xref= paramPropagate->GetX(); xref<ref->R(); xref++){
-      isOKP&=paramPropagate->PropagateTo(xref, mag[2]);
-      isOKU&=paramUpdate->PropagateTo(xref, mag[2]);
+      //isOKP&=paramPropagate->PropagateTo(xref, mag[2]);
+      //isOKU&=paramUpdate->PropagateTo(xref, mag[2]);
+      isOKP&=paramPropagate->PropagateToBxByBz(xref, mag);
+      isOKU&=paramUpdate->PropagateToBxByBz(xref, mag);
     }
-    isOKP&=paramPropagate->PropagateTo(ref->R(), mag[2]);
-    isOKU&=paramUpdate->PropagateTo(ref->R(), mag[2]);
+    //isOKP&=paramPropagate->PropagateTo(ref->R(), mag[2]);
+    //isOKU&=paramUpdate->PropagateTo(ref->R(), mag[2]);
+    isOKP&=paramPropagate->PropagateToBxByBz(ref->R(), mag);
+    isOKU&=paramUpdate->PropagateToBxByBz(ref->R(), mag);
     Double_t clpos[2] = {0, ref->Z()};
     Double_t clcov[3] = { 0.005,0,0.005};
     isOKU&= paramUpdate->Update(clpos, clcov);  

diff --git a/PWG1/AliPerformanceRes.cxx b/PWG1/AliPerformanceRes.cxx
index 16d608523a8acf65ad1b5e5259972585eb3ed2de..8b81d74fe81e498d06044864272608ea20967f92 100644 (file)
--- a/PWG1/AliPerformanceRes.cxx
+++ b/PWG1/AliPerformanceRes.cxx
@@ -536,7 +536,9 @@ void AliPerformanceRes::ProcessInnerTPC(AliMCEvent *const mcEvent, AliESDtrack *
   // rotate inner track to local coordinate system
   // and propagate to the radius of the first track referenco of TPC
   Double_t trRadius = TMath::Sqrt(xyz[1] * xyz[1] + xyz[0] * xyz[0]);
-  Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz());
+  //Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz());
+  Double_t field[3]; track->GetBxByBz(field);
+  Bool_t isOK = track->PropagateBxByBz(alpha,trRadius,field);
   if(!isOK) return;
 
   Float_t mceta =  -TMath::Log(TMath::Tan(0.5 * ref0->Theta()));
@@ -635,7 +637,9 @@ void AliPerformanceRes::ProcessOuterTPC(AliMCEvent *const mcEvent, AliESDtrack *
   // rotate outer track to local coordinate system
   // and propagate to the radius of the last track reference of TPC
   Double_t trRadius = TMath::Sqrt(xyz[1] * xyz[1] + xyz[0] * xyz[0]);
-  Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz());
+  //Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz());
+  Double_t field[3]; track->GetBxByBz(field);
+  Bool_t isOK = track->PropagateBxByBz(alpha,trRadius,field);
   if(!isOK) return;
 
   Float_t mceta =  -TMath::Log(TMath::Tan(0.5 * ref0->Theta()));
@@ -742,8 +746,8 @@ void AliPerformanceRes::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   //
   if(!esdEvent) 
   {
-      AliDebug(AliLog::kError, "esdEvent not available");
-      return;
+    Error("Exec","esdEvent not available");
+    return;
   }
   AliHeader* header = 0;
   AliGenEventHeader* genHeader = 0;
@@ -753,37 +757,38 @@ void AliPerformanceRes::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   if(bUseMC)
   {
     if(!mcEvent) {
-      AliDebug(AliLog::kError, "mcEvent not available");
+      Error("Exec","mcEvent not available");
       return;
     }
-
     // get MC event header
     header = mcEvent->Header();
     if (!header) {
-      AliDebug(AliLog::kError, "Header not available");
+      Error("Exec","Header not available");
       return;
     }
     // MC particle stack
     stack = mcEvent->Stack();
     if (!stack) {
-      AliDebug(AliLog::kError, "Stack not available");
+      Error("Exec","Stack not available");
       return;
     }
-
     // get MC vertex
     genHeader = header->GenEventHeader();
     if (!genHeader) {
-      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
+      Error("Exec","Could not retrieve genHeader from Header");
       return;
     }
     genHeader->PrimaryVertex(vtxMC);
-
-  } // end bUseMC
+  } 
+  else {
+    Error("Exec","MC information required!");
+    return;
+  }
   
   // use ESD friends
   if(bUseESDfriend) {
     if(!esdFriend) {
-      AliDebug(AliLog::kError, "esdFriend not available");
+      Error("Exec","esdFriend not available");
       return;
     }
   }
@@ -845,9 +850,9 @@ void AliPerformanceRes::Analyse() {
   {
     for(Int_t j=5; j<10; j++) 
     {
-      if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window
+      //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window
       fResolHisto->GetAxis(9)->SetRangeUser(0.16,10.); // pt threshold
-      //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.,0.9); // eta window
+      if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.,0.9); // eta window
       //fResolHisto->GetAxis(9)->SetRangeUser(0.16,3.); // pt window
       if(GetAnalysisMode() == 3) fResolHisto->GetAxis(5)->SetRangeUser(-80.,80.); // y range
 

diff --git a/PWG1/AliPerformanceTPC.cxx b/PWG1/AliPerformanceTPC.cxx
index 9fb066f59f4fcfc20cbb5d7649485ec861942096..e35f1fec8b928a6520039a4f6dc8252309ecc689 100644 (file)
--- a/PWG1/AliPerformanceTPC.cxx
+++ b/PWG1/AliPerformanceTPC.cxx
@@ -214,8 +214,8 @@ void AliPerformanceTPC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   //
   if(!esdEvent) 
   {
-      AliDebug(AliLog::kError, "esdEvent not available");
-      return;
+    Error("Exec","esdEvent not available");
+    return;
   }
   AliHeader* header = 0;
   AliGenEventHeader* genHeader = 0;
@@ -225,44 +225,38 @@ void AliPerformanceTPC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEv
   if(bUseMC)
   {
     if(!mcEvent) {
-      AliDebug(AliLog::kError, "mcEvent not available");
+      Error("Exec","mcEvent not available");
       return;
     }
-
     // get MC event header
     header = mcEvent->Header();
     if (!header) {
-      AliDebug(AliLog::kError, "Header not available");
+      Error("Exec","Header not available");
       return;
     }
     // MC particle stack
     stack = mcEvent->Stack();
     if (!stack) {
-      AliDebug(AliLog::kError, "Stack not available");
+      Error("Exec","Stack not available");
       return;
     }
-
     // get MC vertex
     genHeader = header->GenEventHeader();
     if (!genHeader) {
-      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
+      Error("Exec","Could not retrieve genHeader from Header");
       return;
     }
     genHeader->PrimaryVertex(vtxMC);
-
-  } // end bUseMC
-
+  } 
+  
   // use ESD friends
   if(bUseESDfriend) {
     if(!esdFriend) {
-      AliDebug(AliLog::kError, "esdFriend not available");
+      Error("Exec","esdFriend not available");
       return;
     }
   }
 
-
-
-
   //  Process events
   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) 
   { 

diff --git a/PWG1/AliPerformanceTask.cxx b/PWG1/AliPerformanceTask.cxx
index 2f1e36044f909f124d8bea8fe39cfeaa1d6820fa..17d6c4773310ab7f1a0ac59bac02e7e972be4f93 100644 (file)
--- a/PWG1/AliPerformanceTask.cxx
+++ b/PWG1/AliPerformanceTask.cxx
@@ -19,7 +19,7 @@
 // the control QA histograms are filled.\r
 //\r
 // The comparison output objects deriving from AliPerformanceObject \r
-// (e.g. AliPerformanceRes, AliPerformanceEff, AliPerformanceDEdxA, AliPerformanceDCA ...) \r
+// (e.g. AliPerformanceRes, AliPerformanceEff, AliPerformanceDEdx, AliPerformanceDCA ...) \r
 // are stored in the output file (details in description of these classes).\r
 // \r
 // Author: J.Otwinowski 01/04/2009 \r
@@ -50,10 +50,6 @@
 #include "AliESDRecInfo.h"\r
 #include "AliMCInfoCuts.h"\r
 #include "AliRecInfoCuts.h"\r
-#include "AliComparisonRes.h"\r
-#include "AliComparisonEff.h"\r
-#include "AliComparisonDEdx.h"\r
-#include "AliComparisonDCA.h"\r
 #include "AliComparisonObject.h"\r
 #include "AliPerformanceObject.h"\r
 #include "AliPerformanceTask.h"\r
@@ -124,6 +120,14 @@ void AliPerformanceTask::ConnectInputData(Option_t *)
     Printf("ERROR: Could not get ESDInputHandler");\r
   } else {\r
     fESD = esdH->GetEvent();\r
+\r
+    if(fUseESDfriend)\r
+    {\r
+      fESDfriend = static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));\r
+      if(!fESDfriend) {\r
+        Printf("ERROR: ESD friends not available");\r
+      }\r
+    }\r
   }\r
 \r
   // use MC information\r
@@ -195,10 +199,8 @@ void AliPerformanceTask::Exec(Option_t *)
 \r
   if(fUseESDfriend)\r
   {\r
-    fESDfriend = static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));\r
     if(!fESDfriend) {\r
-      Printf("ERROR: ESD friends not available");\r
-      return;\r
+    Printf("ERROR: ESD friends not available");\r
     }\r
   }\r
 \r