From fe9005e366e5e3d318a6ee89f32ddc1773b031d7 Mon Sep 17 00:00:00 2001 From: martinez Date: Wed, 10 Sep 2008 16:27:52 +0000 Subject: [PATCH] Tasks for comparing ESD and AOD information (Mercedes) --- PWG3/READMEmuon | 82 +++++---- PWG3/muon/AliAnalysisTaskAODvsESD.cxx | 236 +++++++++++++++++++++++++ PWG3/muon/AliAnalysisTaskAODvsESD.h | 35 ++++ PWG3/muon/AnalysisTrainMuonComp.C | 145 +++++++++++++++ PWG3/muon/AnalysisTrainMuonCompLocal.C | 133 ++++++++++++++ 5 files changed, 599 insertions(+), 32 deletions(-) create mode 100644 PWG3/muon/AliAnalysisTaskAODvsESD.cxx create mode 100644 PWG3/muon/AliAnalysisTaskAODvsESD.h create mode 100644 PWG3/muon/AnalysisTrainMuonComp.C create mode 100644 PWG3/muon/AnalysisTrainMuonCompLocal.C diff --git a/PWG3/READMEmuon b/PWG3/READMEmuon index b42cc9e3e0e..77b5dcb2987 100644 --- a/PWG3/READMEmuon +++ b/PWG3/READMEmuon @@ -1,41 +1,14 @@ =================================================== - 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 index 00000000000..fe88a11ac9a --- /dev/null +++ b/PWG3/muon/AliAnalysisTaskAODvsESD.cxx @@ -0,0 +1,236 @@ +#include "TChain.h" +#include "TTree.h" +#include "TNtuple.h" +#include "TBranch.h" +#include "TH1F.h" +#include "TCanvas.h" +#include +#include + +#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 (GetInputData(0)); + if (!esdTree) { + Printf("ERROR: Could not read chain from input slot 0"); + } else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + Printf("ERROR: Could not get ESDInputHandler"); + } else + fESD = esdH->GetEvent(); + } + + // Connect AOD here + AliAODHandler *aodH = dynamic_cast (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 index 00000000000..1b852dd86bc --- /dev/null +++ b/PWG3/muon/AliAnalysisTaskAODvsESD.h @@ -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 index 00000000000..6bff0199d41 --- /dev/null +++ b/PWG3/muon/AnalysisTrainMuonComp.C @@ -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 index 00000000000..648a6745686 --- /dev/null +++ b/PWG3/muon/AnalysisTrainMuonCompLocal.C @@ -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()); + } +} -- 2.43.0