#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 "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
#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
-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
+ 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
-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
+ 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
AliError("No OutputTree() for adding the track filter");\r
}\r
+ fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();\r
}\r
\r
//______________________________________________________________________________\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->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
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
// 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 starting form LHC10e without Tender. \r
\r
\r
// 3 - Add the bachelor track from the cascade\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
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
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
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 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
+ 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
+ // 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
//\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
- /*\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
- */\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
+ 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->SetTPCFitMap(track->GetTPCFitMap());\r
aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());\r
aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\r
- aodTrack->SetChi2perNDF(Chi2perNDF(track));\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->SetDCA(dDCA[0],dDCA[1]);\r
+\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 < 15; 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
+ for (int i = 0; i < 4; i++) aodTrigger.SetL1Threshold(i, esdTrigger.GetL1Threshold(i));\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
for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps\r
fESDpid->GetTOFResponse().SetT0resolution(t0spread);\r
fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);\r
- \r
fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); \r
+ AliTOFHeader tmpTOFHeader(0,t0spread[0],0,NULL,NULL,NULL,intrinsicTOFres,t0spread[0]); \r
+ AODEvent()->SetTOFHeader(&tmpTOFHeader); // write dummy TOF header in AOD\r
+ } else {\r
+ AODEvent()->SetTOFHeader(esd->GetTOFHeader()); // write TOF header in AOD\r
}\r
\r
if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \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
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
}\r
Printf("########################");\r
}\r
+\r
+//______________________________________________________\r
+\r
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff