X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliESD.cxx;h=5b82cb2c8263cc6d9f334cd2a740ae78e24d1e72;hb=0bce2dda3a2f29a961190ab1bb7fffd03e473298;hp=7cc56d79fcc5cb93d7fea973d4a9d3598d7924dd;hpb=2c48fa124432185c46eb9f6f53ff2df052dbb9f1;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliESD.cxx b/STEER/AliESD.cxx index 7cc56d79fcc..5b82cb2c826 100644 --- a/STEER/AliESD.cxx +++ b/STEER/AliESD.cxx @@ -22,252 +22,515 @@ // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //----------------------------------------------------------------- -#include "TList.h" -#include - #include "AliESD.h" #include "AliESDfriend.h" -#include "AliESDVZERO.h" -#include "AliESDHLTtrack.h" -#include "AliESDFMD.h" - ClassImp(AliESD) //______________________________________________________________________________ AliESD::AliESD(): - fESDObjects(new TList()), - fESDRun(0), - fHeader(0), - fESDZDC(0), - fESDFMD(0), - fESDVZERO(0), - fESDTZERO(0), - fSPDVertex(0), - fPrimaryVertex(0), - fSPDMult(0), - fPHOSTrigger(0), - fEMCALTrigger(0), - fTracks(0), - fMuonTracks(0), - fPmdTracks(0), - fTrdTracks(0), - fV0s(0), - fCascades(0), - fKinks(0), - fCaloClusters(0), - fErrorLogs(0), + fEventNumberInFile(0), + fBunchCrossNumber(0), + fOrbitNumber(0), + fPeriodNumber(0), + fRunNumber(0), + fTimeStamp(0), + fEventType(0), + fTriggerMask(0), + fTriggerCluster(0), + fRecoVersion(0), + fMagneticField(0), + fZDCN1Energy(0), + fZDCP1Energy(0), + fZDCN2Energy(0), + fZDCP2Energy(0), + fZDCEMEnergy(0), + fZDCParticipants(0), + fT0zVertex(0), + fSPDVertex(), + fPrimaryVertex(), + fSPDMult(), + fT0timeStart(0), + fT0clock(0), + fTracks("AliESDtrack",15000), + fHLTConfMapTracks("AliESDHLTtrack",25000), + fHLTHoughTracks("AliESDHLTtrack",15000), + fMuonTracks("AliESDMuonTrack",30), + fPmdTracks("AliESDPmdTrack",3000), + fTrdTracks("AliESDTrdTrack",300), + fV0s("AliESDv0",200), + fCascades("AliESDcascade",20), + fKinks("AliESDkink",4000), + fCaloClusters("AliESDCaloCluster",10000), fEMCALClusters(0), fFirstEMCALCluster(-1), + fEMCALTriggerPosition(0x0), + fEMCALTriggerAmplitudes(0x0), fPHOSClusters(0), - fFirstPHOSCluster(-1) + fFirstPHOSCluster(-1), + fPHOSTriggerPosition(0x0), + fPHOSTriggerAmplitudes(0x0), + fESDFMD(0x0), + fESDVZERO(0x0), + fESDACORDE(0x0), + fErrorLogs("AliRawDataErrorLog",5) { + // + // Standar constructor + // + + for (Int_t i=0; i<24; i++) { + fT0time[i] = 0; + fT0amplitude[i] = 0; + } + for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.; + for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.; } + //______________________________________________________________________________ AliESD::AliESD(const AliESD& esd): TObject(esd), - fESDObjects(new TList()), - fESDRun(new AliESDRun(*esd.fESDRun)), - fHeader(new AliESDHeader(*esd.fHeader)), - fESDZDC(new AliESDZDC(*esd.fESDZDC)), - fESDFMD(new AliESDFMD(*esd.fESDFMD)), - fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)), - fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)), - fSPDVertex(new AliESDVertex(*esd.fSPDVertex)), - fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)), - fSPDMult(new AliMultiplicity(*esd.fSPDMult)), - fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)), - fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)), - fTracks(new TClonesArray(*esd.fTracks)), - fMuonTracks(new TClonesArray(*esd.fMuonTracks)), - fPmdTracks(new TClonesArray(*esd.fPmdTracks)), - fTrdTracks(new TClonesArray(*esd.fTrdTracks)), - fV0s(new TClonesArray(*esd.fV0s)), - fCascades(new TClonesArray(*esd.fCascades)), - fKinks(new TClonesArray(*esd.fKinks)), - fCaloClusters(new TClonesArray(*esd.fCaloClusters)), - fErrorLogs(new TClonesArray(*esd.fErrorLogs)), + fEventNumberInFile(esd.fEventNumberInFile), + fBunchCrossNumber(esd.fBunchCrossNumber), + fOrbitNumber(esd.fOrbitNumber), + fPeriodNumber(esd.fPeriodNumber), + fRunNumber(esd.fRunNumber), + fTimeStamp(esd.fTimeStamp), + fEventType(esd.fEventType), + fTriggerMask(esd.fTriggerMask), + fTriggerCluster(esd.fTriggerCluster), + fRecoVersion(esd.fRecoVersion), + fMagneticField(esd.fMagneticField), + fZDCN1Energy(esd.fZDCN1Energy), + fZDCP1Energy(esd.fZDCP1Energy), + fZDCN2Energy(esd.fZDCN2Energy), + fZDCP2Energy(esd.fZDCP2Energy), + fZDCEMEnergy(esd.fZDCEMEnergy), + fZDCParticipants(esd.fZDCParticipants), + fT0zVertex(esd.fT0zVertex), + fSPDVertex(esd.fSPDVertex), + fPrimaryVertex(esd.fPrimaryVertex), + fSPDMult(esd.fSPDMult), + fT0timeStart(esd.fT0timeStart), + fT0clock(esd.fT0clock), + fTracks(*((TClonesArray*)esd.fTracks.Clone())), + fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())), + fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())), + fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())), + fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())), + fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())), + fV0s(*((TClonesArray*)esd.fV0s.Clone())), + fCascades(*((TClonesArray*)esd.fCascades.Clone())), + fKinks(*((TClonesArray*)esd.fKinks.Clone())), + fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())), fEMCALClusters(esd.fEMCALClusters), fFirstEMCALCluster(esd.fFirstEMCALCluster), + fEMCALTriggerPosition(esd. fEMCALTriggerPosition), + fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes), fPHOSClusters(esd.fPHOSClusters), - fFirstPHOSCluster(esd.fFirstPHOSCluster) - + fFirstPHOSCluster(esd.fFirstPHOSCluster), + fPHOSTriggerPosition(esd.fPHOSTriggerPosition), + fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes), + fESDFMD(esd.fESDFMD), + fESDVZERO(esd.fESDVZERO), + fESDACORDE(esd.fESDACORDE), + fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone())) { - // CKB init in the constructor list and only add here ... - AddObject(fESDRun); - AddObject(fHeader); - AddObject(fESDZDC); - AddObject(fESDFMD); - AddObject(fESDVZERO); - AddObject(fESDTZERO); - AddObject(fSPDVertex); - AddObject(fPrimaryVertex); - AddObject(fSPDMult); - AddObject(fPHOSTrigger); - AddObject(fEMCALTrigger); - AddObject(fTracks); - AddObject(fMuonTracks); - AddObject(fPmdTracks); - AddObject(fTrdTracks); - AddObject(fV0s); - AddObject(fCascades); - AddObject(fKinks); - AddObject(fCaloClusters); - AddObject(fErrorLogs); - - GetStdContent(); - -} - -//______________________________________________________________________________ -AliESD & AliESD::operator=(const AliESD& source) { - - // Assignment operator - - if(&source == this) return *this; - TObject::operator=(source); - - fESDRun = new AliESDRun(*source.fESDRun); - fHeader = new AliESDHeader(*source.fHeader); - fESDZDC = new AliESDZDC(*source.fESDZDC); - fESDFMD = new AliESDFMD(*source.fESDFMD); - fESDVZERO = new AliESDVZERO(*source.fESDVZERO); - fESDTZERO = new AliESDTZERO(*source.fESDTZERO); - fSPDVertex = new AliESDVertex(*source.fSPDVertex); - fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex); - fSPDMult = new AliMultiplicity(*source.fSPDMult); - fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger); - fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger); - fTracks = new TClonesArray(*source.fTracks); - fMuonTracks = new TClonesArray(*source.fMuonTracks); - fPmdTracks = new TClonesArray(*source.fPmdTracks); - fTrdTracks = new TClonesArray(*source.fTrdTracks); - fV0s = new TClonesArray(*source.fV0s); - fCascades = new TClonesArray(*source.fCascades); - fKinks = new TClonesArray(*source.fKinks); - fCaloClusters = new TClonesArray(*source.fCaloClusters); - fErrorLogs = new TClonesArray(*source.fErrorLogs); - - // CKB this way?? or - // or AddObject( fESDZDC = new AliESDZDC(*source.fESDZDC)); - - fESDObjects = new TList(); - AddObject(fESDRun); - AddObject(fHeader); - AddObject(fESDZDC); - AddObject(fESDFMD); - AddObject(fESDVZERO); - AddObject(fESDTZERO); - AddObject(fSPDVertex); - AddObject(fPrimaryVertex); - AddObject(fSPDMult); - AddObject(fPHOSTrigger); - AddObject(fEMCALTrigger); - AddObject(fTracks); - AddObject(fMuonTracks); - AddObject(fPmdTracks); - AddObject(fTrdTracks); - AddObject(fV0s); - AddObject(fCascades); - AddObject(fKinks); - AddObject(fCaloClusters); - AddObject(fErrorLogs); - - - fEMCALClusters = source.fEMCALClusters; - fFirstEMCALCluster = source.fFirstEMCALCluster; - fPHOSClusters = source.fPHOSClusters; - fFirstPHOSCluster = source.fFirstPHOSCluster; - - - - return *this; - + // + // copy constructor + // + for (Int_t i=0; i<24; i++) { + fT0time[i] = esd.fT0time[i]; + fT0amplitude[i] = esd.fT0amplitude[i]; + } + for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i]; + for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i]; } - //______________________________________________________________________________ AliESD::~AliESD() { // // Standard destructor // - - delete fESDObjects; - fESDObjects = 0; - - // everthing on the list gets deleted automatically - - /* + fTracks.Delete(); fHLTConfMapTracks.Delete(); fHLTHoughTracks.Delete(); - fMuonTracks.Delete(); + fMuonTracks.Delete(); fPmdTracks.Delete(); fTrdTracks.Delete(); fV0s.Delete(); fCascades.Delete(); fKinks.Delete(); fCaloClusters.Delete(); - */ -// fEMCALTriggerPosition->Delete(); -// fEMCALTriggerAmplitudes->Delete(); -// fPHOSTriggerPosition->Delete(); -// fPHOSTriggerAmplitudes->Delete(); -// delete fEMCALTriggerPosition; -// delete fEMCALTriggerAmplitudes; -// delete fPHOSTriggerPosition; -// delete fPHOSTriggerAmplitudes; + delete fESDFMD; + delete fESDVZERO; + delete fEMCALTriggerPosition; + delete fEMCALTriggerAmplitudes; + delete fPHOSTriggerPosition; + delete fPHOSTriggerAmplitudes; + delete fESDACORDE; + + fErrorLogs.Delete(); } //______________________________________________________________________________ void AliESD::Reset() { - // Reset the standard contents - if(fESDRun) fESDRun->Reset(); - if(fHeader) fHeader->Reset(); - if(fESDZDC) fESDZDC->Reset(); - if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names - // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED - // if(fESDVZERO) new (fESDVZERO) AliESDVZERO(); - if(fESDTZERO) fESDTZERO->Reset(); - // CKB no clear/reset implemented - if(fSPDVertex){ - new (fSPDVertex) AliESDVertex(); - fSPDVertex->SetName("SPDVertex"); - } - if(fPrimaryVertex){ - new (fPrimaryVertex) AliESDVertex(); - fPrimaryVertex->SetName("PrimaryVertex"); - } - if(fSPDMult)new (fSPDMult) AliMultiplicity(); - if(fPHOSTrigger)fPHOSTrigger->Reset(); - if(fEMCALTrigger)fEMCALTrigger->Reset(); - if(fTracks)fTracks->Clear(); - if(fMuonTracks)fMuonTracks->Clear(); - if(fPmdTracks)fPmdTracks->Clear(); - if(fTrdTracks)fTrdTracks->Clear(); - if(fV0s)fV0s->Clear(); - if(fCascades)fCascades->Clear(); - if(fKinks)fKinks->Clear(); - if(fCaloClusters)fCaloClusters->Clear(); - if(fErrorLogs) fErrorLogs->Clear(); + // + // Reset the contents and delete the entries in TClonesArrays + // + fEventNumberInFile=0; + fBunchCrossNumber=0; + fOrbitNumber=0; + fPeriodNumber=0; + fRunNumber=0; + fTimeStamp = 0; + fEventType = 0; + fTriggerMask=0; + fTriggerCluster=0; + fRecoVersion=0; + fMagneticField=0; + fZDCN1Energy=0; + fZDCP1Energy=0; + fZDCN2Energy=0; + fZDCP2Energy=0; + fZDCEMEnergy=0; + fZDCParticipants=0; + fT0zVertex=0; + + for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.; + for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.; + for (Int_t i=0; i<24; i++) { + fT0time[i] = 0; + fT0amplitude[i] = 0; + } + fT0timeStart = 0; + fT0clock = 0; +// + fSPDMult.~AliMultiplicity(); + new (&fSPDMult) AliMultiplicity(); + fSPDVertex.~AliESDVertex(); + new (&fSPDVertex) AliESDVertex(); + fPrimaryVertex.~AliESDVertex(); + new (&fPrimaryVertex) AliESDVertex(); +// + fTracks.Delete(); + fHLTConfMapTracks.Delete(); + fHLTHoughTracks.Delete(); + fMuonTracks.Delete(); + fPmdTracks.Delete(); + fTrdTracks.Delete(); + fV0s.Delete(); + fCascades.Delete(); + fKinks.Delete(); + fCaloClusters.Delete(); +// fEMCALClusters=0; fFirstEMCALCluster=-1; fPHOSClusters=0; fFirstPHOSCluster=-1; +// + if (fEMCALTriggerPosition) fEMCALTriggerPosition ->Reset(); + if (fEMCALTriggerAmplitudes) fEMCALTriggerAmplitudes->Reset(); + if (fPHOSTriggerPosition) fPHOSTriggerPosition ->Reset(); + if (fPHOSTriggerAmplitudes) fPHOSTriggerAmplitudes ->Reset(); +// + if (fESDFMD) fESDFMD->Clear(); +// + if (fESDVZERO){ + fESDVZERO->~AliESDVZERO(); + new (fESDVZERO) AliESDVZERO(); + } +// + if (fESDACORDE){ + fESDACORDE->~AliESDACORDE(); + new (fESDACORDE) AliESDACORDE(); + } +// + fErrorLogs.Delete(); +} + + +Bool_t AliESD::RemoveKink(Int_t rm) { + // --------------------------------------------------------- + // Remove a kink candidate and references to it from ESD, + // if this candidate does not come from a reconstructed decay + // Not yet implemented... + // --------------------------------------------------------- + Int_t last=GetNumberOfKinks()-1; + if ((rm<0)||(rm>last)) return kFALSE; + + return kTRUE; +} + +Bool_t AliESD::RemoveV0(Int_t rm) { + // --------------------------------------------------------- + // Remove a V0 candidate and references to it from ESD, + // if this candidate does not come from a reconstructed decay + // --------------------------------------------------------- + Int_t last=GetNumberOfV0s()-1; + if ((rm<0)||(rm>last)) return kFALSE; + + AliESDv0 *v0=GetV0(rm); + Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex(); + + v0=GetV0(last); + Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex(); + + Int_t used=0; + + // Check if this V0 comes from a reconstructed decay + Int_t ncs=GetNumberOfCascades(); + for (Int_t n=0; nGetPindex(); + Int_t csIdxN=cs->GetNindex(); + + if (idxP==csIdxP) + if (idxN==csIdxN) return kFALSE; + + if (csIdxP==lastIdxP) + if (csIdxN==lastIdxN) used++; + } + + //Replace the removed V0 with the last V0 + TClonesArray &a=fV0s; + delete a.RemoveAt(rm); + + if (rm==last) return kTRUE; + + //v0 is pointing to the last V0 candidate... + new (a[rm]) AliESDv0(*v0); + delete a.RemoveAt(last); + + if (!used) return kTRUE; + + + // Remap the indices of the daughters of reconstructed decays + for (Int_t n=0; nGetPindex(); + Int_t csIdxN=cs->GetNindex(); + + if (csIdxP==lastIdxP) + if (csIdxN==lastIdxN) { + cs->AliESDv0::SetIndex(1,idxP); + cs->AliESDv0::SetIndex(0,idxN); + used--; + if (!used) return kTRUE; + } + } + + return kTRUE; +} + +Bool_t AliESD::RemoveTrack(Int_t rm) { + // --------------------------------------------------------- + // Remove a track and references to it from ESD, + // if this track does not come from a reconstructed decay + // --------------------------------------------------------- + Int_t last=GetNumberOfTracks()-1; + if ((rm<0)||(rm>last)) return kFALSE; + + Int_t used=0; + + // Check if this track comes from the reconstructed primary vertex + if (fPrimaryVertex.GetStatus()) { + UShort_t *primIdx=fPrimaryVertex.GetIndices(); + Int_t n=fPrimaryVertex.GetNIndices(); + while (n--) { + Int_t idx=Int_t(primIdx[n]); + if (rm==idx) return kFALSE; + if (idx==last) used++; + } + } + + // Check if this track comes from a reconstructed decay + Int_t nv0=GetNumberOfV0s(); + for (Int_t n=0; nGetNindex(); + if (rm==idx) return kFALSE; + if (idx==last) used++; + + idx=v0->GetPindex(); + if (rm==idx) return kFALSE; + if (idx==last) used++; + } + + Int_t ncs=GetNumberOfCascades(); + for (Int_t n=0; nGetIndex(); + if (rm==idx) return kFALSE; + if (idx==last) used++; + } + + Int_t nkn=GetNumberOfKinks(); + for (Int_t n=0; nGetIndex(0); + if (rm==idx) return kFALSE; + if (idx==last) used++; + + idx=kn->GetIndex(1); + if (rm==idx) return kFALSE; + if (idx==last) used++; + } + + + //Replace the removed track with the last track + TClonesArray &a=fTracks; + delete a.RemoveAt(rm); + + if (rm==last) return kTRUE; + + AliESDtrack *t=GetTrack(last); + t->SetID(rm); + new (a[rm]) AliESDtrack(*t); + delete a.RemoveAt(last); + + + if (!used) return kTRUE; + + + // Remap the indices of the tracks used for the primary vertex reconstruction + if (fPrimaryVertex.GetStatus()) { + UShort_t *primIdx=fPrimaryVertex.GetIndices(); + Int_t n=fPrimaryVertex.GetNIndices(); + while (n--) { + Int_t idx=Int_t(primIdx[n]); + if (idx==last) { + primIdx[n]=Short_t(rm); + used--; + if (!used) return kTRUE; + } + } + } + + // Remap the indices of the daughters of reconstructed decays + for (Int_t n=0; nGetIndex(0)==last) { + v0->SetIndex(0,rm); + used--; + if (!used) return kTRUE; + } + if (v0->GetIndex(1)==last) { + v0->SetIndex(1,rm); + used--; + if (!used) return kTRUE; + } + } + + for (Int_t n=0; nGetIndex()==last) { + cs->SetIndex(rm); + used--; + if (!used) return kTRUE; + } + } + + for (Int_t n=0; nGetIndex(0)==last) { + kn->SetIndex(rm,0); + used--; + if (!used) return kTRUE; + } + if (kn->GetIndex(1)==last) { + kn->SetIndex(rm,1); + used--; + if (!used) return kTRUE; + } + } + + return kTRUE; +} + + +Bool_t AliESD::Clean(Float_t *cleanPars) { + // + // Remove the data which are not needed for the physics analysis. + // + // 1) Cleaning the V0 candidates + // --------------------------- + // If the cosine of the V0 pointing angle "csp" and + // the DCA between the daughter tracks "dca" does not satisfy + // the conditions + // + // csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1]) + // + // an attempt to remove this V0 candidate from ESD is made. + // + // The V0 candidate gets removed if it does not belong to any + // recosntructed cascade decay + // + // 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999 + // + // 2) Cleaning the tracks + // ---------------------- + // If track's transverse parameter is larger than cleanPars[2] + // OR + // track's longitudinal parameter is larger than cleanPars[3] + // an attempt to remove this track from ESD is made. + // + // The track gets removed if it does not come + // from a reconstructed decay + // + Bool_t rc=kFALSE; + + Float_t dcaMax=cleanPars[0]; + Float_t cspMin=cleanPars[1]; + + Int_t nV0s=GetNumberOfV0s(); + for (Int_t i=nV0s-1; i>=0; i--) { + AliESDv0 *v0=GetV0(i); + + Float_t dca=v0->GetDcaV0Daughters(); + Float_t csp=v0->GetV0CosineOfPointingAngle(); + Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin); + if (csp > cspcut) continue; + + if (RemoveV0(i)) rc=kTRUE; + } + + + Float_t dmax=cleanPars[2], zmax=cleanPars[3]; + + const AliESDVertex *vertex=GetVertex(); + Bool_t vtxOK=vertex->GetStatus(); + + Int_t nTracks=GetNumberOfTracks(); + for (Int_t i=nTracks-1; i>=0; i--) { + AliESDtrack *track=GetTrack(i); + Float_t xy,z; track->GetImpactParameters(xy,z); + if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) { + if (RemoveTrack(i)) rc=kTRUE; + } + } + + return rc; } Int_t AliESD::AddV0(const AliESDv0 *v) { // // Add V0 // - TClonesArray &fv = *fV0s; - Int_t idx=fV0s->GetEntriesFast(); - new(fv[idx]) AliESDv0(*v); - return idx; + Int_t idx=fV0s.GetEntriesFast(); + new(fV0s[idx]) AliESDv0(*v); + return idx; } //______________________________________________________________________________ @@ -285,16 +548,19 @@ void AliESD::Print(Option_t *) const GetRunNumber(), GetTriggerMask(), GetMagneticField() ); - printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n", - fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(), - fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(), - fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes()); + printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n", + fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(), + fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(), + fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes()); printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n", GetDiamondX(),GetDiamondY()); printf("SPD Multiplicity. Number of tracklets %d \n", - fSPDMult->GetNumberOfTracklets()); + fSPDMult.GetNumberOfTracklets()); + printf("Event from reconstruction version %d \n",fRecoVersion); printf("Number of tracks: \n"); printf(" charged %d\n", GetNumberOfTracks()); + printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks()); + printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks()); printf(" muon %d\n", GetNumberOfMuonTracks()); printf(" pmd %d\n", GetNumberOfPmdTracks()); printf(" trd %d\n", GetNumberOfTrdTracks()); @@ -315,51 +581,13 @@ void AliESD::SetESDfriend(const AliESDfriend *ev) { if (!ev) return; Int_t ntrk=ev->GetNumberOfTracks(); - + for (Int_t i=0; iGetTrack(i); GetTrack(i)->SetFriendTrack(f); } } -Int_t AliESD::AddTrack(const AliESDtrack *t) { - // Add track - TClonesArray &ftr = *fTracks; - AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t); - track->SetID(fTracks->GetEntriesFast()-1); - return track->GetID(); -} - -Int_t AliESD::AddKink(const AliESDkink *c) { - // Add kink - TClonesArray &fk = *fKinks; - AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c); - kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps.. - return fKinks->GetEntriesFast()-1; -} - -Int_t AliESD::AddCaloCluster(const AliESDCaloCluster *c) { - // Add calocluster - TClonesArray &fc = *fCaloClusters; - AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c); - clus->SetID(fCaloClusters->GetEntriesFast()-1); - return fCaloClusters->GetEntriesFast()-1; - } - - -void AliESD::SetFMDData(AliESDFMD * obj) { - // use already allocated space - if(fESDFMD){ - new(fESDFMD) AliESDFMD(*obj); - } -} - -void AliESD::SetVZEROData(AliESDVZERO * obj){ - // use already allocated space - if(fESDVZERO) - new(fESDVZERO) AliESDVZERO(*obj); -} - void AliESD::GetESDfriend(AliESDfriend *ev) const { // // Extracts the complementary info from the ESD @@ -369,141 +597,25 @@ void AliESD::GetESDfriend(AliESDfriend *ev) const { Int_t ntrk=GetNumberOfTracks(); for (Int_t i=0; iGetFriendTrack(); ev->AddTrack(f); - } -} + t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack" -void AliESD::AddObject(TObject* obj) -{ - // Add an object to the list of object. - // Please be aware that in order to increase performance you should - // refrain from using TObjArrays (if possible). Use TClonesArrays, instead. - fESDObjects->AddLast(obj); -} - - -void AliESD::GetStdContent() -{ - // set pointers for standard content - - fESDRun = (AliESDRun*)fESDObjects->At(kESDRun); - fHeader = (AliESDHeader*)fESDObjects->At(kHeader); - fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC); - fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD); - fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO); - fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO); - fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex); - fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex); - fSPDMult = (AliMultiplicity*)fESDObjects->At(kSPDMult); - fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger); - fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger); - fTracks = (TClonesArray*)fESDObjects->At(kTracks); - fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks); - fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks); - fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks); - fV0s = (TClonesArray*)fESDObjects->At(kV0s); - fCascades = (TClonesArray*)fESDObjects->At(kCascades); - fKinks = (TClonesArray*)fESDObjects->At(kKinks); - fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters); - fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs); - + } } -void AliESD::SetStdNames(){ - // Set the names of the standard contents - fSPDVertex->SetName("SPDVertex"); - fPrimaryVertex->SetName("PrimaryVertex"); - fPHOSTrigger->SetName("PHOSTrigger"); - fEMCALTrigger->SetName("EMCALTrigger"); - fTracks->SetName("Tracks"); - fMuonTracks->SetName("MuonTracks"); - fPmdTracks->SetName("PmdTracks"); - fTrdTracks->SetName("TrdTracks"); - fV0s->SetName("V0s"); - fCascades->SetName("Cascades"); - fKinks->SetName("Kinks"); - fCaloClusters->SetName("CaloClusters"); - -} - -void AliESD::CreateStdContent() +void AliESD::SetDiamond(const AliESDVertex *vertex) { - // create the standard AOD content and set pointers - - // create standard objects and add them to the TList of objects - AddObject(new AliESDRun()); - AddObject(new AliESDHeader()); - AddObject(new AliESDZDC()); - AddObject(new AliESDFMD()); - AddObject(new AliESDVZERO()); - AddObject(new AliESDTZERO()); - AddObject(new AliESDVertex()); - AddObject(new AliESDVertex()); - AddObject(new AliMultiplicity()); - AddObject(new AliESDCaloTrigger()); - AddObject(new AliESDCaloTrigger()); - AddObject(new TClonesArray("AliESDtrack",0)); - AddObject(new TClonesArray("AliESDMuonTrack",0)); - AddObject(new TClonesArray("AliESDPmdTrack",0)); - AddObject(new TClonesArray("AliESDTrdTrack",0)); - AddObject(new TClonesArray("AliESDv0",0)); - AddObject(new TClonesArray("AliESDcascade",0)); - AddObject(new TClonesArray("AliESDkink",0)); - AddObject(new TClonesArray("AliESDCaloCluster",0)); - AddObject(new TClonesArray("AliRawDataErrorLog",0)); - - // check the order of the indices against enum... - - // read back pointers - GetStdContent(); - // set names - SetStdNames(); - -} - -void AliESD::ReadFromTree(TTree *tree){ - - - // is this really so smart that an ESDObject has a pointer to a list - // of another ESDObject... - - fESDObjects = (TList*)((AliESD*)tree->GetTree()->GetUserInfo()->FindObject("AliESD"))->GetList(); - - // if list is empty - // we could still set the branch adresses based on - // tree->GetListOfBranches() CKB - // or create standard list - - if(fESDObjects->GetEntries()GetEntries(),kESDListN); - } - - - - // set the branch addresses - TIter next(fESDObjects); - TNamed *el; - while((el=(TNamed*)next())){ - TString bname(el->GetName()); - - if(bname.CompareTo("AliESDfriend")==0) - { - // AliESDfriend does not have a name ... - tree->SetBranchStatus("ESDfriend.*",1); - tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el)); - - - } - else{ - tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el)); - } + // + // Set the interaction diamond + // + fDiamondXY[0]=vertex->GetXv(); + fDiamondXY[1]=vertex->GetYv(); + Double_t cov[6]; + vertex->GetCovMatrix(cov); + fDiamondCovXY[0]=cov[0]; + fDiamondCovXY[1]=cov[1]; + fDiamondCovXY[2]=cov[2]; } - - GetStdContent(); -} - - -