===================================================
- 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
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
--- /dev/null
+#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");
+}
+
--- /dev/null
+#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
+
--- /dev/null
+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());
+ }
+}
+
--- /dev/null
+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());
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff