#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
-fTPCOnlyFilterMask(0),\r
-fHybridFilterMaskITSTPC(0),\r
-fHybridFilterMaskTPC0(0),\r
-fHybridFilterMaskTPC1(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
-fTPCaloneTrackCuts(0)\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
+ 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
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
-fHybridFilterMaskITSTPC(0),\r
-fHybridFilterMaskTPC0(0),\r
-fHybridFilterMaskTPC1(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
-fTPCaloneTrackCuts(0)\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
+ 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
// 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
+ if(fIsPidOwner) delete fESDpid;\r
}\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::UserCreateOutputObjects()\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
// 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 the TPC only tracks are \r
- // flagged as HybridITSTPConly. Note, in order not to get fakes back in the TPC cuts, one needs \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
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&fHybridFilterMaskITSTPC){\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->SetIsHybridITSTPC(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
UInt_t selectInfo = 0;\r
Bool_t isHybridITSTPC = false;\r
- Bool_t isHybridTPC = false;\r
//\r
// Track selection\r
if (fTrackFilter) {\r
selectInfo = fTrackFilter->IsSelected(esdTrack);\r
}\r
\r
- if(!(selectInfo&fHybridFilterMaskITSTPC)){\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
- if(selectInfo&fHybridFilterMaskTPC0){\r
- isHybridTPC = true;\r
- }\r
- else if (!(selectInfo&fHybridFilterMaskTPC1)){\r
- // select all that have not been chosen by the loose \r
- // cuts\r
- isHybridTPC = true;\r
- }\r
-\r
-\r
- selectInfo &= fTPCOnlyFilterMask;\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
}\r
// get the DCA to the vertex:\r
track->GetImpactParametersTPC(dDCA,cDCA);\r
- // set the constraint parameters to the track\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
+ 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->SetIsHybridITSTPC(isHybridITSTPC); \r
- aodTrack->SetIsHybridTPC(isHybridTPC);\r
+ aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC); \r
+ aodTrack->SetTPCFitMap(track->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\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
}\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
+ AliAODPid* detpid(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
+ 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
+ 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->SetTPCFitMap(esdTrack->GetTPCFitMap());\r
+ aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
+ aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\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
+ 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
+\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
+\r
+\r
//______________________________________________________________________________\r
void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)\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
+ // 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
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
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
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
\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
+ 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
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff