#include "AliESDMuonTrack.h"\r
#include "AliESDVertex.h"\r
#include "AliCentrality.h"\r
+#include "AliEventplane.h"\r
#include "AliESDv0.h"\r
#include "AliESDkink.h"\r
#include "AliESDcascade.h"\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
-fTPCOnlyFilterMask(0),\r
-fIsVZEROEnabled(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
+ 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
{\r
// Default constructor\r
}\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
-fTPCOnlyFilterMask(0),\r
-fIsVZEROEnabled(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
+ 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
{\r
// Constructor\r
}\r
AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){\r
- if(fIsPidOwner)delete fESDpid;\r
+ if(fIsPidOwner) delete fESDpid;\r
}\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::UserCreateOutputObjects()\r
{\r
AliError("No OutputTree() for adding the track filter");\r
}\r
+ fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();\r
}\r
\r
//______________________________________________________________________________\r
header->SetEventType(0);\r
header->SetMuonMagFieldScale(-999.);\r
header->SetCentrality(0); \r
+ header->SetEventplane(0);\r
} else {\r
header->SetBunchCrossNumber(esd.GetBunchCrossNumber());\r
header->SetOrbitNumber(esd.GetOrbitNumber());\r
else{\r
header->SetCentrality(0);\r
}\r
+ if(const_cast<AliESDEvent&>(esd).GetEventplane()){\r
+ header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());\r
+ }\r
+ else{\r
+ header->SetEventplane(0);\r
+ }\r
}\r
\r
// Trigger\r
header->SetZDCP2Energy(esd.GetZDCP2Energy());\r
header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));\r
\r
+ // ITS Cluster Multiplicty\r
+ const AliMultiplicity *mult = esd.GetMultiplicity();\r
+ for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));\r
+ \r
+ // TPC only Reference Multiplicty\r
+ Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;\r
+ header->SetTPConlyRefMultiplicity(refMult);\r
\r
+ //\r
Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};\r
Float_t diamcov[3]; \r
esd.GetDiamondCovXY(diamcov);\r
// vCascade->Print();\r
// }\r
\r
- if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), AliESDpid::kBest_T0); //in case of AOD production strating form LHC10e without Tender. \r
+ if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \r
\r
\r
// 3 - Add the bachelor track from the cascade\r
momBachAtCascadeVtx,\r
*aodV0);\r
\r
-// if (fDebug > 3) {\r
-// printf("---- Cascade / AOD cascade : \n\n");\r
-// aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());\r
-// }\r
+ if (fDebug > 10) {\r
+ printf("---- Cascade / AOD cascade : \n\n");\r
+ aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());\r
+ }\r
\r
} // end of the loop on cascades\r
\r
void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)\r
{\r
// Convert TPC only tracks\r
- \r
+ // Here we have wo hybrid appraoch to remove fakes\r
+ // ******* ITSTPC ********\r
+ // Uses a cut on the ITS properties to select global tracks\r
+ // which are than marked as HybdridITSTPC for the remainder \r
+ // the TPC only tracks are flagged as HybridITSTPConly. \r
+ // Note, in order not to get fakes back in the TPC cuts, one needs \r
+ // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)\r
+ // using cut number (3)\r
+ // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()\r
+ // ******* TPC ********\r
+ // Here, only TPC tracks are flagged that pass the tight ITS cuts and tracks that pass the TPC cuts and NOT the loose ITS cuts\r
+ // the ITS cuts neeed to be added to the filter as extra cuts, since here the selections info is reset in the global and put to the TPC only track\r
+\r
AliCodeTimerAuto("",0);\r
\r
// Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks\r
AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));\r
if(!tr)continue;\r
UInt_t map = tr->GetFilterMap();\r
- if(map&fTPCOnlyFilterMask){\r
+ if(map&fTPCConstrainedFilterMask){\r
// we only reset the track select ionfo, no deletion...\r
- tr->SetFilterMap(map&~fTPCOnlyFilterMask);\r
+ tr->SetFilterMap(map&~fTPCConstrainedFilterMask);\r
+ }\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
}\r
}\r
// Loop over the ESD trcks and pick out the tracks passing TPC only cuts\r
Double_t covTr[21]={0.};\r
Double_t pid[10]={0.}; \r
Double_t p[3] = { 0. };\r
+\r
+ Double_t pDCA[3] = { 0. }; // momentum at DCA\r
+ Double_t rDCA[3] = { 0. }; // position at DCA\r
+ Float_t dDCA[2] = {0.}; // DCA to the vertex d and z\r
+ Float_t cDCA[3] = {0.}; // covariance of impact parameters\r
+\r
+\r
AliAODTrack* aodTrack(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
UInt_t selectInfo = 0;\r
+ Bool_t isHybridITSTPC = false;\r
//\r
// Track selection\r
if (fTrackFilter) {\r
selectInfo = fTrackFilter->IsSelected(esdTrack);\r
}\r
- selectInfo &= fTPCOnlyFilterMask;\r
+\r
+ if(!(selectInfo&fHybridFilterMaskTPCCG)){\r
+ // not already selected tracks, use second part of hybrid tracks\r
+ isHybridITSTPC = true;\r
+ // too save space one could only store these...\r
+ }\r
+\r
+ selectInfo &= fTPCConstrainedFilterMask;\r
if (!selectInfo)continue;\r
- \r
+ if (fWriteHybridTPCCOnly&&!isHybridITSTPC)continue; // write only complementary tracks\r
// create a tpc only tracl\r
AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());\r
if(!track) continue;\r
AliExternalTrackParam exParam;\r
// take the B-field from the ESD, no 3D fieldMap available at this point\r
Bool_t relate = false;\r
- relate = track->RelateToVertex(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);\r
+ relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);\r
if(!relate){\r
delete track;\r
continue;\r
}\r
- Double_t fSigmaConstrainedMax = 5.;\r
- if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax) {\r
- delete track;\r
- continue;\r
+ // fetch the track parameters at the DCA (unconstraint)\r
+ if(track->GetTPCInnerParam()){\r
+ track->GetTPCInnerParam()->GetPxPyPz(pDCA);\r
+ track->GetTPCInnerParam()->GetXYZ(rDCA);\r
}\r
+ // get the DCA to the vertex:\r
+ track->GetImpactParametersTPC(dDCA,cDCA);\r
+ // set the constrained parameters to the track\r
track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());\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
+\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->SetTPCClusterMap(track->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\r
- aodTrack->SetChi2perNDF(Chi2perNDF(track));\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
+ // 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->SetDCA(dDCA[0],dDCA[1]);\r
+\r
aodTrack->SetFlags(track->GetStatus());\r
aodTrack->SetTPCPointsF(track->GetTPCNclsF());\r
\r
\r
}\r
\r
+\r
+void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)\r
+{\r
+\r
+ // Here we have the option to store the complement from global constraint information\r
+ // to tracks passing tight cuts (1) in order not to get fakes back in, one needs \r
+ // two sets of cuts one tight (1) (to throw out fakes) and one lose (2) (fakes/bad tracks would pass (2) but not (1))\r
+ // using cut number (3) selects the tracks that complement (1) e.g. tracks witout ITS refit or cluster requirement\r
+\r
+\r
+ AliCodeTimerAuto("",0);\r
+ \r
+ // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks\r
+ for(int it = 0;it < fNumberOfTracks;++it)\r
+ {\r
+ AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));\r
+ if(!tr)continue;\r
+ UInt_t map = tr->GetFilterMap();\r
+ if(map&fGlobalConstrainedFilterMask){\r
+ // we only reset the track select info, no deletion...\r
+ // mask reset mask in case track is already taken\r
+ tr->SetFilterMap(map&~fGlobalConstrainedFilterMask);\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
+ }\r
+ }\r
+ // Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts\r
+ \r
+\r
+ Double_t pos[3] = { 0. }; \r
+ Double_t covTr[21]={0.};\r
+ Double_t pid[10]={0.}; \r
+ Double_t p[3] = { 0. };\r
+\r
+ Double_t pDCA[3] = { 0. }; // momentum at DCA\r
+ Double_t rDCA[3] = { 0. }; // position at DCA\r
+ Float_t dDCA[2] = {0.}; // DCA to the vertex d and z\r
+ Float_t cDCA[3] = {0.}; // covariance of impact parameters\r
+\r
+\r
+ AliAODTrack* aodTrack(0x0);\r
+ const AliESDVertex *vtx = esd.GetPrimaryVertex();\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
+ if(!exParamGC)continue;\r
+\r
+ UInt_t selectInfo = 0;\r
+ Bool_t isHybridGC = false;\r
+\r
+ //\r
+ // Track selection\r
+ if (fTrackFilter) {\r
+ selectInfo = fTrackFilter->IsSelected(esdTrack);\r
+ }\r
+\r
+\r
+ if(!(selectInfo&fHybridFilterMaskGCG))isHybridGC = true;\r
+ if (fWriteHybridGCOnly&&!isHybridGC)continue; // write only complementary tracks\r
+\r
+ selectInfo &= fGlobalConstrainedFilterMask;\r
+ if (!selectInfo)continue;\r
+ // fetch the track parameters at the DCA (unconstrained)\r
+ esdTrack->GetPxPyPz(pDCA);\r
+ esdTrack->GetXYZ(rDCA);\r
+ // get the DCA to the vertex:\r
+ esdTrack->GetImpactParameters(dDCA,cDCA);\r
+\r
+ esdTrack->GetConstrainedPxPyPz(p);\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
+ if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
+ aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,\r
+ esdTrack->GetLabel(),\r
+ p,\r
+ kTRUE,\r
+ pos,\r
+ kFALSE,\r
+ covTr, \r
+ (Short_t)esdTrack->GetSign(),\r
+ esdTrack->GetITSClusterMap(), \r
+ pid,\r
+ fPrimaryVertex,\r
+ kTRUE, // check if this is right\r
+ vtx->UsesTrack(esdTrack->GetID()),\r
+ AliAODTrack::kPrimary, \r
+ selectInfo);\r
+ aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC); \r
+ aodTrack->SetIsGlobalConstrained(kTRUE); \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
+\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->SetDCA(dDCA[0],dDCA[1]);\r
+\r
+ aodTrack->SetFlags(esdTrack->GetStatus());\r
+ aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
+ } // end of loop on tracks\r
+ \r
+}\r
+\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)\r
{\r
*vzeroData = *(esd.GetVZEROData());\r
}\r
\r
+//______________________________________________________________________________\r
+void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)\r
+{\r
+ // Convert ZDC data\r
+ AliESDZDC* esdZDC = esd.GetZDCData();\r
+ \r
+ const Double_t zem1Energy = esdZDC->GetZEM1Energy();\r
+ const Double_t zem2Energy = esdZDC->GetZEM2Energy();\r
+ \r
+ const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();\r
+ const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();\r
+ const Double_t *towZNA = esdZDC->GetZNATowerEnergy();\r
+ const Double_t *towZPA = esdZDC->GetZPATowerEnergy();\r
+ const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();\r
+ const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();\r
+ \r
+ AliAODZDC* zdcAOD = AODEvent()->GetZDCData();\r
+\r
+ zdcAOD->SetZEM1Energy(zem1Energy);\r
+ zdcAOD->SetZEM2Energy(zem2Energy);\r
+ zdcAOD->SetZNCTowers(towZNC, towZNCLG);\r
+ zdcAOD->SetZNATowers(towZNA, towZNALG);\r
+ zdcAOD->SetZPCTowers(towZPC);\r
+ zdcAOD->SetZPATowers(towZPA);\r
+ \r
+ zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());\r
+ zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(), \r
+ esdZDC->GetImpactParamSideC());\r
+ zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0)); \r
+ zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0)); \r
+\r
+}\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertESDtoAOD() \r
{\r
header->SetRefMultiplicityPos(fNumberOfPositiveTracks);\r
header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);\r
\r
- if ( fTPCOnlyFilterMask ) ConvertTPCOnlyTracks(*esd);\r
- \r
+ if ( fTPCConstrainedFilterMask ) ConvertTPCOnlyTracks(*esd);\r
+ if( fGlobalConstrainedFilterMask) ConvertGlobalConstrainedTracks(*esd); \r
+\r
if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);\r
\r
if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);\r
\r
\r
aodpid->SetITSsignal(track->GetITSsignal());\r
+ Double_t itsdedx[4]; // dE/dx samples for individual ITS layers\r
+ track->GetITSdEdxSamples(itsdedx);\r
+ aodpid->SetITSdEdxSamples(itsdedx);\r
+\r
aodpid->SetTPCsignal(track->GetTPCsignal());\r
aodpid->SetTPCsignalN(track->GetTPCsignalN());\r
\r
aodpid->SetEMCALPosition(emcpos);\r
aodpid->SetEMCALMomentum(emcmom);\r
\r
+ Double_t hmpPid[5] = {0};\r
+ track->GetHMPIDpid(hmpPid);\r
+ aodpid->SetHMPIDprobs(hmpPid);\r
+\r
AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();\r
if(!outerparam) return;\r
\r