#include "AliCodeTimer.h"
#include "AliESDtrackCuts.h"
#include "AliESDpid.h"
+#include "AliAODHMPIDrings.h"
#include "AliV0vertexer.h"
#include "AliCascadeVertexer.h"
#include "Riostream.h"
#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),
fIsVZEROEnabled(kTRUE),
fIsTZEROEnabled(kTRUE),
fIsZDCEnabled(kTRUE),
+ fIsHMPIDEnabled(kTRUE),
fIsV0CascadeRecoEnabled(kFALSE),
fAreCascadesEnabled(kTRUE),
fAreV0sEnabled(kTRUE),
fAreEMCALTriggerEnabled(kTRUE),
fArePHOSTriggerEnabled(kTRUE),
fAreTrackletsEnabled(kTRUE),
+ fIsTRDEnabled(kTRUE),
fESDpid(0x0),
fIsPidOwner(kFALSE),
- fTimeZeroType(AliESDpid::kTOF_T0),
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),
fIsVZEROEnabled(kTRUE),
fIsTZEROEnabled(kTRUE),
fIsZDCEnabled(kTRUE),
+ fIsHMPIDEnabled(kTRUE),
fIsV0CascadeRecoEnabled(kFALSE),
fAreCascadesEnabled(kTRUE),
fAreV0sEnabled(kTRUE),
fAreEMCALTriggerEnabled(kTRUE),
fArePHOSTriggerEnabled(kTRUE),
fAreTrackletsEnabled(kTRUE),
+ fIsTRDEnabled(kTRUE),
fESDpid(0x0),
fIsPidOwner(kFALSE),
- fTimeZeroType(AliESDpid::kTOF_T0),
fTPCaloneTrackCuts(0),
- fDoPropagateTrackToEMCal(kTRUE)
+ fDoPropagateTrackToEMCal(kTRUE),
+ fEMCalSurfaceDistance(440)
{
// Constructor
// Call configuration file
}
+//______________________________________________________________________________
+Bool_t AliAnalysisTaskESDfilter::Notify()
+{
+// Notify method.
+ AddMetadataToUserInfo();
+ return kTRUE;
+}
+
+//______________________________________________________________________________
+Bool_t AliAnalysisTaskESDfilter::AddMetadataToUserInfo()
+{
+// Copy metadata to AOD user info.
+ static Bool_t copyFirst = kFALSE;
+ if (!copyFirst) {
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ AliError("AliAnalysisTaskESDfilter::AddMetadataToUserInfo() : No analysis manager !");
+ return kFALSE;
+ }
+ TTree *esdTree = mgr->GetTree()->GetTree();
+ if (!esdTree) return kFALSE;
+ TNamed *alirootVersion = (TNamed*)esdTree->GetUserInfo()->FindObject("alirootVersion");
+ if (!alirootVersion) return kFALSE;
+ AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler());
+ if (!aodHandler) return kFALSE;
+ TTree *aodTree = aodHandler->GetTree();
+ if (!aodTree) return kFALSE;
+ aodTree->GetUserInfo()->Add(new TNamed(*alirootVersion));
+ copyFirst = kTRUE;
+ }
+ return kTRUE;
+}
+
//______________________________________________________________________________
void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const
{
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();
// TPC only Reference Multiplicty
Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;
header->SetTPConlyRefMultiplicity(refMult);
-
+ //
+ 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];
// VZERO channel equalization factors for event-plane reconstruction
header->SetVZEROEqFactors(esd.GetVZEROEqFactors());
+ // T0 Resolution information
+ const AliESDRun* esdRun = esd.GetESDRun();
+ for (Int_t i=0;i<AliESDRun::kT0spreadSize;i++) header->SetT0spread(i,esdRun->GetT0spread(i));
+
return header;
}
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->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());
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->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());
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->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());
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->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());
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->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());
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->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
// do not duplicate PID information
// aodTrack->ConvertAliPIDtoAODPID();
}
-
+//______________________________________________________________________________
void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)
{
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();
SetAODPID(esdTrack,aodTrack,detpid);
}
+
+ //Perform progagation of tracks if needed
+ if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
+ aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
} // end of loop on tracks
}
const AliESDVertex *vtx = esd.GetPrimaryVertex();
Double_t p[3] = { 0. };
Double_t pos[3] = { 0. };
- Double_t trkPos[3] = {0.,0.,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->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
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)
- {
- Double_t EMCalEta, EMCalPhi;
- Double_t trkphi = esdTrack->Phi()*TMath::RadToDeg();
- if(TMath::Abs(esdTrack->Eta())<0.9 && trkphi > 10 && trkphi < 250 )
- {
- AliExternalTrackParam *trkParam = const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());
- if(trkParam)
- {
- AliExternalTrackParam trkParamTmp(*trkParam);
- if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, 430, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))
- {
- trkParamTmp.GetXYZ(trkPos);
- TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
- EMCalEta = trkPosVec.Eta();
- EMCalPhi = trkPosVec.Phi();
- if(EMCalPhi<0) EMCalPhi += 2*TMath::Pi();
- esdTrack->SetTrackPhiEtaOnEMCal(EMCalPhi,EMCalEta);
- }
- }
- }
- }
- aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
+ if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
+ aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
fAODTrackRefs->AddAt(aodTrack, nTrack);
} // end of loop on tracks
}
+//______________________________________________________________________________
+void AliAnalysisTaskESDfilter::PropagateTrackToEMCal(AliESDtrack *esdTrack)
+{
+ Double_t trkPos[3] = {0.,0.,0.};
+ 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 )
+ {
+ AliExternalTrackParam *trkParam = const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());
+ if(trkParam)
+ {
+ AliExternalTrackParam trkParamTmp(*trkParam);
+ 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->SetTrackPhiEtaPtOnEMCal(EMCalPhi,EMCalEta,EMCalPt);
+ }
+ }
+ }
+}
+
//______________________________________________________________________________
void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)
{
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->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());
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->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());
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;
AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
fPrimaryVertex->SetName(vtx->GetName());
fPrimaryVertex->SetTitle(vtx->GetTitle());
+ fPrimaryVertex->SetBC(vtx->GetBC());
TString vtitle = vtx->GetTitle();
if (!vtitle.Contains("VertexerTracks"))
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->SetT0VertexRaw(99999);
}
+ 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() );
+
}
esdZDC->GetImpactParamSideC());
zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0));
zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0));
+ if(esdZDC->IsZNChit()) zdcAOD->SetZNCTDC(esdZDC->GetZDCTDCCorrected(10,0));
+ if(esdZDC->IsZNAhit()) zdcAOD->SetZNATDC(esdZDC->GetZDCTDCCorrected(12,0));
+}
+
+//_______________________________________________________________________________________________________________________________________
+Int_t AliAnalysisTaskESDfilter::ConvertHMPID(const AliESDEvent& esd) // clm
+{
+ //
+ // Convtert ESD HMPID info to AOD and return the number of good tracks with HMPID signal.
+ // We need to return an int since there is no signal counter in the ESD.
+ //
+
+ AliCodeTimerAuto("",0);
+
+ Int_t cntHmpidGoodTracks = 0;
+
+ Float_t xMip = 0;
+ Float_t yMip = 0;
+ Int_t qMip = 0;
+ Int_t nphMip = 0;
+
+ Float_t xTrk = 0;
+ Float_t yTrk = 0;
+ Float_t thetaTrk = 0;
+ Float_t phiTrk = 0;
+
+ Double_t hmpPid[5]={0};
+ Double_t hmpMom[3]={0};
+
+ TClonesArray &hmpidRings = *(AODEvent()->GetHMPIDrings());
+
+ for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
+ {
+ if(! esd.GetTrack(iTrack) ) continue;
+
+ if(esd.GetTrack(iTrack)->GetHMPIDsignal() > -20 ) { //
+
+ (esd.GetTrack(iTrack))->GetHMPIDmip(xMip, yMip, qMip, nphMip); // Get MIP properties
+ (esd.GetTrack(iTrack))->GetHMPIDtrk(xTrk,yTrk,thetaTrk,phiTrk);
+ (esd.GetTrack(iTrack))->GetHMPIDpid(hmpPid);
+ if((esd.GetTrack(iTrack))->GetOuterHmpParam()) (esd.GetTrack(iTrack))->GetOuterHmpPxPyPz(hmpMom);
+
+ if(esd.GetTrack(iTrack)->GetHMPIDsignal() == 0 && thetaTrk == 0 && qMip == 0 && nphMip ==0 ) continue; //
+
+ new(hmpidRings[cntHmpidGoodTracks++]) AliAODHMPIDrings(
+ (esd.GetTrack(iTrack))->GetID(), // Unique track id to attach the ring to
+ 1000000*nphMip+qMip, // MIP charge and number of photons
+ (esd.GetTrack(iTrack))->GetHMPIDcluIdx(), // 1000000*chamber id + cluster idx of the assigned MIP cluster
+ thetaTrk, // track inclination angle theta
+ phiTrk, // track inclination angle phi
+ (esd.GetTrack(iTrack))->GetHMPIDsignal(), // Cherenkov angle
+ (esd.GetTrack(iTrack))->GetHMPIDoccupancy(), // Occupancy claculated for the given chamber
+ (esd.GetTrack(iTrack))->GetHMPIDchi2(), // Ring resolution squared
+ xTrk, // Track x coordinate (LORS)
+ yTrk, // Track y coordinate (LORS)
+ xMip, // MIP x coordinate (LORS)
+ yMip, // MIP y coordinate (LORS)
+ hmpPid, // PID probablities from ESD, remove later once it is in CombinedPid
+ hmpMom // Track momentum in HMPID at ring reconstruction
+ );
+
+ // Printf(Form("+++++++++ yes/no: %d %lf %lf %lf %lf %lf %lf ",(esd.GetTrack(iTrack))->IsHMPID(),thetaTrk, (esd.GetTrack(iTrack))->GetHMPIDchi2(),xTrk, yTrk , xMip, yMip));
+
+
+ }// HMPID signal > -20
+ }//___esd track loop
+
+ 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);
+ }
}
//______________________________________________________________________________
Int_t nCaloClus = esd->GetNumberOfCaloClusters();
Int_t nFmdClus = 0;
Int_t nPmdClus = esd->GetNumberOfPmdTracks();
+ Int_t nHmpidRings = 0;
AliDebug(1,Form(" NV0=%d NCASCADES=%d NKINKS=%d", nV0s, nCascades, nKinks));
- AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
+ AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus,nHmpidRings);
if (nV0s > 0)
{
// 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 ( fAreTrackletsEnabled ) ConvertTracklets(*esd);
if ( fIsZDCEnabled ) ConvertZDC(*esd);
+ 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());
aodpid->SetTRDmomentum(iPl,trdmom);
}
- aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices.GetArray());
+ aodpid->SetTRDslices(track->GetNumberOfTRDslices()*6,trdslices.GetArray());
+ aodpid->SetTRDsignal(track->GetTRDsignal());
//TRD clusters and tracklets
aodpid->SetTRDncls(track->GetTRDncls());
aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());
+ aodpid->SetTRDChi2(track->GetTRDchi2());
+
//TOF PID
- Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);
+ Double_t times[AliPID::kSPECIES]; track->GetIntegratedTimes(times);
aodpid->SetIntegratedTimes(times);
// Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());
}
aodpid->SetTOFpidResolution(tofRes);
-// aodpid->SetHMPIDsignal(track->GetHMPIDsignal());
+// aodpid->SetHMPIDsignal(0); // set to zero for compression but it will be removed later
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff