Fixes to cure warnings

diff --git a/PWG3/hfe/AliAnalysisTaskHFE.cxx b/PWG3/hfe/AliAnalysisTaskHFE.cxx
index 78b505e92fd52dd1ae10328884a3189f234252ec..5bb8956a29effca81cd63f9149251586f01e57b1 100644 (file)
--- a/PWG3/hfe/AliAnalysisTaskHFE.cxx
+++ b/PWG3/hfe/AliAnalysisTaskHFE.cxx
@@ -681,6 +681,7 @@ void AliAnalysisTaskHFE::ProcessESD(){
       if(track->Pt()>1.0){
         fSecVtx->InitHFEpairs();
         fSecVtx->InitHFEsecvtxs();
+        AliESDtrack *htrack = 0x0; 
         for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){
           htrack = fESD->GetTrack(jtrack);
           if ( itrack == jtrack ) continue; // since it is for tagging single electron, don't need additional condition 

diff --git a/PWG3/hfe/AliAnalysisTaskHFEpidQA.cxx b/PWG3/hfe/AliAnalysisTaskHFEpidQA.cxx
index 67b8b480c6ad5a299416b576f1f3e1cdc14fe263..79eac727395398c5e090c4de9a26736cbd6eeab2 100644 (file)
--- a/PWG3/hfe/AliAnalysisTaskHFEpidQA.cxx
+++ b/PWG3/hfe/AliAnalysisTaskHFEpidQA.cxx
@@ -24,6 +24,9 @@
 #include <TH1I.h>
 #include <TList.h>
 
+#include "AliAnalysisManager.h"
+#include "AliMCEventHandler.h"
+#include "AliLog.h"
 #include "AliAnalysisTaskHFEpidQA.h"
 #include "AliHFEpidQA.h"
 #include "AliESDEvent.h"
@@ -92,13 +95,27 @@ void AliAnalysisTaskHFEpidQA::UserCreateOutputObjects(){
     tmp->SetName("V0pidMC");
     fOutput->Add(tmp);
   }
+
   
+}
+Bool_t AliAnalysisTaskHFEpidQA::UserNotify(){
+   // DEBUG
+  //printf("*****\n");
+  //printf(" -D Current File Name: %s \n", CurrentFileName());
+  return AliAnalysisTask::Notify();
+
 }
 
 void AliAnalysisTaskHFEpidQA::UserExec(Option_t *){
   //
   // Event Loop
-  //
+  // 
+  AliMCEventHandler* mcHandler = (dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()));
+  // check the MC data
+  if(fMCEvent && !mcHandler ) return;
+  if(fMCEvent &&  !mcHandler->InitOk() ) return;
+  if(fMCEvent &&  !mcHandler->TreeK() ) return;
+  if(fMCEvent &&  !mcHandler->TreeTR() ) return;
   if(fMCEvent) fPIDqa->SetMCEvent(fMCEvent);
   fPIDqa->SetRun((dynamic_cast<AliESDEvent*>(fInputEvent))->GetRunNumber());
   fPIDqa->SetT0((dynamic_cast<AliESDEvent*>(fInputEvent))->GetT0());
@@ -113,3 +130,4 @@ void AliAnalysisTaskHFEpidQA::Terminate(Option_t *){
   //
 }
 
+

diff --git a/PWG3/hfe/AliAnalysisTaskHFEpidQA.h b/PWG3/hfe/AliAnalysisTaskHFEpidQA.h
index 1083674d27edc79c30a7939a0472ca0bcb9c163c..4b2e6c63c50812c88cf7f640ed3ee634de6662ca 100644 (file)
--- a/PWG3/hfe/AliAnalysisTaskHFEpidQA.h
+++ b/PWG3/hfe/AliAnalysisTaskHFEpidQA.h
@@ -1,3 +1,22 @@
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+//
+// Task for PID QA
+// Using AliHFEpidQA and AliHFEMCpidQA
+// More information can be found in the source file
+//
 #ifndef ALIANALYSISTASKHFEPIDQA_H
 #define ALIANALYSISTASKHFEPIDQA_H
 
@@ -11,18 +30,15 @@ class TList;
 class AliHFEpidQA;
 
 class AliAnalysisTaskHFEpidQA : public AliAnalysisTaskSE{
-  enum{
-    kV0pidQA = BIT(22),
-    kRecalculateTRDpid = BIT(23)
-  };
   public:
     AliAnalysisTaskHFEpidQA();
     AliAnalysisTaskHFEpidQA(const Char_t *name);
     ~AliAnalysisTaskHFEpidQA();
 
-    void UserCreateOutputObjects();
+    virtual void UserCreateOutputObjects();
     virtual void UserExec(Option_t *);
     virtual void Terminate(Option_t *);
+    virtual Bool_t UserNotify();
 
     Bool_t HasV0pidQA() const { return TestBit(kV0pidQA); };
     Bool_t HasRecalculateTRDpid() const { return TestBit(kRecalculateTRDpid); };
@@ -30,6 +46,10 @@ class AliAnalysisTaskHFEpidQA : public AliAnalysisTaskSE{
     void SetRecalculateTRDpid(Bool_t recal = kTRUE) { SetBit(kRecalculateTRDpid, recal); };
 
   private:
+    enum{
+      kV0pidQA = BIT(22),
+      kRecalculateTRDpid = BIT(23)
+    };
     AliAnalysisTaskHFEpidQA(const AliAnalysisTaskHFEpidQA &ref);
     AliAnalysisTaskHFEpidQA &operator=(const AliAnalysisTaskHFEpidQA &ref);
     AliHFEpidQA *fPIDqa;    //! The heart of the analysis  

diff --git a/PWG3/hfe/AliHFEV0pid.cxx b/PWG3/hfe/AliHFEV0pid.cxx
index 80ae9701272244d36e2fb91f65030ba17a7ddd3b..9956fa2b169bc635f70338f7700eeff5406b194e 100644 (file)
--- a/PWG3/hfe/AliHFEV0pid.cxx
+++ b/PWG3/hfe/AliHFEV0pid.cxx
@@ -103,11 +103,17 @@ void AliHFEV0pid::InitQA(){
     fQA->CreateTH1F("h_cutEfficiencyLambda", "Cut Efficiency for Lambdas", 10, 0, 10);
 
     // QA histograms for invariant mass
-    fQA->CreateTH1F("h_InvMassGamma", "Gamma invariant mass; inv mass {[eV/c^{2}]; counts", 100, 0, 0.25);
+    fQA->CreateTH1F("h_InvMassGamma", "Gamma invariant mass; inv mass [GeV/c^{2}]; counts", 100, 0, 0.25);
     fQA->CreateTH1F("h_InvMassK0s", "K0s invariant mass; inv mass [GeV/c^{2}]; counts", 100, 0.4, 0.65);
     fQA->CreateTH1F("h_InvMassPhi", "Phi invariant mass; inv mass [GeV/c^{2}]; counts", 100, 0.4, 0.65);
     fQA->CreateTH1F("h_InvMassLambda", "Lambda invariant mass; inv mass [GeV/c^{2}]; counts", 100, 1.05, 1.15);
     
+    // QA histograms for p distribution (of the daughters)
+    fQA->CreateTH1F("h_P_electron", "P distribution of the gamma electrons; p (GeV/c); counts", 100, 0.1, 10);
+    fQA->CreateTH1F("h_P_K0pion", "P distribution of the K0 pions; p (GeV/c); counts", 100, 0.1, 10);
+    fQA->CreateTH1F("h_P_Lpion", "P distribution of the Lambda pions; p (GeV/c); counts", 100, 0.1, 10);
+    fQA->CreateTH1F("h_P_Lproton", "P distribution of the Lambda protons; p (GeV/c); counts", 100, 0.1, 10);
+
     // QA invariant mass as a functin of pt
     fQA->CreateTH1Fvector1(20, "h_InvMassGamma_pt", "Gamma invarinat mass in pt bins; inv mass [GeV/c^{2}]; counts", 250, 0, 2);
     fQA->CreateTH1Fvector1(20, "h_InvMassK0_pt", "K0 invarinat mass in pt bins; inv mass [GeV/c^{2}]; counts", 250, 0, 2);
@@ -267,11 +273,11 @@ Bool_t AliHFEV0pid::IsGammaConv(TObject *v0){
   Double_t mPt = kfMother->GetPt();
   fQA->Fill("h_Pt_Gamma", mPt);
   Int_t ptBin = (int)(mPt*10.0);
-  fQA->Fill("h_InvMassGamma_pt", ptBin+1, invMass);
 
   if(fQA) fQA->Fill("h_InvMassGamma", invMass);
   if(invMass > 0.05) return kFALSE; 
-
+  fQA->Fill("h_InvMassGamma_pt", ptBin+1, invMass);
+  
   AliDebug(1, Form("Gamma identified, daughter IDs: %d,%d", daughter[0]->GetID(), daughter[1]->GetID()));
   // Identified gamma - store tracks in the electron containers
   if(!fIndices->Find(daughter[0]->GetID())){

diff --git a/PWG3/hfe/AliHFEcontainer.cxx b/PWG3/hfe/AliHFEcontainer.cxx
index 0cb937e44454560032964928de8ed431e036afdc..4afd1d9309e5a39cb7b6fa76228b6360cbaffcf7 100644 (file)
--- a/PWG3/hfe/AliHFEcontainer.cxx
+++ b/PWG3/hfe/AliHFEcontainer.cxx
@@ -250,12 +250,6 @@ AliCFContainer *AliHFEcontainer::MakeMergedCFContainer(const Char_t *name, const
   for(UInt_t ibin = 0; ibin < fNVars; ibin++) dummyBinning[ibin] = 1;
   AliCFContainer *cmerged = new AliCFContainer(name, title, nStepMerged, fNVars, dummyBinning);
   delete dummyBinning;
-  // cleanup old container content so that we can fill it with the new content
-  AliInfo("Removing temporary grids");
-  for(Int_t istep = 0; istep < cmerged->GetNStep(); istep++){
-    AliCFGridSparse *grid = cmerged->GetGrid(istep);
-    delete grid;
-  }
   // Fill container with content
   AliInfo("Filling new container");
   Int_t cstep = 0;

diff --git a/PWG3/hfe/AliHFEcutStep.cxx b/PWG3/hfe/AliHFEcutStep.cxx
index e0e49c6ac2068df601564be3a4d6f4facf837c1c..e5a5f04b30292fe812822f0b75458253698b645f 100644 (file)
--- a/PWG3/hfe/AliHFEcutStep.cxx
+++ b/PWG3/hfe/AliHFEcutStep.cxx
@@ -88,13 +88,13 @@ Bool_t AliHFEcutStep::IsSelected(TObject *o){
   // Filter tracks in the given cut step
   // Apply all cut objects
   //
-  AliInfo(Form("Cut Step %s: Number of cut objects: %d", GetName(), fCuts->GetEntriesFast()));
+  AliDebug(1, Form("Cut Step %s: Number of cut objects: %d", GetName(), fCuts->GetEntriesFast()));
   if(!fCuts->GetEntriesFast()) return kTRUE;
   Bool_t isSelected = kTRUE;
   for(Int_t iCut = 0; iCut < fCuts->GetEntriesFast(); iCut++){
     if(!(dynamic_cast<AliAnalysisCuts *>(fCuts->UncheckedAt(iCut)))->IsSelected(o)) isSelected = kFALSE;
   }
-  AliInfo(Form("Accepted: %s", isSelected ? "yes" : "no"));
+  AliDebug(1, Form("Accepted: %s", isSelected ? "yes" : "no"));
   return isSelected;
 } 
 

diff --git a/PWG3/hfe/AliHFEdisplacedElectrons.cxx b/PWG3/hfe/AliHFEdisplacedElectrons.cxx
index 127ce102c40182183a33398cc354efbce6f6bb91..aacf6f7d69424215d3b5841101e130f5ddcee6e1 100644 (file)
--- a/PWG3/hfe/AliHFEdisplacedElectrons.cxx
+++ b/PWG3/hfe/AliHFEdisplacedElectrons.cxx
@@ -80,8 +80,6 @@ const Char_t *AliHFEdisplacedElectrons::fgkKineVarTitle[3] ={
 //__________________________________________________________
 AliHFEdisplacedElectrons::AliHFEdisplacedElectrons():
   fDebugLevel(0)
-  , fESD(0x0)
-  , fMC(0x0)
   , fTHnSparseDcaMcPionInfo(NULL)
   , fTHnSparseDcaMcEleInfo(NULL)
   , fTHnSparseDcaDataEleInfo(NULL)
@@ -94,15 +92,13 @@ AliHFEdisplacedElectrons::AliHFEdisplacedElectrons():
 }
 
 //__________________________________________________________
-AliHFEdisplacedElectrons::AliHFEdisplacedElectrons(const AliHFEdisplacedElectrons &displacedElectrons):
-  TObject(displacedElectrons)
-  , fDebugLevel(0)
-  , fESD(0x0)
-  , fMC(0x0)
-  , fTHnSparseDcaMcPionInfo(NULL)
-  , fTHnSparseDcaMcEleInfo(NULL)
-  , fTHnSparseDcaDataEleInfo(NULL)
-  , fOutputList(0x0)
+AliHFEdisplacedElectrons::AliHFEdisplacedElectrons(const AliHFEdisplacedElectrons &ref):
+  TObject(ref)
+  , fDebugLevel(ref.fDebugLevel)
+  , fTHnSparseDcaMcPionInfo(ref.fTHnSparseDcaMcPionInfo)
+  , fTHnSparseDcaMcEleInfo(ref.fTHnSparseDcaMcEleInfo)
+  , fTHnSparseDcaDataEleInfo(ref.fTHnSparseDcaDataEleInfo)
+  , fOutputList(ref.fOutputList)
   
 {
   //
@@ -112,12 +108,22 @@ AliHFEdisplacedElectrons::AliHFEdisplacedElectrons(const AliHFEdisplacedElectron
 
 
 //__________________________________________________________
-AliHFEdisplacedElectrons&AliHFEdisplacedElectrons::operator=(const AliHFEdisplacedElectrons &)
+AliHFEdisplacedElectrons&AliHFEdisplacedElectrons::operator=(const AliHFEdisplacedElectrons &ref)
 {
   //
   // Assignment operator
   //
-  Printf("Not yet implemented.");
+
+  if(this == &ref) return *this;
+  AliHFEdisplacedElectrons::operator=(ref);
+
+  fDebugLevel = ref.fDebugLevel;
+
+  fTHnSparseDcaMcPionInfo = ref.fTHnSparseDcaMcPionInfo;
+  fTHnSparseDcaMcEleInfo = ref.fTHnSparseDcaMcEleInfo;
+  fTHnSparseDcaDataEleInfo = ref.fTHnSparseDcaDataEleInfo;
+  fOutputList = ref.fOutputList;
+
   return *this;
 }
 
@@ -225,7 +231,7 @@ void AliHFEdisplacedElectrons::CreateOutputs(TList* const displacedList){
   const Int_t nVarPion = 5;
   Int_t iBinPion[nVarPion] = {nBinsDca, nBinsDca, nBinsPt, nBinsRap, nBinsPhi};
    
-  THnSparseF *fTHnSparseDcaMcPionInfo = NULL; // empty for the moment 
+  //  THnSparseF *fTHnSparseDcaMcPionInfo = NULL; // empty for the moment 
   if(HasMCData()){
     fTHnSparseDcaMcPionInfo = new THnSparseF("dcaMcPionInfo", 
                                             "MC info:;dcaXY [50 #mum];dcaZ [50 #mum];pT [GeV/c];y [rapidity];#phi [rad];",     
@@ -244,7 +250,7 @@ void AliHFEdisplacedElectrons::CreateOutputs(TList* const displacedList){
   const Int_t nVar = 6;
   Int_t iBin[nVar] = {nBinsEleSource,nBinsDca, nBinsDca, nBinsPt, nBinsRap, nBinsPhi};
   
-  THnSparseF *fTHnSparseDcaMcEleInfo = NULL; // empty for the moment 
+  //  THnSparseF *fTHnSparseDcaMcEleInfo = NULL; // empty for the moment 
   if(HasMCData()){
     fTHnSparseDcaMcEleInfo = new THnSparseF("dcaMcElectronInfo", 
                                         "MC info:;ID [electron source id];dcaXY [50 #mum];dcaZ [50 #mum];pT [GeV/c];y [rapidity];#phi [rad];",         
@@ -262,7 +268,7 @@ void AliHFEdisplacedElectrons::CreateOutputs(TList* const displacedList){
   
   // for ESD: HFE pid
 
-  THnSparseF *fTHnSparseDcaDataEleInfo = NULL;  // empty for the moment
+  //  THnSparseF *fTHnSparseDcaDataEleInfo = NULL;  // empty for the moment
   const Int_t nVarData = 5;
   Int_t iBinData[nVarData] = {nBinsDca, nBinsDca, nBinsPt, nBinsRap, nBinsPhi};  
   
@@ -413,7 +419,7 @@ void AliHFEdisplacedElectrons::FillMCOutput(AliESDEvent * const fESDEvent, AliES
 
 
 //__________________________________________________________
-void AliHFEdisplacedElectrons::FillESDOutput(AliESDEvent * const fESD, AliESDtrack* const esdTrack)
+void AliHFEdisplacedElectrons::FillESDOutput(AliESDEvent * const fESDEvent, AliESDtrack* const esdTrack)
 {
 
   // fill output
@@ -425,10 +431,10 @@ void AliHFEdisplacedElectrons::FillESDOutput(AliESDEvent * const fESD, AliESDtra
   Double_t phi = track->Phi();
   
   // obtain impact parameters in xy and y
-  const AliESDVertex *primVtx = fESD->GetPrimaryVertex();    
+  const AliESDVertex *primVtx = fESDEvent->GetPrimaryVertex();    
   
   Float_t magneticField = 5;  // initialized as 5kG
-  magneticField = fESD->GetMagneticField();  // in kG 
+  magneticField = fESDEvent->GetMagneticField();  // in kG 
   Double_t dz[2];   // error of dca in cm
   Double_t covardz[3];
   track->PropagateToDCA(primVtx,magneticField, 1000., dz, covardz); 

diff --git a/PWG3/hfe/AliHFEdisplacedElectrons.h b/PWG3/hfe/AliHFEdisplacedElectrons.h
index 88fe5749530c8bbaa8286f9c32b12fd6348cc0a6..8ab69284024e93fa7bbf2646447803a601759399 100644 (file)
--- a/PWG3/hfe/AliHFEdisplacedElectrons.h
+++ b/PWG3/hfe/AliHFEdisplacedElectrons.h
@@ -67,9 +67,9 @@ class AliHFEdisplacedElectrons : public TObject{
     kPDGbeauty = kBottom
   };  // PDG codes to be used
 
-  AliHFEdisplacedElectrons();
+  AliHFEdisplacedElectrons(); // default constructor
   AliHFEdisplacedElectrons(const AliHFEdisplacedElectrons &p); // copy constructor
-  AliHFEdisplacedElectrons &operator=(const AliHFEdisplacedElectrons &); // assignment operator
+  AliHFEdisplacedElectrons &operator=(const AliHFEdisplacedElectrons &ref); // assignment operator
 
   virtual ~AliHFEdisplacedElectrons();
 
@@ -120,9 +120,6 @@ class AliHFEdisplacedElectrons : public TObject{
   };   // several constant to be used
  
   UInt_t fDebugLevel;   // debug level
-  AliESDEvent* fESD;              //! ESD pointer              
-  AliMCEvent*  fMC;           //! MC event             
-  const AliESDVertex *fkVertex;    //! Primary vertex
 
   Int_t ElectronFromSource(AliStack *stack, Int_t eleLabel) const;
   Int_t ElePhotonDirect(AliStack *stack, Int_t label) const;
@@ -140,9 +137,9 @@ class AliHFEdisplacedElectrons : public TObject{
   static const Char_t *fgkKineVar[kNKineVar];  // particle names
   static const Char_t *fgkKineVarTitle[kNKineVar];  // particle names
 
-  THnSparseF *fTHnSparseDcaMcPionInfo;   //! container for MC part
-  THnSparseF *fTHnSparseDcaMcEleInfo;   //! container for MC part
-  THnSparseF *fTHnSparseDcaDataEleInfo; //! container for Data part
+  THnSparseF *fTHnSparseDcaMcPionInfo;   //! container for MC pion part
+  THnSparseF *fTHnSparseDcaMcEleInfo;   //! container for MC electron part
+  THnSparseF *fTHnSparseDcaDataEleInfo; //! container for Data electron part
 
   TList *fOutputList;  //! output container
   ClassDef(AliHFEdisplacedElectrons, 0);

diff --git a/PWG3/hfe/AliHFEefficiency.cxx b/PWG3/hfe/AliHFEefficiency.cxx
index 79c995c0c68b46dd8253f09eea558a36902b93ba..fac7f61e004ed0c0163961e164cd8fdaa9048a6a 100644 (file)
--- a/PWG3/hfe/AliHFEefficiency.cxx
+++ b/PWG3/hfe/AliHFEefficiency.cxx
@@ -31,7 +31,9 @@
 #include <TObjArray.h>
 #include <TPad.h>
 
+#include "AliAnalysisManager.h"
 #include "AliCFAcceptanceCuts.h"
+#include "AliCFTrackIsPrimaryCuts.h"
 #include "AliCFContainer.h"
 #include "AliCFEffGrid.h"
 #include "AliESDEvent.h"
@@ -43,6 +45,7 @@
 #include "AliHFEtrackFilter.h"
 #include "AliHFEtools.h"
 #include "AliMCEvent.h"
+#include "AliMCEventHandler.h"
 
 ClassImp(AliHFEefficiency)
 
@@ -120,6 +123,11 @@ void AliHFEefficiency::UserCreateOutputObjects(){
   AliHFEextraCuts *hfeitscuts = dynamic_cast<AliHFEextraCuts *>(hfeITS->GetCut("HFEPixelsCuts"));
   hfeitscuts->SetRequireITSpixel(AliHFEextraCuts::kFirst);
 
+  AliHFEcutStep *primary = fFilter->GetCutStep("Primary");
+  AliCFTrackIsPrimaryCuts *primcuts = dynamic_cast<AliCFTrackIsPrimaryCuts *>(primary->GetCut("PrimaryCuts"));
+  primcuts->SetMaxDCAToVertexXY(3);
+  primcuts->SetMaxDCAToVertexZ(5);
+
   fAcceptanceCuts = new AliCFAcceptanceCuts("Acceptance", "MC Acceptance Cuts");
   fAcceptanceCuts->SetMinNHitITS(3);
   fAcceptanceCuts->SetMinNHitTPC(2);
@@ -145,6 +153,10 @@ void AliHFEefficiency::UserExec(Option_t *){
   fEfficiency->NewEvent();
   fFilter->SetRecEvent(fInputEvent);
   if(fMCEvent){
+    AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
+    if(!mcH->InitOk()) return;
+    if(!mcH->TreeK()) return;
+    if(!mcH->TreeTR()) return;
     fFilter->SetMC(fMCEvent);
     FilterMC();
   }
@@ -161,9 +173,14 @@ void AliHFEefficiency::UserExec(Option_t *){
     else
       fOutput->Fill("itspixel",0);
     AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel())));
-    AliMCParticle *mother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(mctrack->Particle()->GetFirstMother()));
-    fOutput->Fill("mcmother", mother->Particle()->GetPdgCode());
-    fOutput->Fill("ptres", mctrack->Pt(), (track->Pt() - mctrack->Pt())/mctrack->Pt());
+    if(mctrack){
+      Int_t motherLabel = mctrack->Particle()->GetFirstMother();
+      if(motherLabel){
+        AliMCParticle *mother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(motherLabel));
+        fOutput->Fill("mcmother", mother->Particle()->GetPdgCode());
+      }
+      fOutput->Fill("ptres", mctrack->Pt(), (track->Pt() - mctrack->Pt())/mctrack->Pt());
+    }
   }
   delete iter;
   fFilter->Flush();

diff --git a/PWG3/hfe/AliHFEelecbackground.cxx b/PWG3/hfe/AliHFEelecbackground.cxx
index 41ebf552b29377bb662a977a0b9e404763d2bd81..b1b9d11660f7d6d288047aafb50e4b9f90c776ce 100644 (file)
--- a/PWG3/hfe/AliHFEelecbackground.cxx
+++ b/PWG3/hfe/AliHFEelecbackground.cxx
@@ -1064,7 +1064,7 @@ Bool_t AliHFEelecbackground::SingleTrackCut(AliESDtrack* const trackPart) const
     ////////////////////
     
     if(fRequireITSStandalone==1) {
-      if(((status & AliESDtrack::kITSin) == 0 || (trackPart->IsPureITSStandalone()) || (status&AliESDtrack::kITSrefit)==0)) return kFALSE;
+      if(((status & AliESDtrack::kITSin) == 0 || (trackPart->IsPureITSStandalone()) || status&AliESDtrack::kITSrefit==0)) return kFALSE;
     }
     
     if(fRequireITSStandalone==2) {

diff --git a/PWG3/hfe/AliHFEpidQA.cxx b/PWG3/hfe/AliHFEpidQA.cxx
index 838c30e9ed3dd61d12d2185d1dbb458be9212679..38b3a51cc06d08d026267de1a3ae9aa35fad46c0 100644 (file)
--- a/PWG3/hfe/AliHFEpidQA.cxx
+++ b/PWG3/hfe/AliHFEpidQA.cxx
@@ -136,14 +136,14 @@ void AliHFEpidQA::Init(){
  fOutput->BinLogAxis("hTPCnSigmaProton", 0);
 
   fOutput->CreateTH2F("hTPC_PID", "TPC pid all tracks; tpc pid probability; species",100, 0, 1, 5, -0.5, 4.5 );
-  fOutput->CreateTH2F("hTPC_PID_pt_Electron", "TPC PID for conversion electrons; pt (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTPC_PID_pt_Electron", 0);
-  fOutput->CreateTH2F("hTPC_PID_pt_PionK0", "TPC PID for K0 pions; pt (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTPC_PID_pt_PionK0", 0);
-  fOutput->CreateTH2F("hTPC_PID_pt_PionL", "TPC PID for Lambda pions; pt (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTPC_PID_pt_PionL", 0);
-  fOutput->CreateTH2F("hTPC_PID_pt_Proton", "TPC PID for Lambda protons; pt (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTPC_PID_pt_Proton", 0);
+  fOutput->CreateTH2F("hTPC_PID_p_Electron", "TPC PID for conversion electrons; p (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTPC_PID_p_Electron", 0);
+  fOutput->CreateTH2F("hTPC_PID_p_PionK0", "TPC PID for K0 pions; p (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTPC_PID_p_PionK0", 0);
+  fOutput->CreateTH2F("hTPC_PID_p_PionL", "TPC PID for Lambda pions; p (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTPC_PID_p_PionL", 0);
+  fOutput->CreateTH2F("hTPC_PID_p_Proton", "TPC PID for Lambda protons; p (GeV/c); TPC PID", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTPC_PID_p_Proton", 0);
 
 
   // TRD pid response
@@ -165,14 +165,14 @@ void AliHFEpidQA::Init(){
   
   fOutput->CreateTH2F("hTOF_PID", "TOF pid all tracks; tof pid probability; species",100, 0, 1,5,  -0.5, 4.5 );
 
-  fOutput->CreateTH2F("hTOF_PID_pt_Electron", "TOF PID for gamma converisons; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTOF_PID_pt_Electron", 0);
-  fOutput->CreateTH2F("hTOF_PID_pt_PionK0", "TOF PID for K0 pions; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTOF_PID_pt_PionK0", 0);
-  fOutput->CreateTH2F("hTOF_PID_pt_PionL", "TOF PID for Lambda pions; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTOF_PID_pt_PionL", 0);
-  fOutput->CreateTH2F("hTOF_PID_pt_Proton", "TOF PID for Lambda protons; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
-  fOutput->BinLogAxis("hTOF_PID_pt_Proton", 0);
+  fOutput->CreateTH2F("hTOF_PID_p_Electron", "TOF PID for gamma converisons; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTOF_PID_p_Electron", 0);
+  fOutput->CreateTH2F("hTOF_PID_p_PionK0", "TOF PID for K0 pions; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTOF_PID_p_PionK0", 0);
+  fOutput->CreateTH2F("hTOF_PID_p_PionL", "TOF PID for Lambda pions; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTOF_PID_p_PionL", 0);
+  fOutput->CreateTH2F("hTOF_PID_p_Proton", "TOF PID for Lambda protons; p_T (GeV/c); counts", 100, 0.1, 10, 5, -0.5, 4.5);
+  fOutput->BinLogAxis("hTOF_PID_p_Proton", 0);
 
   fOutput->CreateTH2F("hTOF_beta_Electron", "TOF beta for gamma conversions; #beta; p (GeV/c)", 120, 0, 1.2, 100, 0.1, 10);
   fOutput->BinLogAxis("hTOF_beta_Electron", 1);
@@ -399,7 +399,7 @@ void AliHFEpidQA::FillPIDresponse(TObjArray * const particles, Int_t species){
       
       // track kinematics
       Double_t p = tpcIn->P();
-      Double_t pt = tpcIn->Pt();
+      //Double_t pt = tpcIn->Pt();
 
       // TPC dEdx
       Double_t dEdx = esdTrack->GetTPCsignal();
@@ -407,12 +407,12 @@ void AliHFEpidQA::FillPIDresponse(TObjArray * const particles, Int_t species){
       fOutput->Fill(hname, p, dEdx);
 
       //TPC number of sigmas
-      Double_t nsigma = fESDpid->NumberOfSigmasTPC(esdTrack,(AliPID::EParticleType)species);
+      Double_t nsigma = fESDpid->NumberOfSigmasTPC(esdTrack,(AliPID::EParticleType)typePID[species]);
       sprintf(hname, "hTPCnSigma%s",  typeName[species]);
       fOutput->Fill(hname, p, nsigma);
 
       // TPC PID response
-      sprintf(hname, "hTPC_PID_pt_%s", typeName[species]);
+      sprintf(hname, "hTPC_PID_p_%s", typeName[species]);
       Double_t tpcPID[5] = {-1, -1, -1, -1, -1};
       esdTrack->GetTPCpid(tpcPID);
       Int_t ix = 0;
@@ -425,11 +425,11 @@ void AliHFEpidQA::FillPIDresponse(TObjArray * const particles, Int_t species){
        fOutput->Fill("hTPC_PID", tpcPID[k], k);
       }
       if(tpcPID[ix] > 0){
-       fOutput->Fill(hname, pt, ix);
+       fOutput->Fill(hname, p, ix);
       }
 
       // TOF PID response
-      sprintf(hname, "hTOF_PID_pt_%s", typeName[species]);
+      sprintf(hname, "hTOF_PID_p_%s", typeName[species]);
       Double_t tofPID[5] = {-1., -1., -1., -1., -1};
       esdTrack->GetTOFpid(tofPID);
       tmp = 0.;
@@ -442,7 +442,7 @@ void AliHFEpidQA::FillPIDresponse(TObjArray * const particles, Int_t species){
          fOutput->Fill("hTOF_PID", tofPID[k], k);
       }
       if(tofPID[ix] > 0){
-       fOutput->Fill(hname, pt, ix);
+       fOutput->Fill(hname, p, ix);
       }
       
       //TRD first electron only