void AliAnalysisTaskSEVertexingHFTest()
{
  //
  // Test macro for the AliAnalysisTaskSE for heavy-flavour vertexing
  // A.Dainese, andrea.dainese@lnl.infn.it
  //

  Bool_t inputAOD=kTRUE; // otherwise, ESD
  Bool_t createAOD=kFALSE; // kTRUE: create AOD and use it as input to vertexing
                          // kFALSE: use ESD as input to vertexing
  Bool_t writeKineToAOD = kTRUE;
  TString mode="local"; // otherwise, "grid" 
  Bool_t useParFiles=kFALSE;

  gROOT->LoadMacro("$ALICE_ROOT/PWG3/vertexingHF/LoadLibraries.C");
  LoadLibraries(useParFiles);

  TChain *chain = 0;

  if(mode=="local") {
    // Local files 
    TString treeName,fileName;
    if(inputAOD) {
      treeName="aodTree"; 
      fileName="AliAOD.root";
    } else {
      treeName="esdTree"; 
      fileName="AliESDs.root";
    }
    chain = new TChain(treeName.Data());
    chain->Add(fileName.Data());

  } else if (mode=="grid") {
    //Fetch files with AliEn :
    const char *collectionfile = "Collection.xml";
    TGrid::Connect("alien://") ;
    TAlienCollection *coll   = TAlienCollection::Open(collectionfile);
    if(inputAOD) { // input AOD
      chain = new TChain("aodTree");
      while(coll->Next()) chain->Add(coll->GetTURL(""));
    } else { // input ESD
      //Create an AliRunTagCuts and an AliEventTagCuts Object and impose some selection criteria
      AliRunTagCuts      *runCuts   = new AliRunTagCuts();
      AliEventTagCuts    *eventCuts = new AliEventTagCuts();
      AliLHCTagCuts      *lhcCuts   = new AliLHCTagCuts();
      AliDetectorTagCuts *detCuts   = new AliDetectorTagCuts();
      eventCuts->SetMultiplicityRange(0,20000);
      //Create an AliTagAnalysis Object and chain the tags
      AliTagAnalysis   *tagAna = new AliTagAnalysis();
      tagAna->SetType("ESD");
      TGridResult      *tagResult = coll->GetGridResult("",0,0);
      tagResult->Print();
      tagAna->ChainGridTags(tagResult);
      //Create a new esd chain and assign the chain that is returned by querying the tags
      chain = tagAna->QueryTags(runCuts,lhcCuts,detCuts,eventCuts);
    }
  } else {
    printf("ERROR: mode has to be \"local\" or \"grid\" \n");
    return;
  }


  // Create the analysis manager
  AliAnalysisManager *mgr  = new AliAnalysisManager("My Manager","My Manager");
  mgr->SetDebugLevel(10);
  
  // Input Handler
  AliInputEventHandler *inputHandler = 0;
  if(inputAOD) {
    inputHandler = new AliAODInputHandler();
  } else {
    inputHandler = new AliESDInputHandler();
  }
  mgr->SetInputEventHandler(inputHandler);
  
  // Output 
  AliAODHandler *aodHandler = new AliAODHandler();
  const char* deltaAODfname="AliAOD.VertexingHF.root";
  if(createAOD) {
    aodHandler->SetOutputFileName("AliAOD.root");
  } else {
    aodHandler->SetFillAOD(kFALSE);
    aodHandler->SetOutputFileName(deltaAODfname);
    aodHandler->SetCreateNonStandardAOD();
  }
  mgr->SetOutputEventHandler(aodHandler);
  mgr->RegisterExtraFile(deltaAODfname);  

  if(!inputAOD && createAOD) {
    // MC Truth
    AliMCEventHandler* mcHandler = new AliMCEventHandler();
    if(writeKineToAOD) mgr->SetMCtruthEventHandler(mcHandler);
    AliAnalysisTaskMCParticleFilter *kinefilter = new AliAnalysisTaskMCParticleFilter("Particle Filter");
    if(writeKineToAOD) mgr->AddTask(kinefilter);  
    // Barrel Tracks
    AliAnalysisTaskESDfilter *filter = new AliAnalysisTaskESDfilter("Filter");
    mgr->AddTask(filter);

    AliESDtrackCuts* esdTrackCutsHF = new AliESDtrackCuts("AliESDtrackCuts", "Heavy flavour");
    esdTrackCutsHF->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
    
    AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
    trackFilter->AddCuts(esdTrackCutsHF);

    filter->SetTrackFilter(trackFilter);
   
    // Pipelining
    mgr->ConnectInput(filter,0,mgr->GetCommonInputContainer());
    mgr->ConnectOutput(filter,0,mgr->GetCommonOutputContainer());
    if(writeKineToAOD) {
      mgr->ConnectInput(kinefilter,0,mgr->GetCommonInputContainer());
      mgr->ConnectOutput(kinefilter,0,mgr->GetCommonOutputContainer());
    }
 
  }

  // Vertexing analysis task    
  gROOT->LoadMacro("$ALICE_ROOT/PWG3/vertexingHF/AddTaskVertexingHF.C");
  AliAnalysisTaskSEVertexingHF *hfTask = AddTaskVertexingHF(deltaAODfname);
  
  
  //
  // Run the analysis
  //    
  printf("CHAIN HAS %d ENTRIES\n",(Int_t)chain->GetEntries());
  if(!mgr->InitAnalysis()) return;

  mgr->PrintStatus();

  TStopwatch watch;
  watch.Start();
  mgr->StartAnalysis(mode.Data(),chain);
  watch.Stop();
  watch.Print();

  return;
}