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
+ 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
-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
+ 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
// 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
\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
vtx->UsesTrack(track->GetID()),\r
AliAODTrack::kPrimary, \r
selectInfo);\r
- aodTrack->SetIsHybridITSTPC(isHybridITSTPC); \r
- aodTrack->SetIsHybridTPC(isHybridTPC);\r
+ // aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC); \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
}\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
+ 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
+ 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
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff