#include "TVector3.h"
#include "AliTPCdEdxInfo.h"
+#include "AliESDTrdTrack.h"
+#include "AliESDTrdTracklet.h"
+#include "AliAODTrdTrack.h"
+#include "AliAODTrdTracklet.h"
+
using std::cout;
using std::endl;
ClassImp(AliAnalysisTaskESDfilter)
fPtshape(0x0),
fEnableFillAOD(kTRUE),
fUsedTrack(0x0),
+ fUsedTrackCopy(0x0),
fUsedKink(0x0),
fUsedV0(0x0),
fAODTrackRefs(0x0),
fAreEMCALTriggerEnabled(kTRUE),
fArePHOSTriggerEnabled(kTRUE),
fAreTrackletsEnabled(kTRUE),
+ fIsTRDEnabled(kTRUE),
fESDpid(0x0),
fIsPidOwner(kFALSE),
fTPCaloneTrackCuts(0),
- fDoPropagateTrackToEMCal(kTRUE)
+ fDoPropagateTrackToEMCal(kTRUE),
+ fEMCalSurfaceDistance(440)
{
// Default constructor
fV0Cuts[0] = 33. ; // max allowed chi2
fPtshape(0x0),
fEnableFillAOD(kTRUE),
fUsedTrack(0x0),
+ fUsedTrackCopy(0x0),
fUsedKink(0x0),
fUsedV0(0x0),
fAODTrackRefs(0x0),
fAreEMCALTriggerEnabled(kTRUE),
fArePHOSTriggerEnabled(kTRUE),
fAreTrackletsEnabled(kTRUE),
+ fIsTRDEnabled(kTRUE),
fESDpid(0x0),
fIsPidOwner(kFALSE),
fTPCaloneTrackCuts(0),
- fDoPropagateTrackToEMCal(kTRUE)
+ fDoPropagateTrackToEMCal(kTRUE),
+ fEMCalSurfaceDistance(440)
{
// Constructor
header->SetRunNumber(esd.GetRunNumber());
header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
+ header->SetNumberOfESDTracks(esd.GetNumberOfTracks());
TTree* tree = fInputHandler->GetTree();
if (tree) {
header->SetZDCN2Energy(esd.GetZDCN2Energy());
header->SetZDCP2Energy(esd.GetZDCP2Energy());
header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));
+
+ header->SetIRInt2InteractionMap(esd.GetHeader()->GetIRInt2InteractionMap());
+ header->SetIRInt1InteractionMap(esd.GetHeader()->GetIRInt1InteractionMap());
// ITS Cluster Multiplicty
const AliMultiplicity *mult = esd.GetMultiplicity();
Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;
header->SetTPConlyRefMultiplicity(refMult);
//
- header->SetRefMultiplicityComb05(AliESDtrackCuts::GetReferenceMultiplicity(&esd,AliESDtrackCuts::kTrackletsITSTPC,0.5));
- header->SetRefMultiplicityComb08(AliESDtrackCuts::GetReferenceMultiplicity(&esd,AliESDtrackCuts::kTrackletsITSTPC,0.8));
+ AliESDtrackCuts::MultEstTrackType estType = esd.GetPrimaryVertexTracks()->GetStatus() ? AliESDtrackCuts::kTrackletsITSTPC : AliESDtrackCuts::kTracklets;
+ header->SetRefMultiplicityComb05(AliESDtrackCuts::GetReferenceMultiplicity(&esd,estType,0.5));
+ header->SetRefMultiplicityComb08(AliESDtrackCuts::GetReferenceMultiplicity(&esd,estType,0.8));
//
Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};
Float_t diamcov[3];
Double_t momNeg[3] = { 0. };
Double_t momPosAtV0vtx[3]={0.};
Double_t momNegAtV0vtx[3]={0.};
-
+ Int_t tofLabel[3] = {0};
TClonesArray& verticesArray = Vertices();
TClonesArray& tracksArray = Tracks();
TClonesArray& cascadesArray = Cascades();
esdCascadeBach->GetXYZ(pos);
esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);
esdCascadeBach->GetESDpid(pid);
-
+ esdCascadeBach->GetTOFLabel(tofLabel);
+
fUsedTrack[idxBachFromCascade] = kTRUE;
UInt_t selectInfo = 0;
if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));
aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeBach->GetTPCCrossedRows()));
+ aodTrack->SetIntegratedLength(esdCascadeBach->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);
if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;
aodTrack->ConvertAliPIDtoAODPID();
aodTrack->SetFlags(esdCascadeBach->GetStatus());
- SetAODPID(esdCascadeBach,aodTrack,detpid);
+ SetAODPID(esdCascadeBach,aodTrack,detpid);
}
else {
aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );
esdCascadePos->GetXYZ(pos);
esdCascadePos->GetCovarianceXYZPxPyPz(covTr);
esdCascadePos->GetESDpid(pid);
-
+ esdCascadePos->GetTOFLabel(tofLabel);
if (!fUsedTrack[idxPosFromV0Dghter]) {
fUsedTrack[idxPosFromV0Dghter] = kTRUE;
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));
aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadePos->GetTPCCrossedRows()));
+ aodTrack->SetIntegratedLength(esdCascadePos->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);
if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;
esdCascadeNeg->GetXYZ(pos);
esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);
esdCascadeNeg->GetESDpid(pid);
+ esdCascadeNeg->GetTOFLabel(tofLabel);
if (!fUsedTrack[idxNegFromV0Dghter]) {
aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));
aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeNeg->GetTPCCrossedRows()));
+ aodTrack->SetIntegratedLength(esdCascadeNeg->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);
if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;
Double_t momNeg[3]={0.};
Double_t momPosAtV0vtx[3]={0.};
Double_t momNegAtV0vtx[3]={0.};
-
+ Int_t tofLabel[3] = {0};
for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0)
{
if (fUsedV0[nV0]) continue; // skip if already added to the AOD
esdV0Pos->GetXYZ(pos);
esdV0Pos->GetCovarianceXYZPxPyPz(covTr);
esdV0Pos->GetESDpid(pid);
+ esdV0Pos->GetTOFLabel(tofLabel);
const AliESDVertex *vtx = esd.GetPrimaryVertex();
aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));
aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Pos->GetTPCCrossedRows()));
+ aodTrack->SetIntegratedLength(esdV0Pos->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(aodTrack,posFromV0);
// if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());
if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;
aodTrack->ConvertAliPIDtoAODPID();
aodTrack->SetFlags(esdV0Pos->GetStatus());
- SetAODPID(esdV0Pos,aodTrack,detpid);
+ SetAODPID(esdV0Pos,aodTrack,detpid);
}
else {
aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));
esdV0Neg->GetXYZ(pos);
esdV0Neg->GetCovarianceXYZPxPyPz(covTr);
esdV0Neg->GetESDpid(pid);
+ esdV0Neg->GetTOFLabel(tofLabel);
if (!fUsedTrack[negFromV0]) {
fUsedTrack[negFromV0] = kTRUE;
aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));
aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Neg->GetTPCCrossedRows()));
-
+ aodTrack->SetIntegratedLength(esdV0Neg->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(aodTrack,negFromV0);
// if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());
if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;
aodTrack->ConvertAliPIDtoAODPID();
aodTrack->SetFlags(esdV0Neg->GetStatus());
- SetAODPID(esdV0Neg,aodTrack,detpid);
+ SetAODPID(esdV0Neg,aodTrack,detpid);
}
else {
aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));
Double_t rDCA[3] = { 0. }; // position at DCA
Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
Float_t cDCA[3] = {0.}; // covariance of impact parameters
-
+ Int_t tofLabel[3] = {0};
AliAODTrack* aodTrack(0x0);
// AliAODPid* detpid(0x0);
track->GetXYZ(pos);
track->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);// original PID
-
+ esdTrack->GetTOFLabel(tofLabel);
if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
+ fUsedTrackCopy[nTrack] |= selectInfo;
aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,
track->GetLabel(),
p,
aodTrack->SetFlags(track->GetStatus());
aodTrack->SetTPCPointsF(track->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(track->GetTPCCrossedRows()));
-
+ aodTrack->SetIntegratedLength(track->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
//Perform progagation of tracks if needed
if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
- aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
+ aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
// do not duplicate PID information
// aodTrack->ConvertAliPIDtoAODPID();
Double_t rDCA[3] = { 0. }; // position at DCA
Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
Float_t cDCA[3] = {0.}; // covariance of impact parameters
+ Int_t tofLabel[3] = {0};
AliAODTrack* aodTrack(0x0);
esdTrack->GetConstrainedXYZ(pos);
exParamGC->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
+ esdTrack->GetTOFLabel(tofLabel);
if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
+ fUsedTrackCopy[nTrack] |= selectInfo;
aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,
esdTrack->GetLabel(),
p,
aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
-
+
// set the DCA values to the AOD track
aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
aodTrack->SetFlags(esdTrack->GetStatus());
aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
-
+ aodTrack->SetIntegratedLength(esdTrack->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
if(isHybridGC){
// only copy AOD information for hybrid, no duplicate information
aodTrack->ConvertAliPIDtoAODPID();
//Perform progagation of tracks if needed
if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
- aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
+ aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
} // end of loop on tracks
}
Double_t pos[3] = { 0. };
Double_t covTr[21] = { 0. };
Double_t pid[10] = { 0. };
+ Int_t tofLabel[3] = {0};
AliAODTrack* aodTrack(0x0);
AliAODPid* detpid(0x0);
esdTrack->GetXYZ(pos);
esdTrack->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
+ esdTrack->GetTOFLabel(tofLabel);
if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
+ fUsedTrack[nTrack] = kTRUE;
fPrimaryVertex->AddDaughter(aodTrack =
new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),
esdTrack->GetLabel(),
aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
+ aodTrack->SetIntegratedLength(esdTrack->GetIntegratedLength());
+ aodTrack->SetTOFLabel(tofLabel);
if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());
if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());
//Perform progagation of tracks if needed
if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
- aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
+ aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
fAODTrackRefs->AddAt(aodTrack, nTrack);
void AliAnalysisTaskESDfilter::PropagateTrackToEMCal(AliESDtrack *esdTrack)
{
Double_t trkPos[3] = {0.,0.,0.};
- Double_t EMCalEta=-999, EMCalPhi=-999;
+ Double_t EMCalEta=-999, EMCalPhi=-999, EMCalPt=-999;
Double_t trkphi = esdTrack->Phi()*TMath::RadToDeg();
if(TMath::Abs(esdTrack->Eta())<0.9 && trkphi > 10 && trkphi < 250 )
{
if(trkParam)
{
AliExternalTrackParam trkParamTmp(*trkParam);
- if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, 430, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))
+ if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, fEMCalSurfaceDistance, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))
{
trkParamTmp.GetXYZ(trkPos);
TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
EMCalEta = trkPosVec.Eta();
EMCalPhi = trkPosVec.Phi();
+ EMCalPt = trkParamTmp.Pt();
if(EMCalPhi<0) EMCalPhi += 2*TMath::Pi();
- esdTrack->SetTrackPhiEtaOnEMCal(EMCalPhi,EMCalEta);
+ esdTrack->SetTrackPhiEtaPtOnEMCal(EMCalPhi,EMCalEta,EMCalPt);
}
}
}
Double_t covTr[21]={0.};
Double_t pid[10]={0.};
AliAODPid* detpid(0x0);
+ Int_t tofLabel[3] = {0};
fNumberOfKinks = esd.GetNumberOfKinks();
esdTrackM->GetXYZ(pos);
esdTrackM->GetCovarianceXYZPxPyPz(covTr);
esdTrackM->GetESDpid(pid);
+ esdTrackM->GetTOFLabel(tofLabel);
if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());
mother =
new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),
mother->SetChi2perNDF(Chi2perNDF(esdTrackM));
mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());
mother->SetTPCNCrossedRows(UShort_t(esdTrackM->GetTPCCrossedRows()));
-
+ mother->SetIntegratedLength(esdTrackM->GetIntegratedLength());
+ mother->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(mother, imother);
if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;
esdTrackD->GetXYZ(pos);
esdTrackD->GetCovarianceXYZPxPyPz(covTr);
esdTrackD->GetESDpid(pid);
+ esdTrackD->GetTOFLabel(tofLabel);
selectInfo = 0;
if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);
if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());
daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());
daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());
daughter->SetTPCNCrossedRows(UShort_t(esdTrackD->GetTPCCrossedRows()));
+ daughter->SetIntegratedLength(esdTrackD->GetIntegratedLength());
+ daughter->SetTOFLabel(tofLabel);
fAODTrackRefs->AddAt(daughter, idaughter);
if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;
pVTRK->SetNContributors(vtxP->GetNContributors());
pVTRK->SetBC(vtxP->GetBC());
}
+
+ // Add TPC "main" vertex
+ const AliESDVertex *vtxT = esd.GetPrimaryVertexTPC();
+ vtxT->GetXYZ(pos); // position
+ vtxT->GetCovMatrix(covVtx); //covariance matrix
+ AliAODVertex * mVTPC = new(Vertices()[fNumberOfVertices++])
+ AliAODVertex(pos, covVtx, vtxT->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainTPC);
+ mVTPC->SetName(vtxT->GetName());
+ mVTPC->SetTitle(vtxT->GetTitle());
+ mVTPC->SetNContributors(vtxT->GetNContributors());
+
+
}
//______________________________________________________________________________
}
aodTzero->SetT0zVertex(esdTzero->GetT0zVertex());
+ //amplitude
+
+ const Double32_t *amp=esdTzero->GetT0amplitude();
+ for(int ipmt=0; ipmt<24; ipmt++)
+ aodTzero->SetAmp(ipmt, amp[ipmt]);
+ aodTzero->SetAmp(24,esdTzero->GetMultC() );
+ aodTzero->SetAmp(25,esdTzero->GetMultA() );
+
}
return cntHmpidGoodTracks;
}
+void AliAnalysisTaskESDfilter::ConvertTRD(const AliESDEvent& esd)
+{
+ // fill TRD on-line tracks with assiocated tracklets
+ // as used for the TRD level-1 triggers
+
+ const Int_t nTrdTracks = esd.GetNumberOfTrdTracks();
+ const Int_t nLayers = 6;
+
+ for (Int_t iTrdTrack = 0; iTrdTrack < nTrdTracks; ++iTrdTrack) {
+ // copy information from ESD track to AOD track
+ const AliESDTrdTrack *esdTrdTrk = esd.GetTrdTrack(iTrdTrack);
+ AliAODTrdTrack &aodTrdTrk = AODEvent()->AddTrdTrack(esdTrdTrk);
+
+ // copy the contributing tracklets
+ for (Int_t iTracklet = 0; iTracklet < nLayers; ++iTracklet) {
+ if (const AliESDTrdTracklet *esdTrdTrkl = esdTrdTrk->GetTracklet(iTracklet))
+ aodTrdTrk.AddTracklet(*esdTrdTrkl, iTracklet);
+ }
+
+ // add the reference to the matched global track
+ AliAODTrack *aodTrkMatch = 0x0;
+ AliESDtrack *esdTrkMatch = (AliESDtrack*) esdTrdTrk->GetTrackMatch();
+ if (esdTrkMatch) {
+ Int_t idx = esdTrkMatch->GetID();
+
+ if (idx < 0)
+ AliError("track has a matched track that was not found");
+ else if (esdTrkMatch != esd.GetTrack(idx))
+ AliError("wrong track found for ESD track index");
+ else {
+ UInt_t selectInfo = fTrackFilter ? fTrackFilter->IsSelected(esdTrkMatch) : 0;
+
+ if (fUsedTrack[idx]) {
+ aodTrkMatch = (AliAODTrack*) (*fAODTrackRefs)[idx];
+ AliDebug(2, Form("event %lld: existing track (idx %i, pt = %f) matched to TRD track (idx %i, pt = %f), cut flags: 0x%08x",
+ Entry(), idx, esdTrkMatch->Pt(), iTrdTrack, esdTrdTrk->Pt(),
+ selectInfo));
+ }
+ else {
+ if (selectInfo & fUsedTrackCopy[idx]) {
+ // mask filter bits already used in track copies
+ selectInfo &= ~fUsedTrackCopy[idx];
+ AliWarning(Form("event %lld: copied track (idx %i, pt = %f) matched to TRD track (idx %i, pt = %f), cut flags: 0x%08x -> 0x%08x",
+ Entry(), idx, esdTrkMatch->Pt(), iTrdTrack, esdTrdTrk->Pt(),
+ fTrackFilter->IsSelected(esdTrkMatch), selectInfo));
+ }
+ AliDebug(2, Form("event %lld: unused track (idx %i, pt = %f) matched to TRD track (idx %i, pt = %f), cut flags: 0x%08x -> 0x%08x",
+ Entry(), idx, esdTrkMatch->Pt(), iTrdTrack, esdTrdTrk->Pt(),
+ fTrackFilter->IsSelected(esdTrkMatch), selectInfo));
+
+ Double_t mom[3]={0.};
+ Double_t pos[3]={0.};
+ Double_t covTr[21]={0.};
+ Double_t pid[10]={0.};
+
+ esdTrkMatch->GetPxPyPz(mom);
+ esdTrkMatch->GetXYZ(pos);
+ esdTrkMatch->GetCovarianceXYZPxPyPz(covTr);
+ esdTrkMatch->GetESDpid(pid);
+ const AliESDVertex* vtx = esd.GetPrimaryVertex();
+
+ fUsedTrack[idx] = kTRUE;
+ if(fMChandler) fMChandler->SelectParticle(esdTrkMatch->GetLabel());
+
+ aodTrkMatch = new(Tracks()[fNumberOfTracks++])
+ AliAODTrack(esdTrkMatch->GetID(),
+ esdTrkMatch->GetLabel(),
+ mom,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrkMatch->GetSign(),
+ esdTrkMatch->GetITSClusterMap(),
+ pid,
+ fPrimaryVertex,
+ kTRUE,
+ vtx->UsesTrack(esdTrkMatch->GetID()),
+ AliAODTrack::kUndef,
+ selectInfo);
+
+ aodTrkMatch->SetTPCFitMap(esdTrkMatch->GetTPCFitMap());
+ aodTrkMatch->SetTPCClusterMap(esdTrkMatch->GetTPCClusterMap());
+ aodTrkMatch->SetTPCSharedMap (esdTrkMatch->GetTPCSharedMap());
+ aodTrkMatch->SetChi2perNDF(Chi2perNDF(esdTrkMatch));
+ aodTrkMatch->SetTPCPointsF(esdTrkMatch->GetTPCNclsF());
+ aodTrkMatch->SetTPCNCrossedRows(UShort_t(esdTrkMatch->GetTPCCrossedRows()));
+ aodTrkMatch->SetIntegratedLength(esdTrkMatch->GetIntegratedLength());
+ fAODTrackRefs->AddAt(aodTrkMatch,idx);
+ if (esdTrkMatch->GetSign() > 0) ++fNumberOfPositiveTracks;
+ aodTrkMatch->ConvertAliPIDtoAODPID();
+ aodTrkMatch->SetFlags(esdTrkMatch->GetStatus());
+ }
+ }
+ }
+ aodTrdTrk.SetTrackMatchReference(aodTrkMatch);
+ }
+}
+
//______________________________________________________________________________
void AliAnalysisTaskESDfilter::ConvertESDtoAOD()
{
// Array to take into account the tracks already added to the AOD
fUsedTrack = new Bool_t[nTracks];
- for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;
+ fUsedTrackCopy = new UInt_t[nTracks];
+ for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
+ fUsedTrack[iTrack]=kFALSE;
+ fUsedTrackCopy[iTrack] = 0;
+ }
}
// Array to take into account the kinks already added to the AOD
if(fIsHMPIDEnabled) nHmpidRings = ConvertHMPID(*esd);
+ if (fIsTRDEnabled) ConvertTRD(*esd);
+
delete fAODTrackRefs; fAODTrackRefs=0x0;
delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;
delete fAODV0Refs; fAODV0Refs=0x0;
delete[] fUsedTrack; fUsedTrack=0x0;
+ delete[] fUsedTrackCopy; fUsedTrackCopy=0x0;
delete[] fUsedV0; fUsedV0=0x0;
delete[] fUsedKink; fUsedKink=0x0;
return;
}
// TPC momentum
- const AliExternalTrackParam *in=track->GetInnerParam();
- if (in) {
- aodpid->SetTPCmomentum(in->GetP());
- }else{
- aodpid->SetTPCmomentum(-1.);
- }
+ aodpid->SetTPCmomentum(track->GetTPCmomentum());
+ aodpid->SetTPCTgl(track->GetTPCTgl());
+// const AliExternalTrackParam *in=track->GetInnerParam();
+// if (in) {
+// aodpid->SetTPCmomentum(in->GetP());
+// }else{
+// aodpid->SetTPCmomentum(-1.);
+// }
aodpid->SetITSsignal(track->GetITSsignal());
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff