Tasks for comparing ESD and AOD information (Mercedes)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Sep 2008 16:27:52 +0000 (16:27 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 10 Sep 2008 16:27:52 +0000 (16:27 +0000)
PWG3/READMEmuon
PWG3/muon/AliAnalysisTaskAODvsESD.cxx [new file with mode: 0644]
PWG3/muon/AliAnalysisTaskAODvsESD.h [new file with mode: 0644]
PWG3/muon/AnalysisTrainMuonComp.C [new file with mode: 0644]
PWG3/muon/AnalysisTrainMuonCompLocal.C [new file with mode: 0644]

index b42cc9e..77b5dcb 100644 (file)
@@ -1,42 +1,15 @@
 ===================================================
-  Code to include the muon information in the 
-  creation of the standard AOD from the ESD
-  Roberta ARNALDI, Enrico SCOMPARIN Torino
+  ESDMuonFilter task for filling the muon information in the AOD from the ESD
+  Roberta ARNALDI, Torino
 ---------------------------------------------------------------
 
-Code to copy the muon information from the ESD to the standard AOD. 
-
-1) AnalysisTrainMuonLocal.C --> macro to run locally the AliAnalysisTaskESDMuonFilter. 
-                                It creates a standard AOD from the ESD
-2) AliAnalysisTaskESDMuonFilter.h  --> analysis task to copy the muon information from the ESD to the standard AOD
-3) AliAnalysisTaskESDMuonFilter.cxx --> analysis task to copy the muon information from the ESD to the standard AOD
+1) AnalysisTrainMuonLocal.C --> macro to run locally the AliAnalysisTaskESDMuonFilter
+2) AliAnalysisTaskESDMuonFilter.h  --> analysis task to produce the Muon AOD from ESD
+3) AliAnalysisTaskESDMuonFilter.cxx --> analysis task to produce the Muon AOD from ESD
 4) libPWG3muon.pkg
 5) PWG3muonLinkDef.h 
 
 ===================================================
-  Creation of the MUON-AOD from the standard AOD
-  Roberta ARNALDI, Enrico SCOMPARIN Torino
----------------------------------------------------------------
-
-Code to produce a muon-AOD, i.e. a replica of the standard AOD containing only events where 
-at least one muon is present
-
-1) AnalysisTrainFromStandardToMuonAODLocal.C --> macro to produce the MUON-AOD (it runs locally)
-2) AliAnalysisTaskFromStandardToMuonAOD.h  --> analysis task to replicate the AOD content for interesting events
-3) AliAnalysisTaskFromStandardToMuonAOD.cxx --> analysis task to replicate the AOD content for interesting events
-4) libPWG3muon.pkg
-5) PWG3muonLinkDef.h 
-
-- The input files are the ESD (used only for tag creation) and the standard AOD.
-  Tags files are created from all the ESD/AOD files placed in a directory,  
-  given as an argument to the macro, and in its subdirectories.
-- The selection of the muon events is based on the AOD tags.
-- The contents of the MUON-AOD can be defined by the user in the AnalysisTrainFromStandardToMuonAODLocal.C
-  macro with some settings as
-  SetNeedsTracksBranchReplication(), SetNeedsVerticesBranchReplication() 
-  (defined in STEER/AliAODHandler.h)...
-
-===================================================
   Calculation of the LUT 
   Bogdan VULPESCU, Clermont
 ---------------------------------------------------------------
@@ -114,3 +87,48 @@ The macro creates the file MUON.TriggerEfficiencyMap.root
 aliroot
 AliMUONTriggerEfficiencyCells effCells("MUON.TriggerEfficiencyMap.root")
 effCells.DisplayEfficiency()
+
+===================================================
+ Analysis task for checking the consistency of ESD and AOD filling and contents.
+ Mercedes LOPEZ NORIEGA, Orsay
+----------------------------------------------------------------
+
+Purpose:check the consistency between the ESDs and the AOD.
+
+The task works locally and on the grid, there are two macros depending where
+you want to run
+
+Files:
+AliAnalysisTaskAODvsESD.cxx   -source files of the analysis task
+AliAnalysisTaskAODvsESD.h
+
+AnalysisTrainMuonComp.C       - macro for analysis on the grid
+AnalysisTrainMuonCompLocal.C  - macro for local analysis
+
+To run the check:
+1. Copy the following packages in the current working directory
+  - STEERBase.par
+  - ESD.par
+  - AOD.par
+  - ANALYSIS.par
+  - ANALYSISalice.par
+  - PWG3muon.par
+
+2. To run locally:
+  root
+  .x AnalysisTrainMuonCompLocal.C
+
+  by default the macro searches for a tag file of ESDs in the 
+  working directory
+
+3. To run on the grid:
+  root
+  .x AnalysisTrainMuonComp.C
+
+  by default the macro searches for a wn.xml in the current directory, with the list
+  of grid files to analyse.
+
+4. Display results:
+The macro creates the file AODvsESDoutput.root
+It contains an Ntuple from the ESDs and Ntuple from the AODs and an inv. mass histo 
+for each case
diff --git a/PWG3/muon/AliAnalysisTaskAODvsESD.cxx b/PWG3/muon/AliAnalysisTaskAODvsESD.cxx
new file mode 100644 (file)
index 0000000..fe88a11
--- /dev/null
@@ -0,0 +1,236 @@
+#include "TChain.h"
+#include "TTree.h"
+#include "TNtuple.h"
+#include "TBranch.h"
+#include "TH1F.h"
+#include "TCanvas.h"
+#include <TLorentzVector.h>
+#include <TVector3.h>
+
+#include "AliAnalysisTask.h"
+#include "AliAnalysisManager.h"
+#include "AliESDInputHandler.h"
+#include "AliESDEvent.h"
+#include "AliESDMuonTrack.h"
+#include "AliAODInputHandler.h"
+#include "AliAODHandler.h"
+#include "AliAODEvent.h"
+#include "AliAnalysisTaskAODvsESD.h"
+
+ClassImp(AliAnalysisTaskAODvsESD)
+
+//________________________________________________________________________
+AliAnalysisTaskAODvsESD::AliAnalysisTaskAODvsESD(const char *name) 
+: AliAnalysisTask(name, ""), fESD(0), fAOD(0), fList(0), fMuonNtuple(0), fMuonNtupleAOD(0), fInvMass(0), fInvMassAOD(0)
+{
+  // Constructor
+  // Define input and output slots here
+  // Input slot #0 works with a TChain
+  DefineInput(0, TChain::Class());
+  // Output slot #0 writes NTuple/histos into a TList
+  DefineOutput(0, TList::Class());  
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODvsESD::ConnectInputData(Option_t *) 
+{
+  // Connect ESD here
+  TTree* esdTree = dynamic_cast<TTree*> (GetInputData(0));
+  if (!esdTree) {
+    Printf("ERROR: Could not read chain from input slot 0");
+  } else {
+    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());   
+    if (!esdH) {
+      Printf("ERROR: Could not get ESDInputHandler");
+    } else
+      fESD = esdH->GetEvent();
+  }  
+
+  // Connect AOD here
+  AliAODHandler *aodH = dynamic_cast<AliAODHandler*> (AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());  
+  if (!aodH) {
+    Printf("ERROR: Could not get AODHandler");
+  } else
+    fAOD = aodH->GetAOD();
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODvsESD::CreateOutputObjects()
+{
+  // This method has to be called INSIDE the user redefined CreateOutputObjects
+  // method, before creating each object corresponding to the output containers
+  // that are to be written to a file. This need to be done in general for the big output
+  // objects that may not fit memory during processing. 
+  OpenFile(0); 
+
+  // Create Ntuples 
+  // For single muons: thetaX, thetaY, ptInv, eta, phi, theta, px, py, pz,ch
+  fMuonNtuple = new TNtuple("fMuonNtuple","Muon information","thX:thY:ptI:eta:phi:theta:px:py:pz");
+  fMuonNtupleAOD = new TNtuple("fMuonNtupleAOD","Muon information","etaAOD:phiAOD:thetaAOD:pxAOD:pyAOD:pzAOD");
+  // Create histos for inv mass
+  fInvMass = new TH1F("fInvMass","Inv. mass from ESDs",140,0,7);
+  fInvMassAOD = new TH1F("fInvMassAOD","Inv. mass from AOD",140,0,7);
+
+  // Add Ntuples to the list
+  fList = new TList();
+  fList->Add(fMuonNtuple);
+  fList->Add(fMuonNtupleAOD);
+  fList->Add(fInvMass);
+  fList->Add(fInvMassAOD);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODvsESD::Exec(Option_t *) 
+{
+  // Main loop, called for each event
+  if (!fESD) {
+    Printf("ERROR: fESD not available");
+    return;
+  }
+  if (!fAOD) {
+    Printf("ERROR: fAOD not available");
+    return;
+  }
+  
+  // ESDs
+  // for muons
+  Float_t muonMass = 0.105658369;
+  Float_t thetaX1=0;    Float_t thetaY1=0;
+  Float_t ptInv1=0;     Float_t pYZ1=0;
+  Float_t pxM1=0;       Float_t pyM1=0;        Float_t pzM1=0;
+  Float_t etaM1=0;      Float_t phiM1=0;       Float_t thetaM1=0;
+  Int_t chargeM1=0;      Float_t energyM1=0;    TLorentzVector lvM1;
+  Float_t thetaX2=0;    Float_t thetaY2=0;
+  Float_t ptInv2=0;     Float_t pYZ2=0;
+  Float_t pxM2=0;       Float_t pyM2=0;        Float_t pzM2=0;
+  Int_t chargeM2=0;      Float_t energyM2=0;    TLorentzVector lvM2;
+  //for J/psi
+  Float_t invM=0;
+  TLorentzVector lvJpsi;
+  int nmt = fESD->GetNumberOfMuonTracks();
+  // first loop over muon tracks in event
+  for (Int_t mTrack = 0; mTrack < nmt; mTrack++) {
+    thetaX1=0; thetaY1=0; ptInv1=0; pYZ1=0; chargeM1=0;
+    pxM1=0;    pyM1=0;    pzM1=0;   energyM1=0;
+    AliESDMuonTrack* muonTrack1 = fESD->GetMuonTrack(mTrack);
+    thetaX1 = muonTrack1->GetThetaX();
+    thetaY1 = muonTrack1->GetThetaY();
+    ptInv1 = TMath::Abs(muonTrack1->GetInverseBendingMomentum());
+    pYZ1 = 1/ptInv1;
+    pzM1  = - pYZ1 / TMath::Sqrt(1.0 + TMath::Tan(thetaY1)*TMath::Tan(thetaY1));
+    pxM1  = pzM1 * TMath::Tan(thetaX1);
+    pyM1  = pzM1 * TMath::Tan(thetaY1);
+    energyM1 = TMath::Sqrt(muonMass*muonMass + pxM1*pxM1 + pyM1*pyM1 + pzM1*pzM1);
+    lvM1.SetPxPyPzE(pxM1,pyM1,pzM1,energyM1);
+    chargeM1 = Int_t(TMath::Sign(1.,muonTrack1->GetInverseBendingMomentum()));      
+    etaM1 = muonTrack1->Eta();
+    phiM1 = muonTrack1->Phi();
+    thetaM1 = muonTrack1->Theta();
+    fMuonNtuple->Fill(thetaX1,thetaY1,ptInv1,etaM1,phiM1,thetaM1,pxM1,pyM1,pzM1);
+    // second loop over muon tracks in event
+    for (Int_t mTrack2 = mTrack+1; mTrack2 < nmt; mTrack2++) {
+      thetaX2=0; thetaY2=0; ptInv2=0; pYZ2=0; chargeM2=0;
+      pxM2=0; pyM2=0; pzM2=0; energyM2=0;
+      AliESDMuonTrack* muonTrack2 = fESD->GetMuonTrack(mTrack2);
+      thetaX2 = muonTrack2->GetThetaX();
+      thetaY2 = muonTrack2->GetThetaY();
+      ptInv2 = TMath::Abs(muonTrack2->GetInverseBendingMomentum());
+      pYZ2 = 1/ptInv2;
+      pzM2  = - pYZ2 / TMath::Sqrt(1.0 + TMath::Tan(thetaY2)*TMath::Tan(thetaY2));
+      pxM2  = pzM2 * TMath::Tan(thetaX2);
+      pyM2  = pzM2 * TMath::Tan(thetaY2);
+      chargeM2 = Int_t(TMath::Sign(1.,muonTrack2->GetInverseBendingMomentum()));      
+      energyM2 = TMath::Sqrt(muonMass*muonMass + pxM2*pxM2 + pyM2*pyM2 + pzM2*pzM2);
+      // if muons have opposite charge
+      if(chargeM1*chargeM2 == -1){
+       lvM2.SetPxPyPzE(pxM2, pyM2, pzM2,energyM2);
+       lvJpsi = lvM1 + lvM2;
+       invM = lvJpsi.M();
+       fInvMass->Fill(invM);
+      } // end if muons with opposite charge
+    } // end second loop over muon tracks in event
+  } // end first loop over muon tracks in event
+
+
+  // Created AOD
+  Float_t pxAodM1=0;   Float_t pyAodM1=0;     Float_t pzAodM1=0;
+  Float_t etaAodM1=0;  Float_t phiAodM1=0;    Float_t thetaAodM1=0;
+  Int_t chargeAodM1=0;  Float_t energyAodM1=0; TLorentzVector lvAodM1;
+  Float_t pxAodM2=0;   Float_t pyAodM2=0;     Float_t pzAodM2=0;
+  Float_t etaAodM2=0;  Float_t phiAodM2=0;    Float_t thetaAodM2=0;
+  Int_t chargeAodM2=0;  Float_t energyAodM2=0; TLorentzVector lvAodM2;
+  //for J/psi
+  Float_t invMAOD=0;
+  TLorentzVector lvJpsiAOD;
+
+  int nmtAOD = fAOD->GetNumberOfTracks();
+  // first loop over tracks
+  for (Int_t mTrack = 0; mTrack < nmtAOD; mTrack++) {
+    pxM1=0; pyM1=0; pzM1=0; 
+    AliAODTrack* muonTrack1 = fAOD->GetTrack(mTrack);
+    if(muonTrack1->IsMuonTrack()){
+      etaAodM1 = muonTrack1->Eta();
+      phiAodM1 = muonTrack1->Phi();
+      thetaAodM1 = muonTrack1->Theta();
+      pxAodM1 = muonTrack1->Px();
+      pyAodM1 = muonTrack1->Py();
+      pzAodM1 = muonTrack1->Pz();
+      chargeAodM1 = muonTrack1->Charge();
+      energyAodM1 = TMath::Sqrt(muonMass*muonMass + pxAodM1*pxAodM1 + pyAodM1*pyAodM1 + pzAodM1*pzAodM1);
+      lvAodM1.SetPxPyPzE(pxAodM1, pyAodM1, pzAodM1,energyAodM1);
+      fMuonNtupleAOD->Fill(etaAodM1,phiAodM1,thetaAodM1,pxAodM1,pyAodM1,pzAodM1);
+    }
+    // second loop over tracks in event
+    for (Int_t mTrack2 = mTrack+1; mTrack2 < nmtAOD; mTrack2++) {
+      chargeAodM2=0;
+      pxAodM2=0; pyAodM2=0; pzAodM2=0; energyAodM2=0;
+      AliAODTrack* muonTrack2 = fAOD->GetTrack(mTrack2);
+      if(muonTrack2->IsMuonTrack()){
+       etaAodM2 = muonTrack2->Eta();
+       phiAodM2 = muonTrack2->Phi();
+       thetaAodM2 = muonTrack2->Theta();
+       pxAodM2 = muonTrack2->Px();
+       pyAodM2 = muonTrack2->Py();
+       pzAodM2 = muonTrack2->Pz();
+       energyAodM2 = TMath::Sqrt(muonMass*muonMass + pxAodM2*pxAodM2 + pyAodM2*pyAodM2 + pzAodM2*pzAodM2);
+       chargeAodM2 = muonTrack2->Charge();
+       // if muons of opposite charge
+       if(chargeAodM1*chargeAodM2 == -1){
+         lvAodM2.SetPxPyPzE(pxAodM2, pyAodM2, pzAodM2,energyAodM2);
+         lvJpsiAOD = lvAodM1 + lvAodM2;
+         invMAOD = lvJpsiAOD.M();
+         fInvMassAOD->Fill(invMAOD);
+       }// end if muons with opposite charge
+      }// end if muon track
+    }// end second loop over tracks in event  
+  }// end first loop over tracks in event
+  
+  // Post final data. Write histo list to a file with option "RECREATE"
+  PostData(0,fList);
+}      
+
+//________________________________________________________________________
+void AliAnalysisTaskAODvsESD::Terminate(const Option_t*)
+{
+  // check if major differences between the two Ntuples (more comparisons can be added)
+  int n1 = fMuonNtuple->GetEntries();
+  int n2 = fMuonNtupleAOD->GetEntries();
+  if(n1!=n2){
+    printf("ERROR: Different number of entries in single muon Ntuples\n");
+    return;
+  }
+  else
+    printf("Same number of entries in single muon Ntuples\n");
+  
+//   TCanvas* cv1 = new TCanvas("cvn1","cvn1",500,350);
+//   cv1->cd(1);
+//   fInvMass->SetMarkerStyle(29);
+//   fInvMass->SetMarkerColor(4);
+//   fInvMass->Draw();
+//   fInvMassAOD->SetMarkerStyle(28);
+//   fInvMassAOD->SetMarkerColor(2);
+//   fInvMassAOD->Draw("same"); 
+}
+
diff --git a/PWG3/muon/AliAnalysisTaskAODvsESD.h b/PWG3/muon/AliAnalysisTaskAODvsESD.h
new file mode 100644 (file)
index 0000000..1b852dd
--- /dev/null
@@ -0,0 +1,35 @@
+#ifndef AliAnalysisTaskAODvsESD_cxx
+#define AliAnalysisTaskAODvsESD_cxx
+
+class TList;
+class TH2F;
+class AliESDEvent;
+class AliAODEvent;
+
+#include "AliAnalysisTask.h"
+
+class AliAnalysisTaskAODvsESD : public AliAnalysisTask {
+ public:
+  AliAnalysisTaskAODvsESD(const char *name = "AliAnalysisTaskAODvsESD");
+  virtual ~AliAnalysisTaskAODvsESD() {}
+  
+  virtual void   ConnectInputData(Option_t *);
+  virtual void   CreateOutputObjects();
+  virtual void   Exec(Option_t *option);
+  virtual void   Terminate(const Option_t*);
+  
+ private:
+  AliESDEvent *fESD;         // ESD object
+  AliAODEvent *fAOD;         // AOD object
+
+  TList   *fList;             // list of ntuples
+  TNtuple *fMuonNtuple;       // NTuple for single muons ESD
+  TNtuple *fMuonNtupleAOD;    // NTuple for single muons AOD
+  TH1F    *fInvMass;          // ESD inv. mass histo
+  TH1F    *fInvMassAOD;       // AOD inv. mass histo
+   
+  ClassDef(AliAnalysisTaskAODvsESD, 1); // example of analysis
+};
+
+#endif
+
diff --git a/PWG3/muon/AnalysisTrainMuonComp.C b/PWG3/muon/AnalysisTrainMuonComp.C
new file mode 100644 (file)
index 0000000..6bff019
--- /dev/null
@@ -0,0 +1,145 @@
+void AnalysisTrainMuonComp(){
+  TStopwatch timer;
+  timer.Start();
+
+  printf("*** Connect to AliEn ***\n");
+  TGrid::Connect("alien://");
+
+  gSystem->Load("libTree.so");
+  gSystem->Load("libGeom.so");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libPhysics.so");
+  
+  // Common packages
+  SetupPar("STEERBase");
+  gSystem->Load("libSTEERBase.so");
+  SetupPar("ESD");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libESD.so");
+  SetupPar("AOD");
+  gSystem->Load("libAOD.so");
+  SetupPar("ANALYSIS");
+  gSystem->Load("libANALYSIS.so");
+  SetupPar("ANALYSISalice");
+  gSystem->Load("libANALYSISalice.so");
+  // Analysis-specific packages
+  SetupPar("PWG3muon");      
+  gSystem->Load("libPWG3muon.so");
+  
+  gROOT->LoadMacro("AliAnalysisTaskAODvsESD.cxx+");  
+
+  const char *collectionfile = "wn.xml";
+
+  //Usage of event tags
+  AliTagAnalysis *analysis = new AliTagAnalysis(); 
+  
+  TChain* chain = 0x0;
+  chain = analysis->GetChainFromCollection(collectionfile,"esdTree");
+  chain->SetBranchStatus("*Calo*",0);
+
+  // Define the analysis manager
+  AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Analysis train");
+
+  // ESD input handler
+  AliESDInputHandler *esdHandler = new AliESDInputHandler();
+  esdHandler->SetInactiveBranches("FMD CaloCluster");
+  mgr->SetInputEventHandler(esdHandler);
+
+  // AOD output handler
+  AliAODHandler* aodHandler = new AliAODHandler();  
+  aodHandler->SetOutputFileName("AOD.root");  
+  mgr->SetOutputEventHandler(aodHandler);
+  
+  // Set of cuts for the ESD filter
+  // standard cuts
+  AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose");
+  esdTrackCutsL->SetMinNClustersTPC(50);
+  esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5);
+  esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsL->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsL->SetMinNsigmaToVertex(3);
+  esdTrackCutsL->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsL->SetAcceptKingDaughters(kFALSE);
+  // hard cuts
+  AliESDtrackCuts* esdTrackCutsH = new AliESDtrackCuts("AliESDtrackCuts", "Hard");
+  esdTrackCutsH->SetMinNClustersTPC(100);
+  esdTrackCutsH->SetMaxChi2PerClusterTPC(2.0);
+  esdTrackCutsH->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsH->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsH->SetMinNsigmaToVertex(2);
+  esdTrackCutsH->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsH->SetAcceptKingDaughters(kFALSE);
+  
+  AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+  trackFilter->AddCuts(esdTrackCutsL);
+  trackFilter->AddCuts(esdTrackCutsH);
+  
+   // first task - ESD filter task putting standard info in the output generic AOD 
+  AliAnalysisTaskESDfilter *esdFilter = new AliAnalysisTaskESDfilter("ESD Filter");
+  //esdFilter->SetTrackFilter(trackFilter);
+  mgr->AddTask(esdFilter);
+  
+  // second task - ESD filter task putting muon info in the output generic AOD 
+  AliAnalysisTaskESDMuonFilter *esdMuonFilter = new AliAnalysisTaskESDMuonFilter("ESD Muon Filter");
+  mgr->AddTask(esdMuonFilter);
+  
+  // third task - compare created AOD and exixting ESDs
+  AliAnalysisTaskAODvsESD *AODvsESD = new AliAnalysisTaskAODvsESD("aodVsEsd");
+  mgr->AddTask(AODvsESD);
+
+  // Input ESD container
+  AliAnalysisDataContainer *esdIn = mgr->CreateContainer("input1",TChain::Class(), AliAnalysisManager::kInputContainer);
+  // Output AOD container. 
+  AliAnalysisDataContainer *aodOut = mgr->CreateContainer("output1", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
+  // Output comparison
+  AliAnalysisDataContainer *listOut = mgr->CreateContainer("output2", TList::Class(), AliAnalysisManager::kOutputContainer, "AODvsESDoutput.root");
+
+  // Connect containers to tasks slots
+  mgr->ConnectInput(esdFilter,0,esdIn); 
+  mgr->ConnectOutput(esdFilter,0,aodOut);
+  
+  mgr->ConnectInput(esdMuonFilter,0,esdIn);
+  mgr->ConnectOutput(esdMuonFilter,0,aodOut);
+
+  mgr->ConnectInput(AODvsESD,0,esdIn);
+  mgr->ConnectOutput(AODvsESD,0,listOut);
+  
+  // Run the analysis
+  if (mgr->InitAnalysis()){
+    mgr->PrintStatus();
+    mgr->StartAnalysis("local",chain);
+  }   
+  timer.Stop();
+  timer.Print();
+}
+
+//______________________________________________________________________________
+void SetupPar(char* pararchivename)
+{
+  if (pararchivename) {
+    char processline[1024];
+    sprintf(processline,".! tar xvzf %s.par",pararchivename);
+    gROOT->ProcessLine(processline);
+    TString ocwd = gSystem->WorkingDirectory();
+    gSystem->ChangeDirectory(pararchivename);
+    
+    // check for BUILD.sh and execute
+    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
+      printf("*** Building PAR archive    ***\n");
+      
+      if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
+       Error("runProcess","Cannot Build the PAR Archive! - Abort!");
+       return -1;
+      }
+    }
+    // check for SETUP.C and execute
+    if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
+      printf("*** Setup PAR archive       ***\n");
+      gROOT->Macro("PROOF-INF/SETUP.C");
+    }
+    
+    gSystem->ChangeDirectory(ocwd.Data());
+    printf("Current dir: %s\n", ocwd.Data());
+  } 
+}
+
diff --git a/PWG3/muon/AnalysisTrainMuonCompLocal.C b/PWG3/muon/AnalysisTrainMuonCompLocal.C
new file mode 100644 (file)
index 0000000..648a674
--- /dev/null
@@ -0,0 +1,133 @@
+void AnalysisTrainMuonCompLocal()
+{
+  gSystem->Load("libTree.so");
+  gSystem->Load("libGeom.so");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libPhysics.so");
+  
+  // Common packages
+  SetupPar("STEERBase");
+  SetupPar("ESD");
+  SetupPar("AOD");
+  SetupPar("ANALYSIS");
+  SetupPar("ANALYSISalice");
+  // Analysis-specific packages
+  SetupPar("PWG3muon");      
+  
+  gROOT->LoadMacro("AliAnalysisTaskAODvsESD.cxx+");  
+
+  AliTagAnalysis *TagAna = new AliTagAnalysis("ESD"); 
+  TagAna->ChainLocalTags("./");
+
+  AliRunTagCuts *runCuts = new AliRunTagCuts();
+  AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
+  AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
+  AliEventTagCuts *evCuts = new AliEventTagCuts();
+  
+  TChain* chain = 0x0;
+  chain = TagAna->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
+  chain->SetBranchStatus("*Calo*",0);
+  
+  // Define the analysis manager
+  AliAnalysisManager *mgr  = new AliAnalysisManager("Analysis Train", "Analysis train");
+  
+  // ESD input handler
+  AliESDInputHandler *esdHandler = new AliESDInputHandler();
+  esdHandler->SetInactiveBranches("FMD CaloCluster");
+  mgr->SetInputEventHandler(esdHandler);
+  
+  // AOD output handler
+  AliAODHandler* aodHandler   = new AliAODHandler();
+  aodHandler->SetOutputFileName("AOD.root");  
+  mgr->SetOutputEventHandler(aodHandler);
+  
+  // Set of cuts for the ESD filter
+  // standard cuts
+  AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose");
+  esdTrackCutsL->SetMinNClustersTPC(50);
+  esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5);
+  esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsL->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsL->SetMinNsigmaToVertex(3);
+  esdTrackCutsL->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsL->SetAcceptKingDaughters(kFALSE);
+  // hard cuts
+  AliESDtrackCuts* esdTrackCutsH = new AliESDtrackCuts("AliESDtrackCuts", "Hard");
+  esdTrackCutsH->SetMinNClustersTPC(100);
+  esdTrackCutsH->SetMaxChi2PerClusterTPC(2.0);
+  esdTrackCutsH->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsH->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsH->SetMinNsigmaToVertex(2);
+  esdTrackCutsH->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsH->SetAcceptKingDaughters(kFALSE);
+  
+  AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+  trackFilter->AddCuts(esdTrackCutsL);
+  trackFilter->AddCuts(esdTrackCutsH);
+  
+  // first task - ESD filter task putting standard info in the output generic AOD 
+  AliAnalysisTaskESDfilter *esdFilter = new AliAnalysisTaskESDfilter("ESD Filter");
+  //esdFilter->SetTrackFilter(trackFilter);
+  mgr->AddTask(esdFilter);
+  
+  // second task - ESD filter task putting muon info in the output generic AOD 
+  AliAnalysisTaskESDMuonFilter *esdMuonFilter = new AliAnalysisTaskESDMuonFilter("ESD Muon Filter");
+  mgr->AddTask(esdMuonFilter);
+  
+  // third task - compare created AOD and exixting ESDs
+  AliAnalysisTaskAODvsESD *AODvsESD = new AliAnalysisTaskAODvsESD("aodVsEsd");
+  mgr->AddTask(AODvsESD);
+
+  // Input ESD container
+  AliAnalysisDataContainer *esdIn = mgr->CreateContainer("input1",TChain::Class(), AliAnalysisManager::kInputContainer);
+  // Output AOD container. 
+  AliAnalysisDataContainer *aodOut = mgr->CreateContainer("output1", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
+  // Output comparison
+  AliAnalysisDataContainer *listOut = mgr->CreateContainer("output2", TList::Class(), AliAnalysisManager::kOutputContainer, "AODvsESDoutput.root");
+
+  // Connect containers to tasks slots
+  mgr->ConnectInput(esdFilter,0,esdIn); 
+  mgr->ConnectOutput(esdFilter,0,aodOut);
+  
+  mgr->ConnectInput(esdMuonFilter,0,esdIn);
+  mgr->ConnectOutput(esdMuonFilter,0,aodOut);
+
+  mgr->ConnectInput(AODvsESD,0,esdIn);
+  mgr->ConnectOutput(AODvsESD,0,listOut);
+  
+  // Run the analysis
+  if (mgr->InitAnalysis()){
+    mgr->PrintStatus();
+    mgr->StartAnalysis("local",chain);
+  }   
+}
+
+//______________________________________________________________________________
+void SetupPar(char* pararchivename)
+{
+  if (pararchivename) {
+    char processline[1024];
+    sprintf(processline,".! tar xvzf %s.par",pararchivename);
+    gROOT->ProcessLine(processline);
+    TString ocwd = gSystem->WorkingDirectory();
+    gSystem->ChangeDirectory(pararchivename);
+    
+    // check for BUILD.sh and execute
+    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
+      printf("*** Building PAR archive    ***\n");
+      
+      if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
+       Error("runProcess","Cannot Build the PAR Archive! - Abort!");
+       return -1;
+      }
+    }
+    // check for SETUP.C and execute
+    if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
+      printf("*** Setup PAR archive       ***\n");
+      gROOT->Macro("PROOF-INF/SETUP.C");
+    }
+    
+    gSystem->ChangeDirectory(ocwd.Data());
+    printf("Current dir: %s\n", ocwd.Data());
+  } 
+}