/************************************************************************** * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * * * * Permission to use, copy, modify and distribute this software and its * * documentation strictly for non-commercial purposes is hereby granted * * without fee, provided that the above copyright notice appears in all * * copies and that both the copyright notice and this permission notice * * appear in the supporting documentation. The authors make no claims * * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ // // QA task // // Authors: // Raphaelle Bailhache // #include "TROOT.h" #include "TChain.h" #include "TMath.h" #include #include #include #include #include #include "AliVEventHandler.h" #include "AliMCEventHandler.h" #include "AliAnalysisTaskSE.h" #include "AliAnalysisManager.h" #include "AliVEvent.h" #include "AliESDInputHandler.h" #include "AliMCEvent.h" #include "AliESD.h" #include "AliESDEvent.h" #include "AliPID.h" #include "AliPIDResponse.h" #include "AliESDUtils.h" #include "AliMCParticle.h" #include "AliAODMCParticle.h" #include "AliAODEvent.h" #include "AliAODVertex.h" #include "AliAODTrack.h" #include "AliVTrack.h" #include "AliESDtrack.h" #include "AliESDtrackCuts.h" #include "AliAODTrack.h" #include "AliStack.h" #include "AliMCEvent.h" #include "AliHFEcuts.h" #include "AliHFEpid.h" #include "AliHFEpidQAmanager.h" #include "AliHFEtools.h" #include "AliCentrality.h" #include "AliEventplane.h" #include "AliAnalysisTaskHFEQA.h" #include "AliAODMCHeader.h" ClassImp(AliAnalysisTaskHFEQA) //____________________________________________________________________ AliAnalysisTaskHFEQA::AliAnalysisTaskHFEQA() : AliAnalysisTaskSE(), fListHist(0x0), fAODAnalysis(kFALSE), fAODMCHeader(NULL), fAODArrayMCInfo(NULL), fHFECuts(0), fPIDTPConly(0), fPIDTRDonly(0), fPIDTOFTPC(0), fPIDTPCTRD(0), fPIDTPCEMCal(0), fPIDqaTRDonly(0), fPIDqaTOFTPC(0), fPIDqaTPCTRD(0), fPIDqaTPCEMCal(0), fCentralityEstimator("V0M"), fCollisionSystem(3), fNbEvent(0), fTPConly(0), fTOFTPC(0), fTPCTRD(0), fTPCEMCal(0), fTPConlydo(kFALSE), fTRDonlydo(kFALSE), fTOFTPCdo(kFALSE), fTPCTRDdo(kFALSE), fTPCEMCaldo(kFALSE) { // Constructor } //______________________________________________________________________________ AliAnalysisTaskHFEQA:: AliAnalysisTaskHFEQA(const char *name) : AliAnalysisTaskSE(name), fListHist(0x0), fAODAnalysis(kFALSE), fAODMCHeader(NULL), fAODArrayMCInfo(NULL), fHFECuts(0), fPIDTPConly(0), fPIDTRDonly(0), fPIDTOFTPC(0), fPIDTPCTRD(0), fPIDTPCEMCal(0), fPIDqaTRDonly(0), fPIDqaTOFTPC(0), fPIDqaTPCTRD(0), fPIDqaTPCEMCal(0), fCentralityEstimator("V0M"), fCollisionSystem(3), fNbEvent(0), fTPConly(0), fTOFTPC(0), fTPCTRD(0), fTPCEMCal(0), fTPConlydo(kFALSE), fTRDonlydo(kFALSE), fTOFTPCdo(kFALSE), fTPCTRDdo(kFALSE), fTPCEMCaldo(kFALSE) { // // named ctor // fPIDTPConly = new AliHFEpid("hfePidTPConly"); fPIDTRDonly = new AliHFEpid("hfePidTRDonly"); fPIDTOFTPC = new AliHFEpid("hfePidTOFTPC"); fPIDTPCTRD = new AliHFEpid("hfePidTPCTRD"); fPIDTPCEMCal = new AliHFEpid("hfePidTPCEMCal"); fPIDqaTRDonly = new AliHFEpidQAmanager; fPIDqaTOFTPC = new AliHFEpidQAmanager; fPIDqaTPCTRD = new AliHFEpidQAmanager; fPIDqaTPCEMCal = new AliHFEpidQAmanager; SetPbPbAnalysis(); DefineInput(0,TChain::Class()); DefineOutput(1, TList::Class()); } //____________________________________________________________ AliAnalysisTaskHFEQA::AliAnalysisTaskHFEQA(const AliAnalysisTaskHFEQA &ref): AliAnalysisTaskSE(ref), fListHist(NULL), fAODAnalysis(ref.fAODAnalysis), fAODMCHeader(ref.fAODMCHeader), fAODArrayMCInfo(ref.fAODArrayMCInfo), fHFECuts(NULL), fPIDTPConly(0), fPIDTRDonly(0), fPIDTOFTPC(0), fPIDTPCTRD(0), fPIDTPCEMCal(0), fPIDqaTRDonly(0), fPIDqaTOFTPC(0), fPIDqaTPCTRD(0), fPIDqaTPCEMCal(0), fCentralityEstimator(ref.fCentralityEstimator), fCollisionSystem(ref.fCollisionSystem), fNbEvent(ref.fNbEvent), fTPConly(ref.fTPConly), fTOFTPC(ref.fTOFTPC), fTPCTRD(ref.fTPCTRD), fTPCEMCal(ref.fTPCEMCal), fTPConlydo(ref.fTPConlydo), fTRDonlydo(ref.fTRDonlydo), fTOFTPCdo(ref.fTOFTPCdo), fTPCTRDdo(ref.fTPCTRDdo), fTPCEMCaldo(ref.fTPCEMCaldo) { // // Copy Constructor // ref.Copy(*this); } //____________________________________________________________ AliAnalysisTaskHFEQA &AliAnalysisTaskHFEQA::operator=(const AliAnalysisTaskHFEQA &ref){ // // Assignment operator // if(this == &ref) ref.Copy(*this); return *this; } //____________________________________________________________ void AliAnalysisTaskHFEQA::Copy(TObject &o) const { // // Copy into object o // AliAnalysisTaskHFEQA &target = dynamic_cast(o); target.fListHist = fListHist; target.fAODAnalysis = fAODAnalysis; target.fAODMCHeader = fAODMCHeader; target.fAODArrayMCInfo = fAODArrayMCInfo; target.fHFECuts = fHFECuts; target.fPIDTPConly = fPIDTPConly; target.fPIDTRDonly = fPIDTRDonly; target.fPIDTOFTPC = fPIDTOFTPC; target.fPIDTPCTRD = fPIDTPCTRD; target.fPIDTPCEMCal = fPIDTPCEMCal; target.fPIDqaTRDonly = fPIDqaTRDonly; target.fPIDqaTOFTPC = fPIDqaTOFTPC; target.fPIDqaTPCTRD = fPIDqaTPCTRD; target.fPIDqaTPCEMCal = fPIDqaTPCEMCal; target.fCentralityEstimator = fCentralityEstimator; target.fCollisionSystem = fCollisionSystem; target.fNbEvent = fNbEvent; target.fTPConly = fTPConly; target.fTOFTPC = fTOFTPC; target.fTPCTRD = fTPCTRD; target.fTPCEMCal = fTPCEMCal; target.fTPConlydo = fTPConlydo; target.fTRDonlydo = fTRDonlydo; target.fTOFTPCdo = fTOFTPCdo; target.fTPCTRDdo = fTPCTRDdo; target.fTPCEMCaldo = fTPCEMCaldo; } //____________________________________________________________ AliAnalysisTaskHFEQA::~AliAnalysisTaskHFEQA(){ // // Destructor // if(fListHist) delete fListHist; if(fHFECuts) delete fHFECuts; if(fPIDTPConly) delete fPIDTPConly; if(fPIDTRDonly) delete fPIDTRDonly; if(fPIDTOFTPC) delete fPIDTOFTPC; if(fPIDTPCTRD) delete fPIDTPCTRD; if(fPIDTPCEMCal) delete fPIDTPCEMCal; } //________________________________________________________________________ void AliAnalysisTaskHFEQA::UserCreateOutputObjects() { //******************** // Create histograms //******************** AliDebug(2,"AliAnalysisTaskHFEQA: User create output objects"); // AOD or ESD AliVEventHandler *inputHandler = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){ SetAODAnalysis(kTRUE); AliDebug(2,"Put AOD analysis on"); } else { SetAODAnalysis(kFALSE); } AliDebug(2,"AliAnalysisTaskHFEQA: AOD ESD"); // HFE cuts if(!fHFECuts){ fHFECuts = new AliHFEcuts; fHFECuts->CreateStandardCuts(); } fHFECuts->Initialize(); if(fAODAnalysis) { fHFECuts->SetAOD(); } AliDebug(2,"AliAnalysisTaskHFEQA: HFE cuts"); // PIDTPConly HFE if(!fPIDTPConly) { fPIDTPConly =new AliHFEpid("hfePidTPConly"); } if(!fPIDTPConly->GetNumberOfPIDdetectors()) fPIDTPConly->AddDetector("TPC", 0); fPIDTPConly->InitializePID(); fPIDTPConly->SortDetectors(); // PIDTRDonly HFE if(!fPIDTRDonly) { fPIDTRDonly =new AliHFEpid("hfePidTRDonly"); } if(!fPIDTRDonly->GetNumberOfPIDdetectors()) fPIDTRDonly->AddDetector("TRD", 0); fPIDTRDonly->InitializePID(); fPIDqaTRDonly->Initialize(fPIDTRDonly); fPIDTRDonly->SortDetectors(); // PIDTOFTPC HFE if(!fPIDTOFTPC) { fPIDTOFTPC =new AliHFEpid("hfePidTOFTPC"); } if(!fPIDTOFTPC->GetNumberOfPIDdetectors()) { fPIDTOFTPC->AddDetector("TOF", 0); fPIDTOFTPC->AddDetector("TPC", 1); } fPIDTOFTPC->InitializePID(); fPIDqaTOFTPC->Initialize(fPIDTOFTPC); fPIDTOFTPC->SortDetectors(); // PIDTPCTRD HFE if(!fPIDTPCTRD) { fPIDTPCTRD =new AliHFEpid("hfePidTPCTRD"); } if(!fPIDTPCTRD->GetNumberOfPIDdetectors()) { fPIDTPCTRD->AddDetector("TPC", 0); fPIDTPCTRD->AddDetector("TRD", 1); } fPIDTPCTRD->InitializePID(); fPIDqaTPCTRD->Initialize(fPIDTPCTRD); fPIDTPCTRD->SortDetectors(); // PIDTPCEMCal HFE if(!fPIDTPCEMCal) { fPIDTPCEMCal =new AliHFEpid("hfePidTPCEMCal"); } if(!fPIDTPCEMCal->GetNumberOfPIDdetectors()) { fPIDTPCEMCal->AddDetector("TPC", 0); fPIDTPCEMCal->AddDetector("EMCal", 1); } fPIDTPCEMCal->InitializePID(); fPIDqaTPCEMCal->Initialize(fPIDTPCEMCal); fPIDTPCEMCal->SortDetectors(); // Histograms fNbEvent = new TH1F("NbEvent", "",11,0,11); fNbEvent->Sumw2(); Double_t ptbinning[36] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3., 3.5, 4., 4.5, 5., 5.5, 6., 7., 8., 10., 12., 14., 16., 18., 20.}; fTPConly = new TH1F("TPCOnly", "",35,&ptbinning[0]); fTPConly->Sumw2(); fTOFTPC = new TH1F("TOFTPC", "",35,&ptbinning[0]); fTOFTPC->Sumw2(); fTPCTRD = new TH1F("TPCTRD", "",35,&ptbinning[0]); fTPCTRD->Sumw2(); fTPCEMCal = new TH1F("TPCEMCal", "",35,&ptbinning[0]); fTPCEMCal->Sumw2(); // List fListHist = new TList(); fListHist->SetOwner(); fListHist->Add(fPIDqaTRDonly->MakeList("HFEpidQATRDonly")); fListHist->Add(fPIDqaTOFTPC->MakeList("HFEpidQATOFTPC")); fListHist->Add(fPIDqaTPCTRD->MakeList("HFEpidQATPCTRD")); fListHist->Add(fPIDqaTPCEMCal->MakeList("HFEpidQATPCEMCal")); fListHist->Add(fNbEvent); fListHist->Add(fTPConly); fListHist->Add(fTOFTPC); fListHist->Add(fTPCTRD); fListHist->Add(fTPCEMCal); AliDebug(2,"AliAnalysisTaskHFEQA: list"); fListHist->Print(); PostData(1, fListHist); AliDebug(2,"AliAnalysisTaskHFEQA: post"); } //________________________________________________________________________ void AliAnalysisTaskHFEQA::UserExec(Option_t */*option*/) { // // Loop over event // Double_t binct = 11.5; AliMCEvent *mcEvent = MCEvent(); AliDebug(2,"MC info"); // MC info Bool_t mcthere = kTRUE; if(fAODAnalysis) { AliAODEvent *aodE = dynamic_cast(fInputEvent); if(!aodE){ AliError("No AOD Event"); return; } fAODMCHeader = dynamic_cast(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName())); if(!fAODMCHeader){ mcthere = kFALSE; } fAODArrayMCInfo = dynamic_cast(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName())); if(!fAODArrayMCInfo){ mcthere = kFALSE; } else { fHFECuts->SetMCEvent(aodE); } } else { AliMCEventHandler *mcH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); if(!mcH){ mcthere=kFALSE; } if(mcEvent) fHFECuts->SetMCEvent(mcEvent); } //////////////////////////////////// // Number of contributors /////////////////////////////////// AliDebug(2,"Number of contributors"); Int_t ncontribVtx = 0; if(fAODAnalysis) { AliAODEvent *fAOD = dynamic_cast(fInputEvent); if(!fAOD){ AliError("AOD Event required for AOD Analysis"); return; } AliAODVertex *priVtx = fAOD->GetPrimaryVertex(); if(priVtx){ ncontribVtx = priVtx->GetNContributors(); } } else { AliESDEvent *fESD = dynamic_cast(fInputEvent); if(!fESD){ AliError("ESD Event required for ESD Analysis"); return; } const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks(); if(priVtx){ ncontribVtx = priVtx->GetNContributors(); } } AliDebug(2,Form("Number of contributors %d",ncontribVtx)); ///////////////////////////////// // centrality //////////////////////////////// //printf("Centrality \n"); AliCentrality *centrality = fInputEvent->GetCentrality(); AliDebug(2,"Got the centrality"); Float_t cntr = 0.; if(centrality && (! Ispp())) { cntr = centrality->GetCentralityPercentile(fCentralityEstimator.Data()); if((0.0< cntr) && (cntr<5.0)) binct = 0.5; if((5.0< cntr) && (cntr<10.0)) binct = 1.5; if((10.0< cntr) && (cntr<20.0)) binct = 2.5; if((20.0< cntr) && (cntr<30.0)) binct = 3.5; if((30.0< cntr) && (cntr<40.0)) binct = 4.5; if((40.0< cntr) && (cntr<50.0)) binct = 5.5; if((50.0< cntr) && (cntr<60.0)) binct = 6.5; if((60.0< cntr) && (cntr<70.0)) binct = 7.5; if((70.0< cntr) && (cntr<80.0)) binct = 8.5; if((80.0< cntr) && (cntr<90.0)) binct = 9.5; if((90.0< cntr) && (cntr<100.0)) binct = 10.5; if(binct > 11.0) return; } else binct = 0.5; AliDebug(2,Form("Centrality %f with %s",binct,fCentralityEstimator.Data())); ////////////////////// // run number ////////////////////// Int_t runnumber = fInputEvent->GetRunNumber(); AliDebug(2,Form("Run number %d",runnumber)); if(!fPIDTPConly->IsInitialized()){ fPIDTPConly->InitializePID(runnumber); } if(!fPIDTRDonly->IsInitialized()){ fPIDTRDonly->InitializePID(runnumber); } if(!fPIDTOFTPC->IsInitialized()){ fPIDTOFTPC->InitializePID(runnumber); } if(!fPIDTPCTRD->IsInitialized()){ fPIDTPCTRD->InitializePID(runnumber); } if(!fPIDTPCEMCal->IsInitialized()){ fPIDTPCEMCal->InitializePID(runnumber); } // fHFECuts->SetRecEvent(fInputEvent); ////////// // PID ////////// AliDebug(2,"PID response"); AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse(); if(!pidResponse){ AliDebug(2,"No PID response set"); return; } fPIDTPConly->SetPIDResponse(pidResponse); fPIDTRDonly->SetPIDResponse(pidResponse); fPIDTOFTPC->SetPIDResponse(pidResponse); fPIDTPCTRD->SetPIDResponse(pidResponse); fPIDTPCEMCal->SetPIDResponse(pidResponse); ////////////////// // Event cut ////////////////// AliDebug(2,"Event cut"); if(!fHFECuts->CheckEventCuts("fEvRecCuts", fInputEvent)) { AliDebug(2,"Does not pass the event cut"); PostData(1, fListHist); return; } fNbEvent->Fill(binct); ////////////////////////// // Loop over track ////////////////////////// Int_t nbtracks = fInputEvent->GetNumberOfTracks(); AliDebug(2,Form("Number of tracks %d",nbtracks)); for(Int_t k = 0; k < nbtracks; k++){ AliVTrack *track = (AliVTrack *) fInputEvent->GetTrack(k); if(!track) continue; Double_t pt = track->Pt(); AliDebug(2,"test 0\n"); // RecKine: ITSTPC cuts if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"test 1\n"); // RecPrim if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"test 2\n"); // HFEcuts: ITS layers cuts if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"test 3\n"); // HFE cuts: TOF and mismatch flag if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTOF + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"test 4\n"); // HFE cuts: TPC PID cleanup if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTPC + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"test 5\n"); // HFEcuts: Nb of tracklets TRD0 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue; AliDebug(2,"Survived"); //////////////////////// // Apply PID //////////////////////// AliHFEpidObject hfetrack; if(!fAODAnalysis) hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis); else hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis); hfetrack.SetRecTrack(track); hfetrack.SetCentrality((Int_t)binct); hfetrack.SetMulitplicity(ncontribVtx); // for correction if(IsPbPb()) hfetrack.SetPbPb(); else{ if(IspPb()) hfetrack.SetpPb(); else { hfetrack.SetPP(); //printf("pp\n"); } } AliDebug(2,Form("centrality %f and %d",binct,hfetrack.GetCentrality())); //printf("test 7\n"); // Complete PID TPC alone if(fTPConlydo) { if(fPIDTPConly->IsSelected(&hfetrack,0x0,"recTrackCont",0x0)) { fTPConly->Fill(pt); } } AliDebug(2,"TPC only PID\n"); // Complete PID TRD alone if(fTRDonlydo) { if(fPIDTRDonly->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqaTRDonly)) { AliDebug(2,"Passed TRD only PID\n"); } } AliDebug(2,"TRD only PID\n"); // Complete PID TPC TOF if(fTOFTPCdo) { if(fPIDTOFTPC->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqaTOFTPC)) { fTOFTPC->Fill(pt); } } AliDebug(2,"TOF TPC PID\n"); // Complete PID TPC TRD if(fTPCTRDdo) { if(fPIDTPCTRD->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqaTPCTRD)) { fTPCTRD->Fill(pt); } } AliDebug(2,"TPC TRD PID\n"); if(fTPCEMCaldo) { if(!fAODAnalysis) { // Complete PID TPC TRD if(fPIDTPCEMCal->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqaTPCEMCal)) { fTPCEMCal->Fill(pt); } } } AliDebug(2,"TPC EMCal PID\n"); } PostData(1, fListHist); }