hfe/AliHFEpidBayes.cxx
hfe/AliHFEpidObject.cxx
hfe/AliAnalysisTaskElecHadronCorrel.cxx
- hfe/AliAnalysisTaskElecV2.cxx
+ hfe/AliAnalysisTaskFlowTPCEMCalEP.cxx
hfe/AliAnalysisTaskHFECal.cxx
hfe/AliHFEdebugTreeTask.cxx
hfe/AliHFEVZEROEventPlane.cxx
- hfe/AliAnalysisTaskHFEFlow.cxx
+ hfe/AliAnalysisTaskFlowTPCTOFEPSP.cxx
hfe/AliSelectNonHFE.cxx
hfe/AliHFENonPhotonicElectron.cxx
hfe/AliHFEdebugTreeTaskAOD.cxx
hfe/AliHFEInclusiveSpectrum.cxx
hfe/AliHFEInclusiveSpectrumQA.cxx
hfe/AliHFEsmearDCA.cxx
+ hfe/AliAnalysisTaskFlowTPCEMCalQSP.cxx
)
string (REPLACE ".cxx" ".h" HDRS "${SRCS}")
#pragma link C++ class AliHFEpidObject+;
#pragma link C++ class AliAnalysisTaskElecHadronCorrel+;
#pragma link C++ class AliAnalysisTaskElecHadronCorrel+;
-#pragma link C++ class AliAnalysisTaskElecV2+;
+#pragma link C++ class AliAnalysisTaskFlowTPCEMCalEP+;
#pragma link C++ class AliAnalysisTaskHFECal+;
#pragma link C++ class AliHFEdebugTreeTask+;
#pragma link C++ class AliHFEVZEROEventPlane+;
-#pragma link C++ class AliAnalysisTaskHFEFlow+;
+#pragma link C++ class AliAnalysisTaskFlowTPCTOFEPSP+;
#pragma link C++ class AliSelectNonHFE+;
#pragma link C++ class AliHFENonPhotonicElectron+;
#pragma link C++ class AliHFEInclusiveSpectrum+;
#pragma link C++ class AliHFEInclusiveSpectrumQA+;
#pragma link C++ class AliHFEsmearDCA+;
+#pragma link C++ class AliAnalysisTaskFlowTPCEMCalQSP+;
#endif
#include "AliAODEvent.h"
#include "AliAODHandler.h"
-#include "AliAnalysisTaskElecV2.h"
+#include "AliAnalysisTaskFlowTPCEMCalEP.h"
#include "TGeoGlobalMagField.h"
#include "AliLog.h"
#include "AliAnalysisTaskSE.h"
#include "AliEventplane.h"
#include "AliCentrality.h"
-ClassImp(AliAnalysisTaskElecV2)
+ClassImp(AliAnalysisTaskFlowTPCEMCalEP)
//________________________________________________________________________
-AliAnalysisTaskElecV2::AliAnalysisTaskElecV2(const char *name)
+AliAnalysisTaskFlowTPCEMCalEP::AliAnalysisTaskFlowTPCEMCalEP(const char *name)
: AliAnalysisTaskSE(name)
,fESD(0)
,fMC(0)
}
//________________________________________________________________________
-AliAnalysisTaskElecV2::AliAnalysisTaskElecV2()
+AliAnalysisTaskFlowTPCEMCalEP::AliAnalysisTaskFlowTPCEMCalEP()
: AliAnalysisTaskSE("DefaultAnalysis_AliAnalysisElecHadCorrel")
,fESD(0)
,fMC(0)
}
//_________________________________________
-AliAnalysisTaskElecV2::~AliAnalysisTaskElecV2()
+AliAnalysisTaskFlowTPCEMCalEP::~AliAnalysisTaskFlowTPCEMCalEP()
{
//Destructor
}
//_________________________________________
-void AliAnalysisTaskElecV2::UserExec(Option_t*)
+void AliAnalysisTaskFlowTPCEMCalEP::UserExec(Option_t*)
{
//Main loop
//Called for each event
PostData(1, fOutputList);
}
//_________________________________________
-void AliAnalysisTaskElecV2::UserCreateOutputObjects()
+void AliAnalysisTaskFlowTPCEMCalEP::UserCreateOutputObjects()
{
//--- Check MC
if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()){
}
//________________________________________________________________________
-void AliAnalysisTaskElecV2::Terminate(Option_t *)
+void AliAnalysisTaskFlowTPCEMCalEP::Terminate(Option_t *)
{
// Info("Terminate");
AliAnalysisTaskSE::Terminate();
}
//________________________________________________________________________
-Bool_t AliAnalysisTaskElecV2::ProcessCutStep(Int_t cutStep, AliVParticle *track)
+Bool_t AliAnalysisTaskFlowTPCEMCalEP::ProcessCutStep(Int_t cutStep, AliVParticle *track)
{
// Check single track cuts for a given cut step
const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;
return kTRUE;
}
//_________________________________________
-void AliAnalysisTaskElecV2::SelectPhotonicElectron(Int_t iTracks,AliESDtrack *track,Bool_t &fFlagPhotonicElec, Bool_t &fFlagPhotonicElecBCG)
+void AliAnalysisTaskFlowTPCEMCalEP::SelectPhotonicElectron(Int_t iTracks,AliESDtrack *track,Bool_t &fFlagPhotonicElec, Bool_t &fFlagPhotonicElecBCG)
{
//Identify non-heavy flavour electrons using Invariant mass method
}
//_________________________________________
-Double_t AliAnalysisTaskElecV2::GetCos2DeltaPhi(Double_t phiA,Double_t phiB) const
+Double_t AliAnalysisTaskFlowTPCEMCalEP::GetCos2DeltaPhi(Double_t phiA,Double_t phiB) const
{
//Get cos[2(phi-psi_EP)] or cos[2(psi_subEP1 - psi_subEP2)]
Double_t dPhi = TVector2::Phi_0_2pi(phiA - phiB);
}
//_________________________________________
-Double_t AliAnalysisTaskElecV2::GetDeltaPhi(Double_t phiA,Double_t phiB) const
+Double_t AliAnalysisTaskFlowTPCEMCalEP::GetDeltaPhi(Double_t phiA,Double_t phiB) const
{
//Get phi-psi_EP
Double_t dPhi = TVector2::Phi_0_2pi(phiA - phiB);
* provided "as is" without express or implied warranty. *
**************************************************************************/
-#ifndef ALIANALYSISTASKELECV2_H
-#define ALIANALYSISTASKELECV2_H
+#ifndef ALIANALYSISTASKFlowTPCEMCalEP_H
+#define ALIANALYSISTASKFlowTPCEMCalEP_H
class THnSparse;
class TH2F;
#include "AliAnalysisTaskSE.h"
-class AliAnalysisTaskElecV2 : public AliAnalysisTaskSE {
+class AliAnalysisTaskFlowTPCEMCalEP : public AliAnalysisTaskSE {
public:
- AliAnalysisTaskElecV2();
- AliAnalysisTaskElecV2(const char *name);
- virtual ~AliAnalysisTaskElecV2();
+ AliAnalysisTaskFlowTPCEMCalEP();
+ AliAnalysisTaskFlowTPCEMCalEP(const char *name);
+ virtual ~AliAnalysisTaskFlowTPCEMCalEP();
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *option);
TH2F *fGammaWeight; //! gamma weight
TH2F *fPi0Weight; //! pi0 weight
TH2F *fEtaWeight; //! eta weight
- AliAnalysisTaskElecV2(const AliAnalysisTaskElecV2&); // not implemented
- AliAnalysisTaskElecV2& operator=(const AliAnalysisTaskElecV2&); // not implemented
+ AliAnalysisTaskFlowTPCEMCalEP(const AliAnalysisTaskFlowTPCEMCalEP&); // not implemented
+ AliAnalysisTaskFlowTPCEMCalEP& operator=(const AliAnalysisTaskFlowTPCEMCalEP&); // not implemented
- ClassDef(AliAnalysisTaskElecV2, 1); //!example of analysis
+ ClassDef(AliAnalysisTaskFlowTPCEMCalEP, 1); //!example of analysis
};
#endif
--- /dev/null
+/**************************************************************************
+ * 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. *
+ **************************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+// //
+// Task for Heavy Flavour Electron Flow //
+// Non-Photonic Electron identified with Invariant mass //
+// analysis methos in function SelectPhotonicElectron //
+// //
+// //
+// Author: Andrea Dubla (Utrecht University) //
+// //
+// //
+////////////////////////////////////////////////////////////////////////
+
+#include "TChain.h"
+#include "TTree.h"
+#include "TH2F.h"
+#include "TMath.h"
+#include "TCanvas.h"
+#include "THnSparse.h"
+#include "TLorentzVector.h"
+#include "TString.h"
+#include "TFile.h"
+#include "AliAnalysisTask.h"
+#include "AliAnalysisManager.h"
+#include "AliESDEvent.h"
+#include "AliESDHandler.h"
+#include "AliAODEvent.h"
+#include "AliAODHandler.h"
+#include "AliAnalysisTaskFlowTPCEMCalQSP.h"
+#include "TGeoGlobalMagField.h"
+#include "AliLog.h"
+#include "AliAnalysisTaskSE.h"
+#include "TRefArray.h"
+#include "TVector.h"
+#include "AliESDInputHandler.h"
+#include "AliESDpid.h"
+#include "AliAODInputHandler.h"
+#include "AliAODPid.h"
+#include "AliESDtrackCuts.h"
+#include "AliPhysicsSelection.h"
+#include "AliCentralitySelectionTask.h"
+#include "AliESDCaloCluster.h"
+#include "AliAODCaloCluster.h"
+#include "AliESDCaloTrigger.h"
+#include "AliEMCALRecoUtils.h"
+#include "AliEMCALGeometry.h"
+#include "AliGeomManager.h"
+#include "stdio.h"
+#include "TGeoManager.h"
+#include "iostream"
+#include "fstream"
+#include "AliEMCALTrack.h"
+//#include "AliEMCALTracker.h"
+#include "AliMagF.h"
+#include "AliKFParticle.h"
+#include "AliKFVertex.h"
+#include "AliPID.h"
+#include "AliPIDResponse.h"
+#include "AliHFEcontainer.h"
+#include "AliHFEcuts.h"
+#include "AliHFEpid.h"
+#include "AliHFEpidBase.h"
+#include "AliHFEpidQAmanager.h"
+#include "AliHFEtools.h"
+#include "AliCFContainer.h"
+#include "AliCFManager.h"
+#include "AliKFParticle.h"
+#include "AliKFVertex.h"
+#include "AliCentrality.h"
+#include "AliVEvent.h"
+#include "AliStack.h"
+#include "AliMCEvent.h"
+#include "TProfile.h"
+#include "AliFlowCandidateTrack.h"
+#include "AliFlowTrackCuts.h"
+#include "AliFlowEventSimple.h"
+#include "AliFlowCommonConstants.h"
+#include "AliFlowEvent.h"
+#include "TVector3.h"
+#include "TRandom2.h"
+#include "AliESDVZERO.h"
+#include "AliAODVZERO.h"
+#include "AliPID.h"
+#include "AliPIDResponse.h"
+#include "AliFlowTrack.h"
+#include "AliAnalysisTaskVnV0.h"
+
+
+class AliFlowTrackCuts;
+
+
+ClassImp(AliAnalysisTaskFlowTPCEMCalQSP)
+//________________________________________________________________________
+ AliAnalysisTaskFlowTPCEMCalQSP::AliAnalysisTaskFlowTPCEMCalQSP(const char *name)
+ : AliAnalysisTaskSE(name)
+ ,fDebug(0)
+ ,fAOD(0)
+ ,fGeom(0)
+ ,fOutputList(0)
+ ,fCuts(0)
+ ,fIdentifiedAsOutInz(kFALSE)
+ ,fPassTheEventCut(kFALSE)
+ ,fVz(0.0)
+ ,fCFM(0)
+ ,fPID(0)
+ ,fPIDqa(0)
+ ,fCutsRP(0) // track cuts for reference particles
+ ,fNullCuts(0) // dummy cuts for flow event tracks
+ ,fFlowEvent(0) //! flow events (one for each inv mass band)
+ ,fkCentralityMethod(0)
+ ,fCentrality(0)
+ ,fCentralityMin(0)
+ ,fCentralityMax(0)
+ ,fInvmassCut(0)
+ ,fTrigger(0)
+ ,fPhi(0)
+ ,fEta(0)
+ ,fVZEROA(0)
+ ,fVZEROC(0)
+ ,fTPCM(0)
+ ,fNoEvents(0)
+ ,fTrkEovPBef(0)
+ ,fdEdxBef(0)
+ ,fInclusiveElecPt(0)
+ ,fTPCnsigma(0)
+ ,fTPCnsigmaAft(0)
+ ,fCentralityPass(0)
+ ,fCentralityNoPass(0)
+// ,fSparseElectron(0)
+// ,fvalueElectron(0)
+ ,fInvmassLS1(0)
+ ,fInvmassULS1(0)
+ ,fPhotoElecPt(0)
+ ,fSemiInclElecPt(0)
+ ,fULSElecPt(0)
+ ,fLSElecPt(0)
+ ,fminTPC(-1)
+ ,fmaxTPC(3)
+ ,fminEovP(0.8)
+ ,fmaxEovP(1.2)
+ ,fminM20(0.03)
+ ,fmaxM20(0.3)
+ ,fminM02(0.03)
+ ,fmaxM02(0.5)
+ ,fDispersion(1)
+
+{
+ //Named constructor
+
+ fPID = new AliHFEpid("hfePid");
+ // Define input and output slots here
+ // Input slot #0 works with a TChain
+ DefineInput(0, TChain::Class());
+ // Output slot #0 id reserved by the base class for AOD
+ // Output slot #1 writes into a TH1 container
+ // DefineOutput(1, TH1I::Class());
+ DefineOutput(1, TList::Class());
+ DefineOutput(2, AliFlowEventSimple::Class());
+ // DefineOutput(3, TTree::Class());
+ // fvalueElectron = new Double_t[8];
+
+}
+
+//________________________________________________________________________
+AliAnalysisTaskFlowTPCEMCalQSP::AliAnalysisTaskFlowTPCEMCalQSP()
+ : AliAnalysisTaskSE("DefaultAnalysis_AliAnalysisElectFlow")
+ ,fDebug(0)
+ ,fAOD(0)
+ ,fGeom(0)
+ ,fOutputList(0)
+ ,fCuts(0)
+ ,fIdentifiedAsOutInz(kFALSE)
+ ,fPassTheEventCut(kFALSE)
+ ,fVz(0.0)
+ ,fCFM(0)
+ ,fPID(0)
+ ,fPIDqa(0)
+ ,fCutsRP(0) // track cuts for reference particles
+ ,fNullCuts(0) // dummy cuts for flow event tracks
+ ,fFlowEvent(0) //! flow events (one for each inv mass band)
+ ,fkCentralityMethod(0)
+ ,fCentrality(0)
+ ,fCentralityMin(0)
+ ,fCentralityMax(0)
+ ,fInvmassCut(0)
+ ,fTrigger(0)
+ ,fPhi(0)
+ ,fEta(0)
+ ,fVZEROA(0)
+ ,fVZEROC(0)
+ ,fTPCM(0)
+ ,fNoEvents(0)
+ ,fTrkEovPBef(0)
+ ,fdEdxBef(0)
+ ,fInclusiveElecPt(0)
+ ,fTPCnsigma(0)
+ ,fTPCnsigmaAft(0)
+ ,fCentralityPass(0)
+ ,fCentralityNoPass(0)
+// ,fSparseElectron(0)
+// ,fvalueElectron(0)
+ ,fInvmassLS1(0)
+ ,fInvmassULS1(0)
+ ,fPhotoElecPt(0)
+ ,fSemiInclElecPt(0)
+ ,fULSElecPt(0)
+ ,fLSElecPt(0)
+ ,fminTPC(-1)
+ ,fmaxTPC(3)
+ ,fminEovP(0.8)
+ ,fmaxEovP(1.2)
+ ,fminM20(0.03)
+ ,fmaxM20(0.3)
+ ,fminM02(0.03)
+ ,fmaxM02(0.5)
+ ,fDispersion(1)
+
+{
+ //Default constructor
+ fPID = new AliHFEpid("hfePid");
+ // Constructor
+ // Define input and output slots here
+ // Input slot #0 works with a TChain
+ DefineInput(0, TChain::Class());
+ // Output slot #0 id reserved by the base class for AOD
+ // Output slot #1 writes into a TH1 container
+ // DefineOutput(1, TH1I::Class());
+ DefineOutput(1, TList::Class());
+ DefineOutput(2, AliFlowEventSimple::Class());
+ // fvalueElectron = new Double_t[8]; //from here adding more, when done comment filling this
+ //DefineOutput(3, TTree::Class());
+}
+//_________________________________________
+
+AliAnalysisTaskFlowTPCEMCalQSP::~AliAnalysisTaskFlowTPCEMCalQSP()
+{
+ //Destructor
+
+ delete fOutputList;
+ delete fGeom;
+ delete fPID;
+ delete fCFM;
+ delete fPIDqa;
+// delete fSparseElectron;
+// delete [] fvalueElectron;
+ if (fOutputList) delete fOutputList;
+ if (fFlowEvent) delete fFlowEvent;
+}
+//_________________________________________
+
+void AliAnalysisTaskFlowTPCEMCalQSP::UserExec(Option_t*)
+{
+ //Main loop
+ //Called for each event
+
+ // create pointer to event
+
+ fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
+ if (!fAOD)
+ {
+ printf("ERROR: fAOD not available\n");
+ return;
+ }
+
+ if(!fCuts)
+ {
+ AliError("HFE cuts not available");
+ return;
+ }
+
+ if(!fPID->IsInitialized())
+ {
+ // Initialize PID with the given run number
+ AliWarning("PID not initialised, get from Run no");
+ fPID->InitializePID(fAOD->GetRunNumber());
+ }
+
+ // cout << "kTrigger == " << fTrigger <<endl;
+
+ if(fTrigger==0){
+if(!(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kCentral) ) return;
+ }
+ if(fTrigger==1){
+if(!(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & (AliVEvent::kSemiCentral))) return;
+ }
+ if(fTrigger==2){
+if(!(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kEMCEGA) ) return;
+ }
+ if(fTrigger==3){
+if(!(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB) ) return;
+ }
+ //---------------CENTRALITY SELECTION-----------------------
+ Bool_t pass = kFALSE; //to select centrality
+ CheckCentrality(fAOD,pass);
+
+ if(!pass)return;
+
+ Int_t fNOtrks = fAOD->GetNumberOfTracks();
+ const AliAODVertex *pVtx = fAOD->GetPrimaryVertex();
+
+ Double_t pVtxZ = -999;
+ pVtxZ = pVtx->GetZ();
+
+ // Event cut
+ if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) return;
+
+ if(fNOtrks<2) return;
+ if(TMath::Abs(pVtxZ)>10) return;
+
+
+
+ fNoEvents->Fill(0);
+ PlotVZeroMultiplcities(fAOD);
+
+ SetNullCuts(fAOD);
+ PrepareFlowEvent(fAOD->GetNumberOfTracks(),fFlowEvent); //Calculate event plane Qvector and EP resolution for inclusive
+
+
+ AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
+ if(!pidResponse)
+ {
+ AliDebug(1, "Using default PID Response");
+ pidResponse = AliHFEtools::GetDefaultPID(kFALSE, fInputEvent->IsA() == AliAODEvent::Class());
+ }
+
+ fPID->SetPIDResponse(pidResponse);
+
+ // fCFM->SetRecEventInfo(fESD);
+ fCFM->SetRecEventInfo(fAOD);
+
+ // Look for kink mother
+ Int_t numberofvertices = fAOD->GetNumberOfVertices();
+ Double_t listofmotherkink[numberofvertices];
+ Int_t numberofmotherkink = 0;
+ for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {
+ AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);
+ if(!aodvertex) continue;
+ if(aodvertex->GetType()==AliAODVertex::kKink) {
+ AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();
+ if(!mother) continue;
+ Int_t idmother = mother->GetID();
+ listofmotherkink[numberofmotherkink] = idmother;
+ //printf("ID %d\n",idmother);
+ numberofmotherkink++;
+ }
+ }
+
+
+ AliAODTrack *track = NULL;
+
+// Track loop
+ for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++)
+ {
+ track = fAOD->GetTrack(iTracks);
+ if (!track)
+ {
+ printf("ERROR: Could not receive track %d\n", iTracks);
+ continue;
+ }
+
+ if(!track->TestFilterMask(AliAODTrack::kTrkGlobalNoDCA)) continue; // TESTBIT FOR AOD double Counting
+
+
+ //----------hfe begin---------
+
+ if(track->Eta()<-0.7 || track->Eta()>0.7) continue; //eta cuts on candidates
+
+ // RecKine: ITSTPC cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
+
+ // Reject kink mother
+ Bool_t kinkmotherpass = kTRUE;
+ for(Int_t kinkmother = 0; kinkmother < numberofmotherkink; kinkmother++) {
+ if(track->GetID() == listofmotherkink[kinkmother]) {
+ kinkmotherpass = kFALSE;
+ continue;
+ }
+ }
+ if(!kinkmotherpass) continue;
+
+ // RecPrim
+ // if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue; //deleted for DCA absence
+ // HFEcuts: ITS layers cuts
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
+ // HFE cuts: TPC PID cleanup
+ if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
+
+ Double_t fClsE = -999, p = -999, fEovP=-999, pt = -999, dEdx=-999, fTPCnSigma=0;
+ // Track extrapolation
+ Int_t fClsId = track->GetEMCALcluster();
+ if(fClsId < 0) continue;
+ AliAODCaloCluster *cluster = fAOD->GetCaloCluster(fClsId);
+ if(TMath::Abs(cluster->GetTrackDx()) > 0.05 || TMath::Abs(cluster->GetTrackDz()) > 0.05) continue;
+
+ pt = track->Pt(); //pt track after cuts
+ if(pt<1) continue;
+ fClsE = cluster->E();
+ p = track->P();
+ dEdx = track->GetTPCsignal();
+ fEovP = fClsE/p;
+ fTPCnSigma = fPID->GetPIDResponse() ? fPID->GetPIDResponse()->NumberOfSigmasTPC(track, AliPID::kElectron) : 1000;
+ Double_t m20 =cluster->GetM20();
+ Double_t m02 =cluster->GetM02();
+ Double_t disp=cluster->GetDispersion();
+
+/*
+ fvalueElectron[0] = pt;
+ fvalueElectron[1] = p;
+ fvalueElectron[2] = fTPCnSigma;
+ fvalueElectron[3] = dEdx;
+ fvalueElectron[4] = fEovP;
+ fvalueElectron[5] = m20;
+ fvalueElectron[6] = m02;
+ fvalueElectron[7] = Disp;
+ */
+ // fSparseElectron->Fill(fvalueElectron);
+
+ if(fTPCnSigma >= -1 && fTPCnSigma <= 3)fTrkEovPBef->Fill(pt,fEovP);
+ fTPCnsigma->Fill(p,fTPCnSigma);
+ fdEdxBef->Fill(p,dEdx);
+ Double_t eta = track->Eta();
+ Double_t phi = track->Phi();
+
+
+ if(fTPCnSigma < fminTPC || fTPCnSigma > fmaxTPC) continue; //cuts on nsigma tpc and EoP
+ if(fEovP < fminEovP || fEovP >fmaxEovP) continue;
+ if(m20 < fminM20 || m20 > fmaxM20) continue;
+ if(m02 < fminM02 || m02 > fmaxM02) continue;
+ if(disp > fDispersion ) continue;
+
+
+// fTrkEovPAft->Fill(pt,fEovP);
+ fTPCnsigmaAft->Fill(p,fTPCnSigma);
+ fInclusiveElecPt->Fill(pt);
+ fPhi->Fill(phi);
+ fEta->Fill(eta);
+
+ //----------------------Flow of Inclusive Electrons-----------------------------
+ AliFlowTrack *sTrack = new AliFlowTrack();
+ sTrack->Set(track);
+ sTrack->SetID(track->GetID());
+ sTrack->SetForRPSelection(kFALSE);
+ sTrack->SetForPOISelection(kTRUE);
+ sTrack->SetMass(263732);
+ for(int iRPs=0; iRPs!=fFlowEvent->NumberOfTracks(); ++iRPs)
+ {
+ // cout << " no of rps " << iRPs << endl;
+ AliFlowTrack *iRP = dynamic_cast<AliFlowTrack*>(fFlowEvent->GetTrack( iRPs ));
+ if (!iRP) continue;
+ if (!iRP->InRPSelection()) continue;
+ if( sTrack->GetID() == iRP->GetID())
+ {
+ if(fDebug) printf(" was in RP set");
+ cout << sTrack->GetID() <<" == " << iRP->GetID() << " was in RP set" <<endl;
+ iRP->SetForRPSelection(kFALSE);
+ fFlowEvent->SetNumberOfRPs(fFlowEvent->GetNumberOfRPs() - 1);
+ }
+ } //end of for loop on RPs
+ fFlowEvent->InsertTrack(((AliFlowTrack*) sTrack));
+
+//----------------------Selection and Flow of Photonic Electrons-----------------------------
+ Bool_t fFlagPhotonicElec = kFALSE;
+ SelectPhotonicElectron(iTracks,track,fFlagPhotonicElec);
+ if(fFlagPhotonicElec){fPhotoElecPt->Fill(pt);}
+ // Semi inclusive electron
+ if(!fFlagPhotonicElec){fSemiInclElecPt->Fill(pt);}
+
+ }//end loop on track
+
+ PostData(1, fOutputList);
+ PostData(2, fFlowEvent);
+ //----------hfe end---------
+}
+//_________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::SelectPhotonicElectron(Int_t itrack,const AliAODTrack *track, Bool_t &fFlagPhotonicElec)
+{
+ //Identify non-heavy flavour electrons using Invariant mass method
+
+ Bool_t flagPhotonicElec = kFALSE;
+
+ for(Int_t jTracks = 0; jTracks<fAOD->GetNumberOfTracks(); jTracks++){
+ AliAODTrack *trackAsso = fAOD->GetTrack(jTracks);
+ if (!trackAsso) {
+ printf("ERROR: Could not receive track %d\n", jTracks);
+ continue;
+ }
+ // if(!track->TestFilterMask(AliAODTrack::kTrkGlobalNoDCA)) continue; // TESTBIT FOR AOD double Counting
+ if(!trackAsso->TestFilterMask(AliAODTrack::kTrkTPCOnly)) continue;
+ if((!(trackAsso->GetStatus()&AliESDtrack::kITSrefit)|| (!(trackAsso->GetStatus()&AliESDtrack::kTPCrefit)))) continue;
+
+
+ if(jTracks == itrack) continue;
+ Double_t ptAsso=-999., nsigma=-999.0;
+ Double_t mass=-999., width = -999;
+ Bool_t fFlagLS=kFALSE, fFlagULS=kFALSE;
+
+
+ ptAsso = trackAsso->Pt();
+ Short_t chargeAsso = trackAsso->Charge();
+ Short_t charge = track->Charge();
+ nsigma = fPID->GetPIDResponse() ? fPID->GetPIDResponse()->NumberOfSigmasTPC(trackAsso, AliPID::kElectron) : 1000;
+
+ if(trackAsso->GetTPCNcls() < 80) continue;
+ if(nsigma < -3 || nsigma > 3) continue;
+ if(trackAsso->Eta()<-0.9 || trackAsso->Eta()>0.9) continue;
+ if(ptAsso <0.3) continue;
+
+ Int_t fPDGe1 = 11; Int_t fPDGe2 = 11;
+ if(charge>0) fPDGe1 = -11;
+ if(chargeAsso>0) fPDGe2 = -11;
+
+ if(charge == chargeAsso) fFlagLS = kTRUE;
+ if(charge != chargeAsso) fFlagULS = kTRUE;
+
+ AliKFParticle ge1 = AliKFParticle(*track, fPDGe1);
+ AliKFParticle ge2 = AliKFParticle(*trackAsso, fPDGe2);
+ AliKFParticle recg(ge1, ge2);
+
+ if(recg.GetNDF()<1) continue;
+ Double_t chi2recg = recg.GetChi2()/recg.GetNDF();
+ if(TMath::Sqrt(TMath::Abs(chi2recg))>3.) continue;
+ recg.GetMass(mass,width);
+ // cout << "mass = " << mass <<endl;
+
+ if(fFlagLS) fInvmassLS1->Fill(mass);
+ if(fFlagULS) fInvmassULS1->Fill(mass);
+
+ // cout << "InvMassCut == " << fInvmassCut <<endl;
+
+ if(mass<fInvmassCut){
+ if(fFlagULS){fULSElecPt->Fill(track->Pt());}
+ if(fFlagLS){fLSElecPt->Fill(track->Pt());}
+ }
+
+ if(mass<fInvmassCut && fFlagULS && !flagPhotonicElec){
+ flagPhotonicElec = kTRUE;
+ }
+ }//track loop
+ fFlagPhotonicElec = flagPhotonicElec;
+}
+//___________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::UserCreateOutputObjects()
+{
+ //Create histograms
+
+ //----------hfe initialising begin---------
+ fNullCuts = new AliFlowTrackCuts("null_cuts");
+
+ AliFlowCommonConstants* cc = AliFlowCommonConstants::GetMaster();
+ cc->SetNbinsMult(10000);
+ cc->SetMultMin(0);
+ cc->SetMultMax(10000);
+
+ cc->SetNbinsPt(100);
+ cc->SetPtMin(0);
+ cc->SetPtMax(50);
+
+ cc->SetNbinsPhi(180);
+ cc->SetPhiMin(0.0);
+ cc->SetPhiMax(TMath::TwoPi());
+
+ cc->SetNbinsEta(200);
+ cc->SetEtaMin(-7.0);
+ cc->SetEtaMax(+7.0);
+
+ cc->SetNbinsQ(500);
+ cc->SetQMin(0.0);
+ cc->SetQMax(3.0);
+
+ //--------Initialize PID
+ fPID->SetHasMCData(kFALSE);
+ if(!fPID->GetNumberOfPIDdetectors())
+ {
+ fPID->AddDetector("TPC", 0);
+ fPID->AddDetector("EMCAL", 1);
+ }
+
+ fPID->SortDetectors();
+ fPIDqa = new AliHFEpidQAmanager();
+ fPIDqa->Initialize(fPID);
+
+ //--------Initialize correction Framework and Cuts
+ fCFM = new AliCFManager;
+ const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack;
+ fCFM->SetNStepParticle(kNcutSteps);
+ for(Int_t istep = 0; istep < kNcutSteps; istep++)
+ fCFM->SetParticleCutsList(istep, NULL);
+
+ if(!fCuts){
+ AliWarning("Cuts not available. Default cuts will be used");
+ fCuts = new AliHFEcuts;
+ fCuts->CreateStandardCuts();
+ }
+
+ fCuts->SetAOD();
+ fCuts->Initialize(fCFM);
+ //----------hfe initialising end--------
+ //---------Output Tlist
+ fOutputList = new TList();
+ fOutputList->SetOwner();
+ fOutputList->Add(fPIDqa->MakeList("PIDQA"));
+
+ fNoEvents = new TH1F("fNoEvents","",1,0,1) ;
+ fOutputList->Add(fNoEvents);
+
+ fTPCnsigma = new TH2F("fTPCnsigma", "TPC - n sigma before HFE pid",1000,0,50,200,-10,10);
+ fOutputList->Add(fTPCnsigma);
+
+ fTPCnsigmaAft = new TH2F("fTPCnsigmaAft", "TPC - n sigma after HFE pid",1000,0,50,200,-10,10);
+ fOutputList->Add(fTPCnsigmaAft);
+
+ fTrkEovPBef = new TH2F("fTrkEovPBef","track E/p before HFE pid",1000,0,50,100,0,2);
+ fOutputList->Add(fTrkEovPBef);
+
+ fdEdxBef = new TH2F("fdEdxBef","track dEdx vs p before HFE pid",1000,0,50,150,0,150);
+ fOutputList->Add(fdEdxBef);
+
+ fInclusiveElecPt = new TH1F("fInclElecPt", "Inclusive electron pt",1000,0,100);
+ fOutputList->Add(fInclusiveElecPt);
+
+ fPhotoElecPt = new TH1F("fPhotoElecPt", "photonic electron pt",1000,0,100);
+ fOutputList->Add(fPhotoElecPt);
+ //
+ fSemiInclElecPt = new TH1F("fSemiInclElecPt", "Semi-inclusive electron pt",1000,0,100);
+ fOutputList->Add(fSemiInclElecPt);
+
+ fULSElecPt = new TH1F("fULSElecPt", "ULS electron pt",1000,0,100);
+ fOutputList->Add(fULSElecPt);
+
+ fLSElecPt = new TH1F("fLSElecPt", "LS electron pt",1000,0,100);
+ fOutputList->Add(fLSElecPt);
+
+ fInvmassLS1 = new TH1F("fInvmassLS1", "Inv mass of LS (e,e); mass(GeV/c^2); counts;", 1000,0,1.0);
+ fOutputList->Add(fInvmassLS1);
+
+ fInvmassULS1 = new TH1F("fInvmassULS1", "Inv mass of ULS (e,e); mass(GeV/c^2); counts;", 1000,0,1.0);
+ fOutputList->Add(fInvmassULS1);
+
+ fCentralityPass = new TH1F("fCentralityPass", "Centrality Pass", 101, -1, 100);
+ fOutputList->Add(fCentralityPass);
+
+ fCentralityNoPass = new TH1F("fCentralityNoPass", "Centrality No Pass", 101, -1, 100);
+ fOutputList->Add(fCentralityNoPass);
+
+ fPhi = new TH1F("fPhi", "#phi distribution", 100, -.5, 7);
+ fOutputList->Add(fPhi);
+
+ fEta = new TH1F("fEta", "#eta distribution", 100, -1.1, 1.1);
+ fOutputList->Add(fEta);
+
+ fVZEROA = new TH1F("fVZEROA", "VZERO A Multiplicity", 1000, 0, 10000);
+ fOutputList->Add(fVZEROA);
+
+ fVZEROC = new TH1F("fVZEROC", "VZERO C Multiplicity", 1000, 0, 10000);
+ fOutputList->Add(fVZEROC);
+
+ fTPCM = new TH1F("fTPCM", "TPC multiplicity", 1000, 0, 10000);
+ fOutputList->Add(fTPCM);
+
+
+// Int_t binsv1[8]={1000,1000,200,150,100, 100, 100 ,100}; //pt, p, tpcnSigma, dEdx, E/p, M20, M02, Disp
+// Double_t xminv1[8]={0, 0, -10, 0, 0, 0, 0 ,0};
+// Double_t xmaxv1[8]={50, 50, 10, 150, 2 ,2, 2, 2};
+// fSparseElectron = new THnSparseD ("Electron","Electron",8,binsv1,xminv1,xmaxv1);
+// fOutputList->Add(fSparseElectron);
+
+
+ PostData(1,fOutputList);
+ // create and post flowevent
+ fFlowEvent = new AliFlowEvent(10000);
+ PostData(2, fFlowEvent);
+
+ }
+
+//________________________________________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::Terminate(Option_t *)
+{
+ // Info("Terminate");
+ AliAnalysisTaskSE::Terminate();
+}
+//_____________________________________________________________________________
+template <typename T> void AliAnalysisTaskFlowTPCEMCalQSP::PlotVZeroMultiplcities(const T* event) const
+{
+ // QA multiplicity plots
+ fVZEROA->Fill(event->GetVZEROData()->GetMTotV0A());
+ fVZEROC->Fill(event->GetVZEROData()->GetMTotV0C());
+}
+//_____________________________________________________________________________
+template <typename T> void AliAnalysisTaskFlowTPCEMCalQSP::SetNullCuts(T* event)
+{
+ //Set null cuts
+ if (fDebug) cout << " fCutsRP " << fCutsRP << endl;
+ fCutsRP->SetEvent(event, MCEvent());
+ fNullCuts->SetParamType(AliFlowTrackCuts::kGlobal);
+ fNullCuts->SetPtRange(+1, -1); // select nothing QUICK
+ fNullCuts->SetEtaRange(+1, -1); // select nothing VZERO
+ fNullCuts->SetEvent(event, MCEvent());
+}
+//_____________________________________________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::PrepareFlowEvent(Int_t iMulti, AliFlowEvent *FlowEv) const
+{
+ //Prepare flow events
+ FlowEv->ClearFast();
+ FlowEv->Fill(fCutsRP, fNullCuts);
+ FlowEv->SetReferenceMultiplicity(iMulti);
+ FlowEv->DefineDeadZone(0, 0, 0, 0);
+ // FlowEv->TagSubeventsInEta(-0.7, 0, 0, 0.7);
+}
+//_____________________________________________________________________________
+Bool_t AliAnalysisTaskFlowTPCEMCalQSP::ProcessCutStep(Int_t cutStep, AliVParticle *track)
+{
+ // Check single track cuts for a given cut step
+ const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;
+ if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;
+ return kTRUE;
+}
+//_________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::CheckCentrality(AliAODEvent* event, Bool_t ¢ralitypass)
+{
+ // Check if event is within the set centrality range. Falls back to V0 centrality determination if no method is set
+ if (!fkCentralityMethod) AliFatal("No centrality method set! FATAL ERROR!");
+ fCentrality = event->GetCentrality()->GetCentralityPercentile(fkCentralityMethod);
+ cout << "--------------Centrality evaluated-------------------------"<<endl;
+
+ if ((fCentrality <= fCentralityMin) || (fCentrality > fCentralityMax))
+ {
+ fCentralityNoPass->Fill(fCentrality);
+ cout << "--------------Fill no pass-------------------------"<<endl;
+ centralitypass = kFALSE;
+ }else
+ {
+ fCentralityPass->Fill(fCentrality);
+ cout << "--------------Fill pass-------------------------"<<endl;
+ centralitypass = kTRUE;
+ }
+
+}
+//_____________________________________________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::SetCentralityParameters(Double_t CentralityMin, Double_t CentralityMax, const char* CentralityMethod)
+{
+ // Set a centrality range ]min, max] and define the method to use for centrality selection
+ fCentralityMin = CentralityMin;
+ fCentralityMax = CentralityMax;
+ fkCentralityMethod = CentralityMethod;
+}
+//_____________________________________________________________________________
+void AliAnalysisTaskFlowTPCEMCalQSP::SetIDCuts(Double_t minTPC, Double_t maxTPC, Double_t minEovP, Double_t maxEovP, Double_t minM20, Double_t maxM20, Double_t minM02, Double_t maxM02, Double_t Dispersion)
+{
+ //Set ID cuts
+ fminTPC = minTPC;
+ fmaxTPC = maxTPC;
+ fminEovP = minEovP;
+ fmaxEovP = maxEovP;
+ fminM20 = minM20;
+ fmaxM20 = maxM20;
+ fminM02 = minM02;
+ fmaxM02 = maxM02;
+ fDispersion = Dispersion;
+}
+//_____________________________________________________________________________
+
+
--- /dev/null
+#ifndef ALIANALYSISTASKFLOWTPCEMCalQSP_H
+#define ALIANALYSISTASKFLOWTPCEMCalQSP_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+////////////////////////////////////////////////////////////////////////
+// //
+// Task for Heavy Flavour Electron Flow //
+// //
+// Author: Andrea Dubla (Utrecht University) //
+// //
+////////////////////////////////////////////////////////////////////////
+
+class THnSparse;
+class TH2F;
+class TLorentzVector;
+
+class AliEMCALTrack;
+class AliMagF;
+class AliESDEvent;
+class AliAODEvent;
+class AliEMCALGeometry;
+class AliEMCALRecoUtils;
+class AliAnalysisFilter;
+class AliESDtrackCuts;
+class AliESDtrack;
+class AliAODtrack;
+class AliHFEcontainer;
+class AliHFEcuts;
+class AliHFEpid;
+class AliHFEpidQAmanager;
+class AliCFManager;
+class AliFlowTrackCuts;
+class AliFlowTrack;
+class AliFlowEvent;
+class AliFlowCandidateTrack;
+class AliFlowEventSimple;
+class AliCentrality;
+#include "AliAnalysisTaskSE.h"
+//#include "AliCentrality.h"
+
+class AliAnalysisTaskFlowTPCEMCalQSP : public AliAnalysisTaskSE {
+
+ public:
+ AliAnalysisTaskFlowTPCEMCalQSP();
+ AliAnalysisTaskFlowTPCEMCalQSP(const char *name);
+ virtual ~AliAnalysisTaskFlowTPCEMCalQSP();
+
+ void SetEnableDebugMode() {fDebug = kTRUE; };
+ void SetCentralityParameters(Double_t CentralityMin, Double_t CentralityMax, const char* CentralityMethod); //select centrality
+ void CheckCentrality(AliAODEvent *event,Bool_t ¢ralitypass); //to use only events with the correct centrality....
+ void SelectPhotonicElectron(Int_t itrack,const AliAODTrack *track, Bool_t &fFlagPhotonicElec);
+ void SetInvariantMassCut(Double_t invmass) {fInvmassCut = invmass;};
+ void SetTrigger(Int_t trig) {fTrigger = trig;};
+ template <typename T> void PlotVZeroMultiplcities(const T* event) const;
+ template <typename T> void SetNullCuts(T* aod);
+ void PrepareFlowEvent(Int_t iMulti, AliFlowEvent *FlowEv) const;
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t *);
+ void SetRPCuts(AliFlowTrackCuts *cutsRP) { fCutsRP = cutsRP; }
+ void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
+ void SetIDCuts(Double_t minTPC, Double_t maxTPC, Double_t minEovP, Double_t maxEovP, Double_t minM20, Double_t maxM20, Double_t minM02, Double_t maxM02, Double_t Dispersion);
+
+
+
+ AliHFEpid *GetPID() const { return fPID; };
+
+ private:
+
+ Bool_t ProcessCutStep(Int_t cutStep, AliVParticle *track);
+
+ Bool_t fDebug; //! enable debug mode
+ AliAODEvent *fAOD; //AOD object
+ AliEMCALGeometry *fGeom; // emcal geometry
+ TList *fOutputList; //output list
+ AliHFEcuts *fCuts; //Cut Collection
+ Bool_t fIdentifiedAsOutInz; //Out Of Range in z
+ Bool_t fPassTheEventCut; //Pass The Event Cut
+ Double_t fVz; //z position of the primary vertex
+ AliCFManager *fCFM; //!Correction Framework Manager
+ AliHFEpid *fPID; //PID
+ AliHFEpidQAmanager *fPIDqa; //! PID QA manager
+ AliFlowTrackCuts *fCutsRP; // track cuts for reference particles
+ AliFlowTrackCuts *fNullCuts; // dummy cuts for flow event tracks
+ AliFlowEvent *fFlowEvent; //! flow events Inclusive e
+ const char *fkCentralityMethod; // method used to determine centrality (V0 by default)
+ Double_t fCentrality; // event centrality for QA
+ Double_t fCentralityMin; // lower bound of cenrality bin
+ Double_t fCentralityMax; // upper bound of centrality bin
+ Double_t fInvmassCut; //invariant mass cut value
+ Int_t fTrigger; //invariant mass cut value
+ TH1F *fPhi; //! QA plot of azimuthal distribution of tracks used for event plane estimation
+ TH1F *fEta; //! QA plot of eta distribution of tracks used for event plane estimation
+ TH1F *fVZEROA; //! QA plot vzeroa multiplicity (all tracks in event)
+ TH1F *fVZEROC; //! QA plot vzeroc multiplicity (all tracks in event)
+ TH1F *fTPCM; //! QA plot TPC multiplicity (tracks used for event plane estimation)
+ TH1F *fNoEvents; //no of events
+ TH2F *fTrkEovPBef; //track E/p before HFE pid
+ TH2F *fdEdxBef; //track dEdx vs p before HFE pid
+ TH1F *fInclusiveElecPt; // Inclusive elec pt
+ TH2F *fTPCnsigma; //TPC n sigma vs p
+ TH2F *fTPCnsigmaAft; //TPC n sigma vs p after HFE pid
+ TH1F *fCentralityPass; // ! QA histogram of events that pass centrality cut
+ TH1F *fCentralityNoPass; //! QA histogram of events that do not pass centrality cut
+ // THnSparse *fSparseElectron;//! Trk matching sparse for v1 clusterizer
+ // Double_t *fvalueElectron;//! 6dim sparse fill for trk matching quantities
+ TH1F *fInvmassLS1; //LS Invmass for all rec par
+ TH1F *fInvmassULS1;//ULS Invmass for all rec par
+ TH1F *fPhotoElecPt; //photonic elec pt
+ TH1F *fSemiInclElecPt; //Semi inclusive ele pt
+ TH1F *fULSElecPt; //ULS elec Pt
+ TH1F *fLSElecPt;// LS elec pt
+
+ Double_t fminTPC; //ID cuts tpc
+ Double_t fmaxTPC; //ID cuts tpc
+ Double_t fminEovP; //ID cuts eovp
+ Double_t fmaxEovP;//ID cuts eovp
+ Double_t fminM20;//ID cuts SS
+ Double_t fmaxM20;//ID cuts SS
+ Double_t fminM02;//ID cuts SS
+ Double_t fmaxM02;//ID cuts SS
+ Double_t fDispersion;//ID cuts SS
+
+
+ AliAnalysisTaskFlowTPCEMCalQSP(const AliAnalysisTaskFlowTPCEMCalQSP&); // not implemented
+ AliAnalysisTaskFlowTPCEMCalQSP& operator=(const AliAnalysisTaskFlowTPCEMCalQSP&); // not implemented
+
+ ClassDef(AliAnalysisTaskFlowTPCEMCalQSP, 2); //!example of analysis
+};
+
+#endif
+
+
\r
#include "AliCentrality.h"\r
#include "AliEventplane.h"\r
-#include "AliAnalysisTaskHFEFlow.h"\r
+#include "AliAnalysisTaskFlowTPCTOFEPSP.h"\r
#include "AliAODMCHeader.h"\r
#include "TClonesArray.h"\r
#include "AliHFENonPhotonicElectron.h"\r
\r
\r
//____________________________________________________________________\r
-AliAnalysisTaskHFEFlow::AliAnalysisTaskHFEFlow() :\r
+AliAnalysisTaskFlowTPCTOFEPSP::AliAnalysisTaskFlowTPCTOFEPSP() :\r
AliAnalysisTaskSE(),\r
fListHist(0x0), \r
fAODAnalysis(kFALSE),\r
\r
}\r
//______________________________________________________________________________\r
-AliAnalysisTaskHFEFlow:: AliAnalysisTaskHFEFlow(const char *name) :\r
+AliAnalysisTaskFlowTPCTOFEPSP:: AliAnalysisTaskFlowTPCTOFEPSP(const char *name) :\r
AliAnalysisTaskSE(name),\r
fListHist(0x0),\r
fAODAnalysis(kFALSE),\r
\r
}\r
//____________________________________________________________\r
-AliAnalysisTaskHFEFlow::AliAnalysisTaskHFEFlow(const AliAnalysisTaskHFEFlow &ref):\r
+AliAnalysisTaskFlowTPCTOFEPSP::AliAnalysisTaskFlowTPCTOFEPSP(const AliAnalysisTaskFlowTPCTOFEPSP &ref):\r
AliAnalysisTaskSE(ref),\r
fListHist(NULL),\r
fAODAnalysis(ref.fAODAnalysis), \r
}\r
\r
//____________________________________________________________\r
-AliAnalysisTaskHFEFlow &AliAnalysisTaskHFEFlow::operator=(const AliAnalysisTaskHFEFlow &ref){\r
+AliAnalysisTaskFlowTPCTOFEPSP &AliAnalysisTaskFlowTPCTOFEPSP::operator=(const AliAnalysisTaskFlowTPCTOFEPSP &ref){\r
//\r
// Assignment operator\r
//\r
}\r
\r
//____________________________________________________________\r
-void AliAnalysisTaskHFEFlow::Copy(TObject &o) const {\r
+void AliAnalysisTaskFlowTPCTOFEPSP::Copy(TObject &o) const {\r
// \r
// Copy into object o\r
//\r
- AliAnalysisTaskHFEFlow &target = dynamic_cast<AliAnalysisTaskHFEFlow &>(o);\r
+ AliAnalysisTaskFlowTPCTOFEPSP &target = dynamic_cast<AliAnalysisTaskFlowTPCTOFEPSP &>(o);\r
target.fAODAnalysis = fAODAnalysis;\r
target.fUseFilterAOD = fUseFilterAOD;\r
target.fApplyCut = fApplyCut;\r
target.fDebugStreamer=fDebugStreamer;\r
}\r
//____________________________________________________________\r
-AliAnalysisTaskHFEFlow::~AliAnalysisTaskHFEFlow(){\r
+AliAnalysisTaskFlowTPCTOFEPSP::~AliAnalysisTaskFlowTPCTOFEPSP(){\r
//\r
// Destructor\r
//\r
\r
}\r
//________________________________________________________________________\r
-void AliAnalysisTaskHFEFlow::UserCreateOutputObjects()\r
+void AliAnalysisTaskFlowTPCTOFEPSP::UserCreateOutputObjects()\r
{\r
\r
//********************\r
\r
AliDebug(2,"test");\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: User create output objects");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: User create output objects");\r
\r
// AOD or ESD\r
AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
SetAODAnalysis(kFALSE);\r
}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: AOD ESD");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: AOD ESD");\r
\r
// RP TRACK CUTS:\r
fcutsRP = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010();\r
//TList *qaCutsRP = fcutsRP->GetQA();\r
//qaCutsRP->SetName("QA_StandartTPC_RP");\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cutsRP");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cutsRP");\r
\r
//POI TRACK CUTS:\r
fcutsPOI = new AliFlowTrackCuts("dummy");\r
}\r
else fflowEvent = new AliFlowEvent(fcutsRP,fcutsPOI);\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cutsPOI");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cutsPOI");\r
\r
// Flow\r
AliFlowCommonConstants* cc = AliFlowCommonConstants::GetMaster();\r
cc->SetQMin(0.0);\r
cc->SetQMax(3.0);\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: common constants");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: common constants");\r
\r
\r
// HFE cuts\r
fHFECuts->Initialize();\r
if(fAODAnalysis) fHFECuts->SetAOD(); \r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: HFE cuts");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: HFE cuts");\r
\r
\r
// PID HFE\r
//fPID->SetHasMCData(HasMCData());\r
if(!fPID) {\r
fPID =new AliHFEpid("hfePid");\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: pid init 0");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid init 0");\r
}\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: pid init 1");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid init 1");\r
if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);\r
- AliDebug(2,Form("AliAnalysisTaskHFEFlow: GetNumber of PID detectors %d",fPID->GetNumberOfPIDdetectors()));\r
+ AliDebug(2,Form("AliAnalysisTaskFlowTPCTOFEPSP: GetNumber of PID detectors %d",fPID->GetNumberOfPIDdetectors()));\r
fPID->InitializePID();\r
AliDebug(2,"Init ");\r
fPIDqa->Initialize(fPID);\r
fPID->SortDetectors();\r
AliDebug(2,"Sort detectors");\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: pid and pidqa");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid and pidqa");\r
\r
if(!fPIDTOFOnly->GetNumberOfPIDdetectors()) fPIDTOFOnly->AddDetector("TPC", 0);\r
fPIDTOFOnly->InitializePID();\r
fPIDTOFOnly->SortDetectors();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: pidtof");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pidtof");\r
\r
// HFE Background cuts\r
\r
fHFEBackgroundCuts->SetPtRange(0.3,1e10);\r
}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: hfe background");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: hfe background");\r
\r
// PID background HFE\r
if(!fPIDBackground->GetNumberOfPIDdetectors()) fPIDBackground->AddDetector("TPC", 0);\r
fPIDBackgroundqa->Initialize(fPIDBackground);\r
fPIDBackground->SortDetectors();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: pid background");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid background");\r
\r
if (fMonitorPhotonic) {\r
if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();\r
Double_t binLimInvMass[nBinsInvMass+1];\r
for(Int_t i=0; i<=nBinsInvMass; i++) binLimInvMass[i]=(Double_t)minInvMass + (maxInvMass-minInvMass)/nBinsInvMass*(Double_t)i ;\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: variables");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: variables");\r
\r
//******************\r
// Histograms\r
fListHist = new TList();\r
fListHist->SetOwner();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: list");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: list");\r
\r
// Minimum histos\r
\r
// Histos\r
fHistEV = new TH2D("fHistEV", "events", 3, 0, 3, 3, 0,3);\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: histev");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: histev");\r
\r
// Event plane as function of phiep, centrality\r
const Int_t nDima=4;\r
fEventPlane->SetBinEdges(3,binLimC);\r
fEventPlane->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: eventplane");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: eventplane");\r
\r
// Fraction of contamination, centrality\r
const Int_t nDimcont=2;\r
fContaminationv2 = new TProfile2D("Contaminationv2","",nBinsC,binLimC,nBinsPt,binLimPt);\r
fContaminationv2->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: fraction of contamination");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: fraction of contamination");\r
\r
// Resolution cosres_abc centrality\r
const Int_t nDimfbis=4;\r
fCosResabc->SetBinEdges(3,binLimCMore);\r
fCosResabc->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosresabc");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosresabc");\r
\r
// Resolution cosres centrality\r
const Int_t nDimf=2;\r
fCosRes->SetBinEdges(1,binLimCMore);\r
fCosRes->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosres");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosres");\r
\r
// Maps delta phi\r
const Int_t nDimg=5;\r
fDeltaPhiMaps->SetBinEdges(4,binLimEtaLess);\r
fDeltaPhiMaps->Sumw2(); \r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimaps");\r
\r
// Maps cos phi\r
const Int_t nDimh=5;\r
fCosPhiMaps->SetBinEdges(4,binLimEtaLess);\r
fCosPhiMaps->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimaps");\r
\r
//\r
// fMonitorEventPlane\r
fEventPlaneaftersubtraction->SetBinEdges(1,binLimC);\r
fEventPlaneaftersubtraction->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: eventplane after sub");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: eventplane after sub");\r
\r
// Monitoring of the event Plane cos(2phi) sin(2phi) centrality\r
const Int_t nDimi=3;\r
fCosSin2phiep->SetBinEdges(2,binLimCMore);\r
fCosSin2phiep->Sumw2();\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cossin2phiep");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cossin2phiep");\r
\r
// Monitoring Event plane after subtraction of the track\r
const Int_t nDime=4;\r
fCos2phie->SetBinEdges(0,binLimCos);\r
fCos2phie->SetBinEdges(1,binLimC);\r
fCos2phie->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cos2phie");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cos2phie");\r
fSin2phie = new THnSparseF("sin2phie","sin2phie",nDime,nBine);\r
fSin2phie->SetBinEdges(2,binLimPt);\r
fSin2phie->SetBinEdges(3,binLimEta);\r
fSin2phie->SetBinEdges(0,binLimCos);\r
fSin2phie->SetBinEdges(1,binLimC);\r
fSin2phie->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: sin2phie");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phie");\r
fCos2phiep = new THnSparseF("cos2phiep","cos2phiep",nDime,nBine);\r
fCos2phiep->SetBinEdges(2,binLimPt);\r
fCos2phiep->SetBinEdges(3,binLimEta);\r
fCos2phiep->SetBinEdges(0,binLimCos);\r
fCos2phiep->SetBinEdges(1,binLimC);\r
fCos2phiep->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cos2phiep");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cos2phiep");\r
fSin2phiep = new THnSparseF("sin2phiep","sin2phiep",nDime,nBine);\r
fSin2phiep->SetBinEdges(2,binLimPt);\r
fSin2phiep->SetBinEdges(3,binLimEta);\r
fSin2phiep->SetBinEdges(0,binLimCos);\r
fSin2phiep->SetBinEdges(1,binLimC);\r
fSin2phiep->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: sin2phiep");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phiep");\r
fSin2phiephiep = new THnSparseF("sin2phie_phiep","sin2phie_phiep",nDime,nBine);\r
fSin2phiephiep->SetBinEdges(2,binLimPt);\r
fSin2phiephiep->SetBinEdges(3,binLimEta);\r
fSin2phiephiep->SetBinEdges(0,binLimCos);\r
fSin2phiephiep->SetBinEdges(1,binLimC);\r
fSin2phiephiep->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: sin2phiephiep");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phiephiep");\r
\r
const Int_t nDimfbiss=4;\r
Int_t nBinfbiss[nDimfbiss] = {nBinsCos,nBinsCos,nBinsCos,nBinsC};\r
fSinResabc->SetBinEdges(2,binLimCos);\r
fSinResabc->SetBinEdges(3,binLimC);\r
fSinResabc->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: sinresabc");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sinresabc");\r
\r
// Profile cosres centrality with 3 subevents\r
fProfileCosResab = new TProfile("ProfileCosRes_a_b","ProfileCosRes_a_b",nBinsCMore,binLimCMore);\r
fProfileCosResac->Sumw2();\r
fProfileCosResbc = new TProfile("ProfileCosRes_b_c","ProfileCosRes_b_c",nBinsCMore,binLimCMore);\r
fProfileCosResbc->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: profilecosresbc");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosresbc");\r
\r
//\r
const Int_t nDimff=2;\r
fSinRes->SetBinEdges(0,binLimCos);\r
fSinRes->SetBinEdges(1,binLimC);\r
fSinRes->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: sinres");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sinres");\r
\r
// Profile cosres centrality\r
fProfileCosRes = new TProfile("ProfileCosRes","ProfileCosRes",nBinsCMore,binLimCMore);\r
fProfileCosRes->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: profilecosres");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosres");\r
\r
// Profile Maps cos phi\r
fProfileCosPhiMaps = new TProfile2D("ProfileCosPhiMaps","ProfileCosPhiMaps",nBinsC,binLimC,nBinsPt,binLimPt);\r
fProfileCosPhiMaps->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: profilecosphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosphimaps");\r
\r
}\r
//\r
fTrackingCuts->SetBinEdges(0,binLimPt);\r
fTrackingCuts->SetBinEdges(1,binLimStep);\r
fTrackingCuts->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: trackingcuts");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: trackingcuts");\r
}\r
\r
//\r
fDeltaPhiMapsContamination->SetBinEdges(2,binLimPt);\r
fDeltaPhiMapsContamination->SetBinEdges(3,binLimTPCdEdx);\r
fDeltaPhiMapsContamination->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimapscontamination");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapscontamination");\r
\r
}\r
//\r
fDeltaPhiMapsBeforePID->SetBinEdges(1,binLimC);\r
fDeltaPhiMapsBeforePID->SetBinEdges(2,binLimPt);\r
fDeltaPhiMapsBeforePID->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimapsbeforepid");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapsbeforepid");\r
\r
const Int_t nDimhb=3;\r
Int_t nBinhb[nDimhb] = {nBinsCos,nBinsC,nBinsPt};\r
fCosPhiMapsBeforePID->SetBinEdges(1,binLimC);\r
fCosPhiMapsBeforePID->SetBinEdges(2,binLimPt);\r
fCosPhiMapsBeforePID->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosphimapsbeforepid");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapsbeforepid");\r
}\r
//\r
// fMonitorPhotonic\r
fDeltaPhiMapsTaggedPhotonic->SetBinEdges(1,binLimC);\r
fDeltaPhiMapsTaggedPhotonic->SetBinEdges(2,binLimPt);\r
fDeltaPhiMapsTaggedPhotonic->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimapstaggedphotonic");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggedphotonic");\r
\r
fDeltaPhiMapsTaggedNonPhotonic = new THnSparseF("DeltaPhiMapsTaggedNonPhotonic","DeltaPhiMapsTaggedNonPhotonic",nDimgbp,nBingbp);\r
fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(0,binLimPhi);\r
fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(1,binLimC);\r
fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(2,binLimPt);\r
fDeltaPhiMapsTaggedNonPhotonic->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimapstaggednonphotonic");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggednonphotonic");\r
\r
fDeltaPhiMapsTaggedPhotonicLS = new THnSparseF("DeltaPhiMapsTaggedPhotonicLS","DeltaPhiMapsTaggedPhotonicLS",nDimgbp,nBingbp);\r
fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(0,binLimPhi);\r
fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(1,binLimC);\r
fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(2,binLimPt);\r
fDeltaPhiMapsTaggedPhotonicLS->Sumw2(); \r
- AliDebug(2,"AliAnalysisTaskHFEFlow: deltaphimapstaggedphotonicls"); \r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggedphotonicls"); \r
\r
/*\r
const Int_t nDimhbp=3;\r
fCosPhiMapsTaggedPhotonic->SetBinEdges(1,binLimC);\r
fCosPhiMapsTaggedPhotonic->SetBinEdges(2,binLimPt);\r
fCosPhiMapsTaggedPhotonic->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosphimapstaggedphotonic");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggedphotonic");\r
\r
fCosPhiMapsTaggedNonPhotonic = new THnSparseF("CosPhiMapsTaggedNonPhotonic","CosPhiMapsTaggedNonPhotonic",nDimhbp,nBinhbp);\r
fCosPhiMapsTaggedNonPhotonic->SetBinEdges(0,binLimCos);\r
fCosPhiMapsTaggedNonPhotonic->SetBinEdges(1,binLimC);\r
fCosPhiMapsTaggedNonPhotonic->SetBinEdges(2,binLimPt);\r
fCosPhiMapsTaggedNonPhotonic->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosphimapstaggednonphotonic");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggednonphotonic");\r
\r
fCosPhiMapsTaggedPhotonicLS = new THnSparseF("CosPhiMapsTaggedPhotonicLS","CosPhiMapsTaggedPhotonicLS",nDimhbp,nBinhbp);\r
fCosPhiMapsTaggedPhotonicLS->SetBinEdges(0,binLimCos);\r
fCosPhiMapsTaggedPhotonicLS->SetBinEdges(1,binLimC);\r
fCosPhiMapsTaggedPhotonicLS->SetBinEdges(2,binLimPt);\r
fCosPhiMapsTaggedPhotonicLS->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: cosphimapstaggedphotonicls");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggedphotonicls");\r
*/\r
const Int_t nDimMCSource=3;\r
Int_t nBinMCSource[nDimMCSource] = {nBinsC,nBinsPt,nBinsSource};\r
fMCSourceDeltaPhiMaps->SetBinEdges(1,binLimPt);\r
fMCSourceDeltaPhiMaps->SetBinEdges(2,binLimSource);\r
fMCSourceDeltaPhiMaps->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: mcsourcedeltaphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: mcsourcedeltaphimaps");\r
\r
// Maps invmass opposite\r
const Int_t nDimOppSign=5;\r
fOppSignDeltaPhiMaps->SetBinEdges(3,binLimInvMass);\r
fOppSignDeltaPhiMaps->SetBinEdges(4,binLimSource);\r
fOppSignDeltaPhiMaps->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: oppsigndeltaphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: oppsigndeltaphimaps");\r
\r
// Maps invmass same sign\r
const Int_t nDimSameSign=5;\r
fSameSignDeltaPhiMaps->SetBinEdges(3,binLimInvMass);\r
fSameSignDeltaPhiMaps->SetBinEdges(4,binLimSource);\r
fSameSignDeltaPhiMaps->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: samesigndeltaphimaps");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: samesigndeltaphimaps");\r
\r
// Maps angle same sign\r
const Int_t nDimAngleSameSign=3;\r
fSameSignAngle->SetBinEdges(1,binLimC);\r
fSameSignAngle->SetBinEdges(2,binLimSource);\r
fSameSignAngle->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: samesignangle");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: samesignangle");\r
\r
// Maps angle opp sign\r
const Int_t nDimAngleOppSign=3;\r
fOppSignAngle->SetBinEdges(1,binLimC);\r
fOppSignAngle->SetBinEdges(2,binLimSource);\r
fOppSignAngle->Sumw2();\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: oppsignangle");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: oppsignangle");\r
\r
}\r
\r
fListHist->Add(fDeltaPhiMaps);\r
fListHist->Add(fPIDqa->MakeList("HFEpidQA"));\r
fListHist->Add(fContaminationv2);\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add default");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add default");\r
\r
if(fMonitorEventPlane) {\r
fListHist->Add(fProfileCosRes);\r
fListHist->Add(fSinResabc);\r
fListHist->Add(fProfileCosPhiMaps);\r
}\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add monitor");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add monitor");\r
\r
if(fMonitorTrackCuts) fListHist->Add(fTrackingCuts);\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add monitortrackcuts");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add monitortrackcuts");\r
\r
if(fMonitorContamination) {\r
fListHist->Add(fDeltaPhiMapsContamination);\r
}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add deltaphimapscontamination");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add deltaphimapscontamination");\r
\r
if(fMonitorWithoutPID) {\r
fListHist->Add(fDeltaPhiMapsBeforePID);\r
fListHist->Add(fCosPhiMapsBeforePID);\r
}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add without pid");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add without pid");\r
\r
if(fMonitorPhotonic) {\r
fListHist->Add(fPIDBackgroundqa->MakeList("HFEpidBackgroundQA"));\r
fListHist->Add(fBackgroundSubtraction->GetListOutput());\r
}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add photonic");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add photonic");\r
\r
if(fHFEVZEROEventPlane && fMonitorEventPlane) fListHist->Add(fHFEVZEROEventPlane->GetOutputList());\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: add event plane");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add event plane");\r
\r
PostData(1, fListHist);\r
//for(Int_t bincless = 0; bincless < fNbBinsCentralityQCumulant; bincless++) {\r
// PostData(bincless+2,fflowEvent); \r
//}\r
\r
- AliDebug(2,"AliAnalysisTaskHFEFlow: post");\r
+ AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: post");\r
\r
\r
}\r
\r
//________________________________________________________________________\r
-void AliAnalysisTaskHFEFlow::UserExec(Option_t */*option*/)\r
+void AliAnalysisTaskFlowTPCTOFEPSP::UserExec(Option_t */*option*/)\r
{\r
//\r
// Loop over event\r
\r
}\r
//______________________________________________________________________________\r
-AliFlowCandidateTrack *AliAnalysisTaskHFEFlow::MakeTrack( Double_t mass, \r
+AliFlowCandidateTrack *AliAnalysisTaskFlowTPCTOFEPSP::MakeTrack( Double_t mass, \r
Double_t pt, Double_t phi, Double_t eta) {\r
//\r
// Make Track (Not needed actually)\r
return sTrack;\r
}\r
//_________________________________________________________________________________ \r
-Double_t AliAnalysisTaskHFEFlow::GetPhiAfterAddV2(Double_t phi,Double_t reactionPlaneAngle) const\r
+Double_t AliAnalysisTaskFlowTPCTOFEPSP::GetPhiAfterAddV2(Double_t phi,Double_t reactionPlaneAngle) const\r
{\r
//\r
// Adds v2, uses Newton-Raphson iteration\r
return phiend;\r
}\r
//_____________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *vEvent, AliMCEvent *mcEvent,Int_t binct,Double_t deltaphi,Int_t source,Int_t indexmother)\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *vEvent, AliMCEvent *mcEvent,Int_t binct,Double_t deltaphi,Int_t source,Int_t indexmother)\r
{ \r
//\r
// Look At Non HFE\r
return taggedphotonic;\r
}\r
//_________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::FindMother(Int_t tr, AliMCEvent *mcEvent, Int_t &indexmother){\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::FindMother(Int_t tr, AliMCEvent *mcEvent, Int_t &indexmother){\r
//\r
// Find the mother if MC\r
//\r
\r
}\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::CheckPdg(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::CheckPdg(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the pdg of the particle\r
\r
}\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::IsMotherGamma(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherGamma(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the lab of gamma mother or -1 if not gamma\r
}\r
//\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::IsMotherPi0(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherPi0(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the lab of pi0 mother or -1 if not pi0\r
\r
}\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::IsMotherC(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherC(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the lab of signal mother or -1 if not signal\r
\r
}\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::IsMotherB(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherB(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the lab of signal mother or -1 if not signal\r
\r
}\r
//____________________________________________________________________________________________________________\r
-Int_t AliAnalysisTaskHFEFlow::IsMotherEta(Int_t tr, AliMCEvent* mcEvent) {\r
+Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherEta(Int_t tr, AliMCEvent* mcEvent) {\r
\r
//\r
// Return the lab of pi0 mother or -1 if not pi0\r
// Flow task class for the ALICE HFE group\r
//\r
//\r
-#ifndef ALIANALYSISTASKHFEFLOW_H\r
-#define ALIANALYSISTASKHFEFLOW_H\r
+#ifndef ALIANALYSISTASKFlowTPCTOFEPSP_H\r
+#define ALIANALYSISTASKFlowTPCTOFEPSP_H\r
\r
\r
\r
class AliHFENonPhotonicElectron;\r
class TTreeSRedirector;\r
\r
-class AliAnalysisTaskHFEFlow: public AliAnalysisTaskSE {\r
+class AliAnalysisTaskFlowTPCTOFEPSP: public AliAnalysisTaskSE {\r
public:\r
\r
typedef enum{\r
\r
\r
\r
- AliAnalysisTaskHFEFlow();\r
- AliAnalysisTaskHFEFlow(const char *name);\r
- AliAnalysisTaskHFEFlow(const AliAnalysisTaskHFEFlow &ref);\r
- AliAnalysisTaskHFEFlow& operator=(const AliAnalysisTaskHFEFlow &ref);\r
+ AliAnalysisTaskFlowTPCTOFEPSP();\r
+ AliAnalysisTaskFlowTPCTOFEPSP(const char *name);\r
+ AliAnalysisTaskFlowTPCTOFEPSP(const AliAnalysisTaskFlowTPCTOFEPSP &ref);\r
+ AliAnalysisTaskFlowTPCTOFEPSP& operator=(const AliAnalysisTaskFlowTPCTOFEPSP &ref);\r
virtual void Copy(TObject &o) const;\r
- virtual ~AliAnalysisTaskHFEFlow();\r
+ virtual ~AliAnalysisTaskFlowTPCTOFEPSP();\r
\r
virtual void UserExec(Option_t */*option*/);\r
virtual void UserCreateOutputObjects();\r
Int_t IsMotherEta(Int_t tr, AliMCEvent* mcEvent);\r
\r
\r
- ClassDef(AliAnalysisTaskHFEFlow, 1); // analysisclass\r
+ ClassDef(AliAnalysisTaskFlowTPCTOFEPSP, 1); // analysisclass\r
};\r
\r
#endif\r