#include <TTree.h>\r
#include <TList.h>\r
#include <TArrayI.h>\r
+#include <TParameter.h>\r
#include <TRandom.h>\r
#include <TParticle.h>\r
#include <TFile.h>\r
#include "AliCodeTimer.h"\r
#include "AliESDtrackCuts.h"\r
#include "AliESDpid.h"\r
+#include "AliV0vertexer.h"\r
+#include "AliCascadeVertexer.h"\r
#include "Riostream.h"\r
+#include "AliExternalTrackParam.h"\r
+#include "AliTrackerBase.h"\r
+#include "TVector3.h"\r
+#include "AliTPCdEdxInfo.h"\r
\r
ClassImp(AliAnalysisTaskESDfilter)\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():\r
- AliAnalysisTaskSE(),\r
- fTrackFilter(0x0),\r
- fKinkFilter(0x0),\r
- fV0Filter(0x0),\r
- fCascadeFilter(0x0),\r
- fHighPthreshold(0),\r
- fPtshape(0x0),\r
- fEnableFillAOD(kTRUE),\r
- fUsedTrack(0x0),\r
- fUsedKink(0x0),\r
- fUsedV0(0x0),\r
- fAODTrackRefs(0x0),\r
- fAODV0VtxRefs(0x0),\r
- fAODV0Refs(0x0),\r
- fMChandler(0x0),\r
- fNumberOfTracks(0),\r
- fNumberOfPositiveTracks(0),\r
- fNumberOfV0s(0),\r
- fNumberOfVertices(0),\r
- fNumberOfCascades(0),\r
- fNumberOfKinks(0),\r
- fOldESDformat(kFALSE),\r
- fPrimaryVertex(0x0),\r
+ AliAnalysisTaskSE(),\r
+ fTrackFilter(0x0),\r
+ fKinkFilter(0x0),\r
+ fV0Filter(0x0),\r
+ fCascadeFilter(0x0),\r
+ fHighPthreshold(0),\r
+ fPtshape(0x0),\r
+ fEnableFillAOD(kTRUE),\r
+ fUsedTrack(0x0),\r
+ fUsedKink(0x0),\r
+ fUsedV0(0x0),\r
+ fAODTrackRefs(0x0),\r
+ fAODV0VtxRefs(0x0),\r
+ fAODV0Refs(0x0),\r
+ fMChandler(0x0),\r
+ fNumberOfTracks(0),\r
+ fNumberOfPositiveTracks(0),\r
+ fNumberOfV0s(0),\r
+ fNumberOfVertices(0),\r
+ fNumberOfCascades(0),\r
+ fNumberOfKinks(0),\r
+ fOldESDformat(kFALSE),\r
+ fPrimaryVertex(0x0),\r
fTPCConstrainedFilterMask(0),\r
fHybridFilterMaskTPCCG(0),\r
fWriteHybridTPCCOnly(kFALSE),\r
fGlobalConstrainedFilterMask(0),\r
fHybridFilterMaskGCG(0),\r
fWriteHybridGCOnly(kFALSE),\r
- fIsVZEROEnabled(kTRUE),\r
- fIsZDCEnabled(kTRUE),\r
- fAreCascadesEnabled(kTRUE),\r
- fAreV0sEnabled(kTRUE),\r
- fAreKinksEnabled(kTRUE),\r
- fAreTracksEnabled(kTRUE),\r
- fArePmdClustersEnabled(kTRUE),\r
- fAreCaloClustersEnabled(kTRUE),\r
- fAreEMCALCellsEnabled(kTRUE),\r
- fArePHOSCellsEnabled(kTRUE),\r
- fAreTrackletsEnabled(kTRUE),\r
- fESDpid(0x0),\r
- fIsPidOwner(kFALSE),\r
- fTimeZeroType(AliESDpid::kTOF_T0),\r
- fTPCaloneTrackCuts(0)\r
+ fIsVZEROEnabled(kTRUE),\r
+ fIsTZEROEnabled(kTRUE),\r
+ fIsZDCEnabled(kTRUE),\r
+ fIsV0CascadeRecoEnabled(kFALSE),\r
+ fAreCascadesEnabled(kTRUE),\r
+ fAreV0sEnabled(kTRUE),\r
+ fAreKinksEnabled(kTRUE),\r
+ fAreTracksEnabled(kTRUE),\r
+ fArePmdClustersEnabled(kTRUE),\r
+ fAreCaloClustersEnabled(kTRUE),\r
+ fAreEMCALCellsEnabled(kTRUE),\r
+ fArePHOSCellsEnabled(kTRUE),\r
+ fAreEMCALTriggerEnabled(kTRUE),\r
+ fArePHOSTriggerEnabled(kTRUE),\r
+ fAreTrackletsEnabled(kTRUE),\r
+ fESDpid(0x0),\r
+ fIsPidOwner(kFALSE),\r
+ fTimeZeroType(AliESDpid::kTOF_T0),\r
+ fTPCaloneTrackCuts(0),\r
+ fDoPropagateTrackToEMCal(kTRUE)\r
{\r
// Default constructor\r
+ fV0Cuts[0] = 33. ; // max allowed chi2\r
+ fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter\r
+ fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter\r
+ fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks\r
+ fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle\r
+ fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume\r
+ fV0Cuts[6] = 100. ; // max radius of the fiducial volume\r
+\r
+ fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)\r
+ fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter\r
+ fCascadeCuts[2] = 0.008; // "window" around the Lambda mass\r
+ fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter\r
+ fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor\r
+ fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle\r
+ fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume\r
+ fCascadeCuts[7] = 100. ; // max radius of the fiducial volume\r
}\r
\r
//______________________________________________________________________________\r
fHybridFilterMaskGCG(0),\r
fWriteHybridGCOnly(kFALSE),\r
fIsVZEROEnabled(kTRUE),\r
+ fIsTZEROEnabled(kTRUE),\r
fIsZDCEnabled(kTRUE),\r
+ fIsV0CascadeRecoEnabled(kFALSE),\r
fAreCascadesEnabled(kTRUE),\r
fAreV0sEnabled(kTRUE),\r
fAreKinksEnabled(kTRUE),\r
fAreCaloClustersEnabled(kTRUE),\r
fAreEMCALCellsEnabled(kTRUE),\r
fArePHOSCellsEnabled(kTRUE),\r
- fAreTrackletsEnabled(kTRUE),\r
+ fAreEMCALTriggerEnabled(kTRUE),\r
+ fArePHOSTriggerEnabled(kTRUE),\r
+ fAreTrackletsEnabled(kTRUE),\r
fESDpid(0x0),\r
fIsPidOwner(kFALSE),\r
fTimeZeroType(AliESDpid::kTOF_T0),\r
- fTPCaloneTrackCuts(0)\r
+ fTPCaloneTrackCuts(0),\r
+ fDoPropagateTrackToEMCal(kTRUE)\r
{\r
// Constructor\r
+\r
+ fV0Cuts[0] = 33. ; // max allowed chi2\r
+ fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter\r
+ fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter\r
+ fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks\r
+ fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle\r
+ fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume\r
+ fV0Cuts[6] = 100. ; // max radius of the fiducial volume\r
+\r
+ fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)\r
+ fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter\r
+ fCascadeCuts[2] = 0.008; // "window" around the Lambda mass\r
+ fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter\r
+ fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor\r
+ fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle\r
+ fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume\r
+ fCascadeCuts[7] = 100. ; // max radius of the fiducial volume\r
+\r
+\r
+\r
}\r
AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){\r
if(fIsPidOwner) delete fESDpid;\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const\r
{\r
+// Print selection task information\r
AliInfo("");\r
\r
AliAnalysisTaskSE::PrintTask(option,indent);\r
\r
TString spaces(' ',indent+3);\r
\r
- cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;\r
- cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl; \r
+ cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("EMCAL triggers are %s",fAreEMCALTriggerEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("PHOS triggers are %s",fArePHOSTriggerEnabled ? "ENABLED":"DISABLED") << endl;\r
+ cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl; \r
+ cout << spaces.Data() << Form("PropagateTrackToEMCal is %s", fDoPropagateTrackToEMCal ? "ENABLED":"DISABLED") << endl; \r
}\r
\r
//______________________________________________________________________________\r
//______________________________________________________________________________\r
AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)\r
{\r
+// Convert header information\r
+\r
AliCodeTimerAuto("",0);\r
\r
AliAODHeader* header = AODEvent()->GetHeader();\r
header->SetDiamond(diamxy,diamcov);\r
header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());\r
\r
+ // VZERO channel equalization factors for event-plane reconstruction \r
+ header->SetVZEROEqFactors(esd.GetVZEROEqFactors());\r
+\r
return header;\r
}\r
\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd) \r
{\r
+\r
// Convert the cascades part of the ESD.\r
// Return the number of cascades\r
\r
vtx->UsesTrack(esdCascadeBach->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ aodTrack->SetTPCFitMap(esdCascadeBach->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));\r
vtx->UsesTrack(esdCascadePos->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ aodTrack->SetTPCFitMap(esdCascadePos->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));\r
vtx->UsesTrack(esdCascadeNeg->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ aodTrack->SetTPCFitMap(esdCascadeNeg->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));\r
vtx->UsesTrack(esdV0Pos->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ aodTrack->SetTPCFitMap(esdV0Pos->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));\r
vtx->UsesTrack(esdV0Neg->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ aodTrack->SetTPCFitMap(esdV0Neg->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));\r
if(map&fHybridFilterMaskTPCCG){\r
// this is one part of the hybrid tracks\r
// the others not passing the selection will be TPC only selected below\r
- // tr->SetIsHybridTPCConstrainedGlobal(kTRUE);\r
+ tr->SetIsHybridTPCConstrainedGlobal(kTRUE);\r
}\r
}\r
// Loop over the ESD trcks and pick out the tracks passing TPC only cuts\r
Double_t pos[3] = { 0. }; \r
Double_t covTr[21]={0.};\r
Double_t pid[10]={0.}; \r
+\r
+\r
Double_t p[3] = { 0. };\r
\r
Double_t pDCA[3] = { 0. }; // momentum at DCA\r
\r
\r
AliAODTrack* aodTrack(0x0);\r
- \r
+ // AliAODPid* detpid(0x0);\r
+\r
+ // account for change in pT after the constraint\r
+ Float_t ptMax = 1E10;\r
+ Float_t ptMin = 0;\r
+ for(int i = 0;i<32;i++){\r
+ if(fTPCConstrainedFilterMask&(1<<i)){\r
+ AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);\r
+ Float_t tmp1= 0,tmp2 = 0;\r
+ cuts->GetPtRange(tmp1,tmp2);\r
+ if(tmp1>ptMin)ptMin=tmp1;\r
+ if(tmp2<ptMax)ptMax=tmp2;\r
+ }\r
+ } \r
+\r
for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
{\r
AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy \r
}\r
\r
track->GetPxPyPz(p);\r
+\r
+ Float_t pT = track->Pt();\r
+ if(pT<ptMin||pT>ptMax){\r
+ delete track;\r
+ continue;\r
+ }\r
+\r
+ // \r
+\r
+\r
track->GetXYZ(pos);\r
track->GetCovarianceXYZPxPyPz(covTr);\r
- track->GetESDpid(pid);\r
+ esdTrack->GetESDpid(pid);// original PID\r
+\r
if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,\r
track->GetLabel(),\r
vtx->UsesTrack(track->GetID()),\r
AliAODTrack::kPrimary, \r
selectInfo);\r
- // aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC); \r
+ aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC); \r
+ aodTrack->SetTPCFitMap(track->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\r
- // aodTrack->SetIsTPCConstrained(kTRUE); \r
- Float_t ndf = track->GetTPCNcls()+1 - 5 ;\r
- if(ndf>0){\r
- aodTrack->SetChi2perNDF(track->GetConstrainedChi2TPC());\r
- }\r
- else{\r
- aodTrack->SetChi2perNDF(-1);\r
- }\r
-\r
+ aodTrack->SetIsTPCConstrained(kTRUE); \r
+ aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack)); // original track\r
// set the DCA values to the AOD track\r
aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);\r
aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);\r
aodTrack->SetFlags(track->GetStatus());\r
aodTrack->SetTPCPointsF(track->GetTPCNclsF());\r
\r
+ // do not duplicate PID information \r
+ // aodTrack->ConvertAliPIDtoAODPID();\r
+ // SetAODPID(esdTrack,aodTrack,detpid);\r
+\r
delete track;\r
} // end of loop on tracks\r
\r
if(map&fHybridFilterMaskGCG){\r
// this is one part of the hybrid tracks\r
// the others not passing the selection will be the ones selected below\r
- // tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);\r
+ tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);\r
}\r
}\r
// Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts\r
\r
\r
AliAODTrack* aodTrack(0x0);\r
+ AliAODPid* detpid(0x0);\r
const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
- for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
+\r
+ // account for change in pT after the constraint\r
+ Float_t ptMax = 1E10;\r
+ Float_t ptMin = 0;\r
+ for(int i = 0;i<32;i++){\r
+ if(fGlobalConstrainedFilterMask&(1<<i)){\r
+ AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);\r
+ Float_t tmp1= 0,tmp2 = 0;\r
+ cuts->GetPtRange(tmp1,tmp2);\r
+ if(tmp1>ptMin)ptMin=tmp1;\r
+ if(tmp2<ptMax)ptMax=tmp2;\r
+ }\r
+ } \r
+\r
+\r
+\r
+ for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
{\r
AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy \r
const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();\r
// get the DCA to the vertex:\r
esdTrack->GetImpactParameters(dDCA,cDCA);\r
\r
- esdTrack->GetConstrainedPxPyPz(p);\r
+ if (!esdTrack->GetConstrainedPxPyPz(p)) continue;\r
+\r
+\r
+ Float_t pT = exParamGC->Pt();\r
+ if(pT<ptMin||pT>ptMax){\r
+ continue;\r
+ }\r
+\r
+\r
esdTrack->GetConstrainedXYZ(pos);\r
exParamGC->GetCovarianceXYZPxPyPz(covTr);\r
esdTrack->GetESDpid(pid);\r
vtx->UsesTrack(esdTrack->GetID()),\r
AliAODTrack::kPrimary, \r
selectInfo);\r
- // aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC); \r
- // aodTrack->SetIsGlobalConstrained(kTRUE); \r
+ aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC); \r
+ aodTrack->SetIsGlobalConstrained(kTRUE); \r
+ aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\r
- Float_t ndf = esdTrack->GetTPCNcls()+1 - 5 ;\r
- if(ndf>0){\r
- aodTrack->SetChi2perNDF(esdTrack->GetConstrainedChi2TPC());\r
- }\r
- else{\r
- aodTrack->SetChi2perNDF(-1);\r
- }\r
+ aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));\r
+\r
\r
// set the DCA values to the AOD track\r
aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);\r
\r
aodTrack->SetFlags(esdTrack->GetStatus());\r
aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
+\r
+ if(isHybridGC){\r
+ // only copy AOD information for hybrid, no duplicate information\r
+ aodTrack->ConvertAliPIDtoAODPID();\r
+ SetAODPID(esdTrack,aodTrack,detpid);\r
+ }\r
} // end of loop on tracks\r
\r
}\r
const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
Double_t p[3] = { 0. };\r
Double_t pos[3] = { 0. };\r
+ Double_t trkPos[3] = {0.,0.,0.};\r
Double_t covTr[21] = { 0. };\r
Double_t pid[10] = { 0. };\r
AliAODTrack* aodTrack(0x0);\r
AliAODTrack::kPrimary, \r
selectInfo)\r
);\r
+ aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\r
aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));\r
aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
+ if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());\r
+ if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());\r
+\r
+ //Perform progagation of tracks if needed\r
+ if(fDoPropagateTrackToEMCal)\r
+ {\r
+ Double_t EMCalEta, EMCalPhi;\r
+ Double_t trkphi = esdTrack->Phi()*TMath::RadToDeg();\r
+ if(TMath::Abs(esdTrack->Eta())<0.9 && trkphi > 10 && trkphi < 250 )\r
+ {\r
+ AliExternalTrackParam *trkParam = const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());\r
+ if(trkParam)\r
+ {\r
+ AliExternalTrackParam trkParamTmp(*trkParam);\r
+ if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, 430, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))\r
+ {\r
+ trkParamTmp.GetXYZ(trkPos);\r
+ TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);\r
+ EMCalEta = trkPosVec.Eta();\r
+ EMCalPhi = trkPosVec.Phi();\r
+ if(EMCalPhi<0) EMCalPhi += 2*TMath::Pi();\r
+ esdTrack->SetTrackPhiEtaOnEMCal(EMCalPhi,EMCalEta);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());\r
\r
fAODTrackRefs->AddAt(aodTrack, nTrack);\r
\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)\r
{\r
+// Convert PMD Clusters \r
AliCodeTimerAuto("",0);\r
Int_t jPmdClusters=0;\r
// Access to the AOD container of PMD clusters\r
}\r
}\r
\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)\r
{\r
+// Convert Calorimeter Clusters\r
AliCodeTimerAuto("",0);\r
\r
// Access to the AOD container of clusters\r
caloCluster->SetNCells(cluster->GetNCells());\r
caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());\r
caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());\r
+\r
+ caloCluster->SetTrackDistance(cluster->GetTrackDx(), cluster->GetTrackDz());\r
\r
+ Int_t nMatchCount = 0;\r
TArrayI* matchedT = cluster->GetTracksMatched();\r
if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) { \r
for (Int_t im = 0; im < matchedT->GetSize(); im++) {\r
Int_t iESDtrack = matchedT->At(im);;\r
if (fAODTrackRefs->At(iESDtrack) != 0) {\r
caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));\r
+ nMatchCount++;\r
}\r
}\r
}\r
+ if(nMatchCount==0)\r
+ caloCluster->SetTrackDistance(-999,-999);\r
\r
} \r
caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters \r
}\r
\r
+//______________________________________________________________________________\r
+void AliAnalysisTaskESDfilter::ConvertCaloTrigger(TString calo, const AliESDEvent& esd)\r
+{\r
+ AliCodeTimerAuto("",0);\r
+ \r
+ if (calo == "PHOS") \r
+ {\r
+ AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));\r
+ AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));\r
+\r
+ aodTrigger.Allocate(esdTrigger.GetEntries());\r
+ esdTrigger.Reset();\r
+\r
+ Float_t a;\r
+ Int_t tmod,tabsId;\r
+\r
+ while (esdTrigger.Next()) {\r
+ esdTrigger.GetPosition(tmod,tabsId);\r
+ esdTrigger.GetAmplitude(a);\r
+ aodTrigger.Add(tmod,tabsId,a,0.,(Int_t*)NULL,0,0,0);\r
+ }\r
+\r
+ return;\r
+ }\r
+ \r
+ AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()); \r
+ \r
+ if (aodHandler)\r
+ {\r
+ TTree *aodTree = aodHandler->GetTree();\r
+ \r
+ if (aodTree)\r
+ {\r
+ Int_t *type = esd.GetCaloTriggerType();\r
+ \r
+ for (Int_t i = 0; i < 8; i++) \r
+ {\r
+ aodTree->GetUserInfo()->Add(new TParameter<int>(Form("EMCALCaloTrigger%d",i), type[i]));\r
+ }\r
+ }\r
+ }\r
+ \r
+ AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));\r
+ \r
+ AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));\r
+ \r
+ aodTrigger.Allocate(esdTrigger.GetEntries());\r
+ \r
+ esdTrigger.Reset();\r
+ while (esdTrigger.Next())\r
+ { \r
+ Int_t px, py, ts, nTimes, times[10], b; \r
+ Float_t a, t;\r
+ \r
+ esdTrigger.GetPosition(px, py);\r
+ \r
+ esdTrigger.GetAmplitude(a);\r
+ esdTrigger.GetTime(t);\r
+ \r
+ esdTrigger.GetL0Times(times);\r
+ esdTrigger.GetNL0Times(nTimes);\r
+ \r
+ esdTrigger.GetL1TimeSum(ts);\r
+ \r
+ esdTrigger.GetTriggerBits(b);\r
+ \r
+ aodTrigger.Add(px, py, a, t, times, nTimes, ts, b);\r
+ }\r
+ \r
+ aodTrigger.SetL1Threshold(0, esdTrigger.GetL1Threshold(0));\r
+ aodTrigger.SetL1Threshold(1, esdTrigger.GetL1Threshold(1));\r
+ \r
+ Int_t v0[2] = \r
+ {\r
+ esdTrigger.GetL1V0(0),\r
+ esdTrigger.GetL1V0(1)\r
+ }; \r
+ \r
+ aodTrigger.SetL1V0(v0); \r
+ aodTrigger.SetL1FrameMask(esdTrigger.GetL1FrameMask());\r
+}\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)\r
{\r
+// Convert EMCAL Cells\r
AliCodeTimerAuto("",0);\r
// fill EMCAL cell info\r
if (esd.GetEMCALCells()) { // protection against missing ESD information\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)\r
{\r
+// Convert PHOS Cells\r
AliCodeTimerAuto("",0);\r
// fill PHOS cell info\r
if (esd.GetPHOSCells()) { // protection against missing ESD information\r
vtx->UsesTrack(esdTrack->GetID()),\r
AliAODTrack::kPrimary,\r
selectInfo);\r
+ mother->SetTPCFitMap(esdTrackM->GetTPCFitMap());\r
mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());\r
mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());\r
mother->SetChi2perNDF(Chi2perNDF(esdTrackM));\r
vtx->UsesTrack(esdTrack->GetID()),\r
AliAODTrack::kSecondary,\r
selectInfo);\r
+ daughter->SetTPCFitMap(esdTrackD->GetTPCFitMap());\r
daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());\r
daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());\r
daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());\r
pVSPD->SetName(vtxP->GetName());\r
pVSPD->SetTitle(vtxP->GetTitle());\r
pVSPD->SetNContributors(vtxP->GetNContributors()); \r
+ pVSPD->SetBC(vtxP->GetBC());\r
}\r
\r
// Add TRK pileup vertices\r
pVTRK->SetName(vtxP->GetName());\r
pVTRK->SetTitle(vtxP->GetTitle());\r
pVTRK->SetNContributors(vtxP->GetNContributors());\r
+ pVTRK->SetBC(vtxP->GetBC());\r
}\r
}\r
\r
*vzeroData = *(esd.GetVZEROData());\r
}\r
\r
+//______________________________________________________________________________\r
+void AliAnalysisTaskESDfilter::ConvertTZERO(const AliESDEvent& esd)\r
+{\r
+ // Convert TZERO data\r
+ const AliESDTZERO* esdTzero = esd.GetESDTZERO(); \r
+ AliAODTZERO* aodTzero = AODEvent()->GetTZEROData();\r
+\r
+ for (Int_t icase=0; icase<3; icase++){ \r
+ aodTzero->SetT0TOF( icase, esdTzero->GetT0TOF(icase));\r
+ aodTzero->SetT0TOFbest(icase, esdTzero->GetT0TOFbest(icase)); \r
+ }\r
+ aodTzero->SetBackgroundFlag(esdTzero->GetBackgroundFlag());\r
+ aodTzero->SetPileupFlag(esdTzero->GetPileupFlag());\r
+ aodTzero->SetSatelliteFlag(esdTzero->GetSatellite()); \r
+\r
+ Float_t rawTime[24];\r
+ for(Int_t ipmt=0; ipmt<24; ipmt++)\r
+ rawTime[ipmt] = esdTzero->GetTimeFull(ipmt,0);\r
+ \r
+ Int_t idxOfFirstPmtA = -1, idxOfFirstPmtC = -1;\r
+ Float_t timeOfFirstPmtA = 9999, timeOfFirstPmtC = 9999;\r
+ for(int ipmt=0; ipmt<12; ipmt++){\r
+ if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtC && rawTime[ipmt]!=0){\r
+ timeOfFirstPmtC = rawTime[ipmt];\r
+ idxOfFirstPmtC = ipmt;\r
+ }\r
+ }\r
+ for(int ipmt=12; ipmt<24; ipmt++){\r
+ if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtA && rawTime[ipmt]!=0 ){\r
+ timeOfFirstPmtA = rawTime[ipmt];\r
+ idxOfFirstPmtA = ipmt;\r
+ }\r
+ }\r
+\r
+ if(idxOfFirstPmtA != -1 && idxOfFirstPmtC != -1){\r
+ //speed of light in cm/ns TMath::C()*1e-7 \r
+ Float_t vertexraw = TMath::C()*1e-7 * (rawTime[idxOfFirstPmtA] - rawTime[idxOfFirstPmtC])/2;\r
+ aodTzero->SetT0VertexRaw( vertexraw );\r
+ }else{\r
+ aodTzero->SetT0VertexRaw(99999);\r
+ }\r
+\r
+}\r
+\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)\r
{\r
AliCodeTimerAuto("",0);\r
\r
fOldESDformat = ( esd->GetAliESDOld() != 0x0 );\r
- \r
+ \r
+ // Reconstruct cascades and V0 here\r
+ if (fIsV0CascadeRecoEnabled) {\r
+ esd->ResetCascades();\r
+ esd->ResetV0s();\r
+\r
+ AliV0vertexer lV0vtxer;\r
+ AliCascadeVertexer lCascVtxer;\r
+\r
+ lV0vtxer.SetCuts(fV0Cuts);\r
+ lCascVtxer.SetCuts(fCascadeCuts);\r
+\r
+\r
+ lV0vtxer.Tracks2V0vertices(esd);\r
+ lCascVtxer.V0sTracks2CascadeVertices(esd);\r
+ }\r
+\r
+ \r
fNumberOfTracks = 0;\r
fNumberOfPositiveTracks = 0;\r
fNumberOfV0s = 0;\r
AliAODHeader* header = ConvertHeader(*esd);\r
\r
if ( fIsVZEROEnabled ) ConvertVZERO(*esd);\r
+ if ( fIsTZEROEnabled ) ConvertTZERO(*esd);\r
\r
// Fetch Stack for debuggging if available \r
fMChandler=0x0;\r
if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);\r
\r
if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);\r
+ \r
+ if ( fAreEMCALTriggerEnabled )ConvertCaloTrigger(TString("EMCAL"), *esd);\r
+\r
+ if ( fArePHOSTriggerEnabled )ConvertCaloTrigger(TString("PHOS"), *esd);\r
\r
if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);\r
+ if ( fIsZDCEnabled ) ConvertZDC(*esd);\r
\r
delete fAODTrackRefs; fAODTrackRefs=0x0;\r
delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;\r
\r
aodpid->SetTPCsignal(track->GetTPCsignal());\r
aodpid->SetTPCsignalN(track->GetTPCsignalN());\r
+ if(track->GetTPCdEdxInfo()) aodpid->SetTPCdEdxInfo(track->GetTPCdEdxInfo());\r
\r
//n TRD planes = 6\r
Int_t nslices = track->GetNumberOfTRDslices()*6;\r
- Double_t *trdslices = new Double_t[nslices];\r
+ TArrayD trdslices(nslices);\r
for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {\r
for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);\r
}\r
aodpid->SetTRDmomentum(iPl,trdmom);\r
}\r
\r
- aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices);\r
+ aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices.GetArray());\r
\r
+ //TRD clusters and tracklets\r
+ aodpid->SetTRDncls(track->GetTRDncls());\r
+ aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());\r
+ \r
//TOF PID \r
Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);\r
aodpid->SetIntegratedTimes(times);\r
}\r
Printf("########################");\r
}\r
+\r
+//______________________________________________________\r
+\r