Possibility to read as input the AOD that was just created from the ESD, in the same...
authordainese <dainese@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Oct 2009 20:15:52 +0000 (20:15 +0000)
committerdainese <dainese@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Oct 2009 20:15:52 +0000 (20:15 +0000)
PWG3/vertexingHF/AliAnalysisTaskSEBkgLikeSignD0.cxx
PWG3/vertexingHF/AliAnalysisTaskSEBkgLikeSignJPSI.cxx
PWG3/vertexingHF/AliAnalysisTaskSEBtoJPSItoEle.cxx
PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.cxx
PWG3/vertexingHF/AliAnalysisTaskSECompareHF.cxx
PWG3/vertexingHF/AliAnalysisTaskSED0Mass.cxx
PWG3/vertexingHF/AliAnalysisTaskSEDplus.cxx
PWG3/vertexingHF/AliAnalysisTaskSESelectHF.cxx
PWG3/vertexingHF/AliCFHeavyFlavourTaskMultiVarMultiStep.cxx

index 4756692..d7eceb4 100644 (file)
@@ -27,6 +27,8 @@
 #include <TList.h>
 #include <TH1F.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
@@ -216,29 +218,37 @@ void AliAnalysisTaskSEBkgLikeSignD0::UserExec(Option_t */*option*/)
   
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
-
-  // load heavy flavour vertices
-  TClonesArray *arrayVerticesHF =
-    (TClonesArray*)aod->GetList()->FindObject("VerticesHF");
-  if(!arrayVerticesHF) {
-    printf("AliAnalysisTaskSEBkgLikeSignD0::UserExec: VerticesHF branch not found!\n");
-    return;
+  TClonesArray *arrayD0toKpi = 0;
+  TClonesArray *arrayLikeSign = 0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      // load D0 candidates                                                   
+      arrayD0toKpi=(TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi");
+      // load like sign candidates
+      arrayLikeSign=(TClonesArray*)aodFromExt->GetList()->FindObject("LikeSign2Prong");
+    }
+  } else {
+    // load D0 candidates                                                   
+    arrayD0toKpi=(TClonesArray*)aod->GetList()->FindObject("D0toKpi");
+    // load like sign candidates
+    arrayLikeSign=(TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong");
   }
 
-  // load D0->ee candidates                                                   
-  TClonesArray *arrayD0toKpi =
-    (TClonesArray*)aod->GetList()->FindObject("D0toKpi");
+
   if(!arrayD0toKpi) {
     printf("AliAnalysisTaskSEBkgLikeSignD0::UserExec: D0toKpi branch not found!\n");
     return;
   }
-
-  // load like sign candidates
-  TClonesArray *arrayLikeSign =
-    (TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong");
   if(!arrayLikeSign) {
     printf("AliAnalysisTaskSEBkgLikeSignD0::UserExec: LikeSign2Prong branch not found!\n");
     return;
index afc482e..3c4e8f5 100644 (file)
@@ -28,6 +28,8 @@
 #include <TList.h>
 #include <TH1F.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
@@ -204,29 +206,37 @@ void AliAnalysisTaskSEBkgLikeSignJPSI::UserExec(Option_t */*option*/)
   
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
-
-  // load heavy flavour vertices
-  TClonesArray *arrayVerticesHF =
-    (TClonesArray*)aod->GetList()->FindObject("VerticesHF");
-  if(!arrayVerticesHF) {
-    printf("AliAnalysisTaskSEBkgLikeSignJPSI::UserExec: VerticesHF branch not found!\n");
-    return;
+  TClonesArray *arrayJPSItoEle = 0;
+  TClonesArray *arrayLikeSign = 0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      // load Jpsi candidates   
+      arrayJPSItoEle=(TClonesArray*)aodFromExt->GetList()->FindObject("JPSItoEle");
+      // load like sign candidates
+      arrayLikeSign=(TClonesArray*)aodFromExt->GetList()->FindObject("LikeSign2Prong");
+    }
+  } else {
+    // load Jpsi candidates                                                   
+    arrayJPSItoEle=(TClonesArray*)aod->GetList()->FindObject("JPSItoEle");
+    // load like sign candidates
+    arrayLikeSign=(TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong");
   }
 
-  // load JPSI->ee candidates                                                   
-  TClonesArray *arrayJPSItoEle =
-    (TClonesArray*)aod->GetList()->FindObject("JPSItoEle");
+
   if(!arrayJPSItoEle) {
     printf("AliAnalysisTaskSEBkgLikeSignJPSI::UserExec: JPSItoEle branch not found!\n");
     return;
   }
-
-  // load like sign candidates
-  TClonesArray *arrayLikeSign =
-    (TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong");
   if(!arrayLikeSign) {
     printf("AliAnalysisTaskSEBkgLikeSignJPSI::UserExec: LikeSign2Prong branch not found!\n");
     return;
index 44e5892..0c37c97 100644 (file)
@@ -28,6 +28,8 @@ class TROOT;
 #include <TClonesArray.h>
 #include <TDatabasePDG.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODMCParticle.h"
 #include "AliAODMCHeader.h"
@@ -166,21 +168,35 @@ void AliAnalysisTaskSEBtoJPSItoEle::UserExec(Option_t */*option*/)
 
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
+  TClonesArray *inputArrayJPSItoEle = 0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      // load Jpsi candidates   
+      inputArrayJPSItoEle=(TClonesArray*)aodFromExt->GetList()->FindObject("JPSItoEle");
+    }
+  } else {
+    // load Jpsi candidates                                                   
+    inputArrayJPSItoEle=(TClonesArray*)aod->GetList()->FindObject("JPSItoEle");
+  }
 
-  // AOD primary vertex
-  AliAODVertex *vtx1 = (AliAODVertex*)aod->GetPrimaryVertex();
-  
-  // load JPSI candidates                                                   
-  TClonesArray *inputArrayJPSItoEle =
-    (TClonesArray*)aod->GetList()->FindObject("JPSItoEle");
   if(!inputArrayJPSItoEle) {
     printf("AliAnalysisTaskSECompareHF::UserExec: JPSItoEle branch not found!\n");
     return;
   } 
 
+  // AOD primary vertex
+  AliAODVertex *vtx1 = (AliAODVertex*)aod->GetPrimaryVertex();
+  
   // load MC particles
   TClonesArray* mcArray = 
      dynamic_cast<TClonesArray*>(aod->FindListObject(AliAODMCParticle::StdBranchName()));
index 5bfb588..5dc1d32 100644 (file)
@@ -28,6 +28,9 @@
 #include <TDatabasePDG.h>
 #include <TMath.h>
 #include <TROOT.h>
+
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODRecoDecayHF2Prong.h"
 #include "AliAODRecoDecayHF.h"
@@ -2538,13 +2541,25 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/)
   
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
+  TClonesArray *arrayD0toKpi=0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      arrayD0toKpi=(TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi");
+    }
+  } else {
+    arrayD0toKpi=(TClonesArray*)aod->GetList()->FindObject("D0toKpi");
+  }
 
-  // load D0->Kpi candidates                                                   
-  TClonesArray *arrayD0toKpi =
-    (TClonesArray*)aod->GetList()->FindObject("D0toKpi");
   if(!arrayD0toKpi) {
     Printf("AliAnalysisTaskSECharmFraction::UserExec: D0toKpi branch not found!\n");
     return;
index 5451541..de32976 100644 (file)
@@ -26,6 +26,8 @@
 #include <TList.h>
 #include <TH1F.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliESDtrack.h"
@@ -136,41 +138,57 @@ void AliAnalysisTaskSECompareHF::UserExec(Option_t */*option*/)
 
   
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
-  
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
 
-  fHistNEvents->Fill(0); // count event
-  // Post the data already here
-  PostData(1,fOutput);
+  TClonesArray *inputArrayVertices = 0;
+  TClonesArray *inputArrayD0toKpi = 0;
+  TClonesArray *inputArrayDstar = 0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      // load HF vertices                
+      inputArrayVertices = (TClonesArray*)aodFromExt->GetList()->FindObject("VerticesHF");
+      // load D0->Kpi candidates
+      inputArrayD0toKpi = (TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi");
+      // load D*+ candidates                                                   
+      inputArrayDstar = (TClonesArray*)aodFromExt->GetList()->FindObject("Dstar");
+    }
+  } else {
+    // load HF vertices                
+    inputArrayVertices = (TClonesArray*)aod->GetList()->FindObject("VerticesHF");
+    // load D0->Kpi candidates                                                 
+    inputArrayD0toKpi = (TClonesArray*)aod->GetList()->FindObject("D0toKpi");
+    // load D*+ candidates                                                   
+    inputArrayDstar = (TClonesArray*)aod->GetList()->FindObject("Dstar");
+  }
+
 
-  // load HF vertices                     
-  TClonesArray *inputArrayVertices =
-    (TClonesArray*)aod->GetList()->FindObject("VerticesHF");
   if(!inputArrayVertices) {
     printf("AliAnalysisTaskSECompareHF::UserExec: Vertices branch not found!\n");
     return;
   }
-
-  // load D0->Kpi candidates                                                   
-  TClonesArray *inputArrayD0toKpi =
-    (TClonesArray*)aod->GetList()->FindObject("D0toKpi");
   if(!inputArrayD0toKpi) {
     printf("AliAnalysisTaskSECompareHF::UserExec: D0toKpi branch not found!\n");
     return;
   }
-
-  // load D*+ candidates                                                   
-  TClonesArray *inputArrayDstar =
-    (TClonesArray*)aod->GetList()->FindObject("Dstar");
   if(!inputArrayDstar) {
     printf("AliAnalysisTaskSECompareHF::UserExec: Dstar branch not found!\n");
     return;
   }
   
 
+  fHistNEvents->Fill(0); // count event
+  // Post the data already here
+  PostData(1,fOutput);
+
   // AOD primary vertex
   AliAODVertex *vtx1 = (AliAODVertex*)aod->GetPrimaryVertex();
   //vtx1->Print();
index 5b7d67c..532040e 100644 (file)
@@ -31,6 +31,8 @@
 #include <TH2F.h>
 #include <TDatabasePDG.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
@@ -42,6 +44,7 @@
 #include "AliAnalysisTaskSE.h"
 #include "AliAnalysisTaskSED0Mass.h"
 
+
 ClassImp(AliAnalysisTaskSED0Mass)
 
 
@@ -301,33 +304,40 @@ void AliAnalysisTaskSED0Mass::UserExec(Option_t */*option*/)
   //cout<<"I'm in UserExec"<<endl;
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
-
-  TClonesArray *inputArray=0;
-
+  TString bname;
   if(fArray==0){ //D0 candidates
-    // load D0->Kpi candidates                                                   
+    // load D0->Kpi candidates
     //cout<<"D0 candidates"<<endl;
-    inputArray =
-      (TClonesArray*)aod->GetList()->FindObject("D0toKpi");
-    if(!inputArray) {
-      printf("AliAnalysisTaskSECompareHFpt::UserExec: D0toKpi branch not found!\n");
-      return;
-    }
-
+    bname="D0toKpi";
   } else { //LikeSign candidates
-
-    //cout<<"LS candidates"<<endl;
     // load like sign candidates
-    inputArray =
-      (TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong");
-    if(!inputArray) {
-      printf("AliAnalysisTaskSEBkgLikeSignD0::UserExec: LikeSign2Prong branch not found!\n");
-      return;
+    //cout<<"LS candidates"<<endl;
+    bname="LikeSign2Prong";
+  }
+
+  TClonesArray *inputArray=0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      inputArray=(TClonesArray*)aodFromExt->GetList()->FindObject(bname.Data());
     }
+  } else {
+    inputArray=(TClonesArray*)aod->GetList()->FindObject(bname.Data());
+  }
 
+
+  if(!inputArray) {
+    printf("AliAnalysisTaskSED0Mass::UserExec: input branch not found!\n");
+    return;
   }
   
   // AOD primary vertex
@@ -350,6 +360,7 @@ void AliAnalysisTaskSED0Mass::UserExec(Option_t */*option*/)
     return;
   }
   
+  //printf("VERTEX Z %f %f\n",vtx1->GetZ(),mcHeader->GetVtxZ());
 
   //histogram filled with 1 for every AOD
   fNentries->Fill(1);
@@ -369,8 +380,6 @@ void AliAnalysisTaskSED0Mass::UserExec(Option_t */*option*/)
       unsetvtx=kTRUE;
     }
     
-
-
     //check reco daughter in acceptance
     Double_t eta0=d->EtaProng(0);
     Double_t eta1=d->EtaProng(1);
index 2a9762d..6de9716 100644 (file)
@@ -25,6 +25,9 @@
 #include <TList.h>
 #include <TString.h>
 #include <TH1F.h>
+
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
@@ -166,13 +169,25 @@ void AliAnalysisTaskSEDplus::UserExec(Option_t */*option*/)
   
   AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aod && AODEvent() && IsStandardAOD()) aod = dynamic_cast<AliAODEvent*> (AODEvent());
+  TClonesArray *array3Prong = 0;
+
+  if(!aod && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aod = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      array3Prong=(TClonesArray*)aodFromExt->GetList()->FindObject("Charm3Prong");
+    }
+  } else {
+    array3Prong=(TClonesArray*)aod->GetList()->FindObject("Charm3Prong");
+  }
 
-  // load Dplus->Kpipi candidates                                                   
-  TClonesArray *array3Prong =
-    (TClonesArray*)aod->GetList()->FindObject("Charm3Prong");
   if(!array3Prong) {
     printf("AliAnalysisTaskSEDplus::UserExec: Charm3Prong branch not found!\n");
     return;
index 878d08b..053f968 100644 (file)
@@ -23,6 +23,8 @@
 
 #include <TClonesArray.h>
 
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
@@ -107,13 +109,27 @@ void AliAnalysisTaskSESelectHF::UserExec(Option_t */*option*/)
   
   AliAODEvent *aodIn = dynamic_cast<AliAODEvent*> (InputEvent());
 
-  // In case there is an AOD handler writing a standard AOD, use the AOD 
-  // event in memory rather than the input (ESD) event.
-  if (!aodIn && AODEvent() && IsStandardAOD()) aodIn = dynamic_cast<AliAODEvent*> (AODEvent());
+  TClonesArray *inputArrayD0toKpi = 0;
+
+  if(!aodIn && AODEvent() && IsStandardAOD()) {
+    // In case there is an AOD handler writing a standard AOD, use the AOD 
+    // event in memory rather than the input (ESD) event.    
+    aodIn = dynamic_cast<AliAODEvent*> (AODEvent());
+    // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+    // have to taken from the AOD event hold by the AliAODExtension
+    AliAODHandler* aodHandler = (AliAODHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+    if(aodHandler->GetExtensions()) {
+      AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+      AliAODEvent *aodFromExt = ext->GetAOD();
+      // load D0 candidates                                                   
+      inputArrayD0toKpi=(TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi");
+    }
+  } else {
+    // load D0 candidates                                                   
+    inputArrayD0toKpi=(TClonesArray*)aodIn->GetList()->FindObject("D0toKpi");
+  }
 
-  // load D0->Kpi candidates                                                   
-  TClonesArray *inputArrayD0toKpi =
-    (TClonesArray*)aodIn->GetList()->FindObject("D0toKpi");
   if(!inputArrayD0toKpi) {
     printf("AliAnalysisTaskSESelectHF::UserExec: D0toKpi branch not found!\n");
     return;
index d0b6e4e..8bc72f9 100644 (file)
@@ -41,6 +41,8 @@
 #include "AliCFManager.h"
 #include "AliCFContainer.h"
 #include "AliLog.h"
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
 #include "AliAODEvent.h"
 #include "AliAODRecoDecay.h"
 #include "AliAODRecoDecayHF.h"
@@ -176,9 +178,33 @@ void AliCFHeavyFlavourTaskMultiVarMultiStep::UserExec(Option_t *)
        fEvents++;
        if (fEvents%10000 ==0) AliDebug(2,Form("Event %d",fEvents));
        AliAODEvent* aodEvent = dynamic_cast<AliAODEvent*>(fInputEvent);
-       // In case there is an AOD handler writing a standard AOD, use the AOD 
-       // event in memory rather than the input (ESD) event.
-       if (!aodEvent && AODEvent() && IsStandardAOD()) aodEvent = dynamic_cast<AliAODEvent*> (AODEvent());
+
+       TClonesArray *arrayD0toKpi=0;
+
+       if(!aodEvent && AODEvent() && IsStandardAOD()) {
+         // In case there is an AOD handler writing a standard AOD, use the AOD 
+         // event in memory rather than the input (ESD) event.    
+         aodEvent = dynamic_cast<AliAODEvent*> (AODEvent());
+         // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
+         // have to taken from the AOD event hold by the AliAODExtension
+         AliAODHandler* aodHandler = (AliAODHandler*) 
+           ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+         if(aodHandler->GetExtensions()) {
+           AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
+           AliAODEvent *aodFromExt = ext->GetAOD();
+           arrayD0toKpi=(TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi");
+         }
+       } else {
+         arrayD0toKpi=(TClonesArray*)aodEvent->GetList()->FindObject("D0toKpi");
+       }
+
+
+       if (!arrayD0toKpi) {
+         AliError("Could not find array of HF vertices");
+         return;
+       }
+
+
        fCFManager->SetEventInfo(aodEvent);
        
        // MC-event selection
@@ -335,9 +361,6 @@ void AliCFHeavyFlavourTaskMultiVarMultiStep::UserExec(Option_t *)
        fCountMC += icountMC;
        fCountAcc += icountAcc;
 
-       // load heavy flavour vertices
-       TClonesArray *arrayD0toKpi = (TClonesArray*)((aodEvent->GetList())->FindObject("D0toKpi"));     
-       if (!arrayD0toKpi) AliError("Could not find array of HF vertices");
        AliDebug(2, Form("Found %d vertices",arrayD0toKpi->GetEntriesFast()));
 
        Int_t pdgDgD0toKpi[2]={321,211};