//-----------------------------------------------------------------
// Implementation of the AliESDEvent class
-// This is the class to deal with during the phisical analysis of data.
+// This is the class to deal with during the physics analysis of data.
// It also ensures the backward compatibility with the old ESD format.
+/*
+ AliESDEvent *ev= new AliESDEvent();
+ ev->ReadFromTree(esdTree);
+ ...
+ for (Int_t i=0; i<nev; i++) {
+ esdTree->GetEntry(i);
+ if(ev->GetAliESDOld())ev->CopyFromOldESD();
+*/
+// The AliESDInputHAndler does this automatically for you
//
// Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
//-----------------------------------------------------------------
#include "TList.h"
+#include "TRefArray.h"
#include <TNamed.h>
#include "AliESDEvent.h"
#include "AliESDfriend.h"
#include "AliESDVZERO.h"
-#include "AliESDHLTtrack.h"
#include "AliESDFMD.h"
#include "AliESD.h"
#include "AliESDMuonTrack.h"
// here we define the names, some classes are no TNamed, therefore the classnames
// are the Names
- const char* AliESDEvent::fESDListName[kESDListN] = {"AliESDRun",
+ const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
"AliESDHeader",
"AliESDZDC",
"AliESDFMD",
// Reset the standard contents
ResetStdContent();
-
if(fESDOld)fESDOld->Reset();
// call reset for user supplied data?
}
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(fESDVZERO){
+ // reset by callin d'to /c'tor keep the pointer
+ fESDVZERO->~AliESDVZERO();
+ new (fESDVZERO) AliESDVZERO();
+ }
if(fESDTZERO) fESDTZERO->Reset();
// CKB no clear/reset implemented
if(fSPDVertex){
fSPDVertex->~AliESDVertex();
new (fSPDVertex) AliESDVertex();
- fSPDVertex->SetName(fESDListName[kSPDVertex]);
+ fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
}
if(fPrimaryVertex){
fPrimaryVertex->~AliESDVertex();
new (fPrimaryVertex) AliESDVertex();
- fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
+ fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
}
if(fSPDMult){
fSPDMult->~AliMultiplicity();
if(fPHOSTrigger)fPHOSTrigger->Reset();
if(fEMCALTrigger)fEMCALTrigger->Reset();
if(fTracks)fTracks->Delete();
- 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(fMuonTracks)fMuonTracks->Delete();
+ if(fPmdTracks)fPmdTracks->Delete();
+ if(fTrdTracks)fTrdTracks->Delete();
+ if(fV0s)fV0s->Delete();
+ if(fCascades)fCascades->Delete();
+ if(fKinks)fKinks->Delete();
if(fCaloClusters)fCaloClusters->Delete();
if(fErrorLogs) fErrorLogs->Delete();
}
}
-Bool_t AliESDEvent::RemoveTrack(Int_t /*i*/) {
+Bool_t AliESDEvent::RemoveKink(Int_t rm) {
// ---------------------------------------------------------
- // Remove track
+ // 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 AliESDEvent::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; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+ Int_t csIdxP=cs->GetPindex();
+ 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; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+
+ Int_t csIdxP=cs->GetPindex();
+ 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 AliESDEvent::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 a reconstructed decay
- // if (yes) return kFALSE
+ Int_t nv0=GetNumberOfV0s();
+ for (Int_t n=0; n<nv0; n++) {
+ AliESDv0 *v0=GetV0(n);
+
+ Int_t idx=v0->GetNindex();
+ 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; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+ Int_t idx=cs->GetIndex();
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
+
+ Int_t nkn=GetNumberOfKinks();
+ for (Int_t n=0; n<nkn; n++) {
+ AliESDkink *kn=GetKink(n);
+
+ Int_t idx=kn->GetIndex(0);
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+
+ idx=kn->GetIndex(1);
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
- // Remap the indices of the daughters of recosntructed decays
- // Remove the track
- // delete fTracks->RemoveAt(i);
+ //Replace the removed track with the last track
+ TClonesArray &a=*fTracks;
+ delete a.RemoveAt(rm);
- // Compress the array with tracks
- // fTracks->Compress();
+ 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 daughters of reconstructed decays
+ for (Int_t n=0; n<nv0; n++) {
+ AliESDv0 *v0=GetV0(n);
+ if (v0->GetIndex(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; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+ if (cs->GetIndex()==last) {
+ cs->SetIndex(rm);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+
+ for (Int_t n=0; n<nkn; n++) {
+ AliESDkink *kn=GetKink(n);
+ if (kn->GetIndex(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;
}
-Int_t AliESDEvent::AddTrack(const AliESDtrack *t) {
+Bool_t AliESDEvent::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 AliESDEvent::AddTrack(const AliESDtrack *t)
+{
// Add track
TClonesArray &ftr = *fTracks;
AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
return track->GetID();
}
- void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) {
+ void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
+{
TClonesArray &fmu = *fMuonTracks;
new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
}
-void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) {
+void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
+{
TClonesArray &fpmd = *fPmdTracks;
new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
}
-void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) {
+void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
+{
TClonesArray &ftrd = *fTrdTracks;
new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
}
-Int_t AliESDEvent::AddKink(const AliESDkink *c) {
+Int_t AliESDEvent::AddKink(const AliESDkink *c)
+{
// Add kink
TClonesArray &fk = *fKinks;
AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
}
-void AliESDEvent::AddCascade(const AliESDcascade *c) {
+void AliESDEvent::AddCascade(const AliESDcascade *c)
+{
TClonesArray &fc = *fCascades;
new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
}
-Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
+Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
+{
// Add calocluster
TClonesArray &fc = *fCaloClusters;
AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
}
- void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) {
- TClonesArray &errlogs = *fErrorLogs;
- new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
- }
+void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) {
+ TClonesArray &errlogs = *fErrorLogs;
+ new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
+}
-void AliESDEvent::SetVertex(const AliESDVertex *vertex) {
+void AliESDEvent::SetVertex(const AliESDVertex *vertex)
+{
+ // Set the SPD vertex
// use already allocated space
if(fSPDVertex){
*fSPDVertex = *vertex;
- fSPDVertex->SetName(fESDListName[kSPDVertex]);
+ fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
}
}
-void AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) {
+void AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex)
+{
+ // Set the primary vertex
+ // use already allocated space
if(fPrimaryVertex){
*fPrimaryVertex = *vertex;
- fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
+ fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
}
}
-void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) {
+void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
+{
+ // Set the SPD Multiplicity
if(fSPDMult){
*fSPDMult = *mul;
}
}
-void AliESDEvent::SetFMDData(AliESDFMD * obj) {
+void AliESDEvent::SetFMDData(AliESDFMD * obj)
+{
// use already allocated space
if(fESDFMD){
*fESDFMD = *obj;
}
}
-void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
+void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
+{
// use already allocated space
if(fESDVZERO)
- new(fESDVZERO) AliESDVZERO(*obj);
+ *fESDVZERO = *obj;
}
-void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
+void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
+{
//
// Extracts the complementary info from the ESD
//
// set pointers for standard content
// get by name much safer and not a big overhead since not called very often
- fESDRun = (AliESDRun*)fESDObjects->FindObject(fESDListName[kESDRun]);
- fHeader = (AliESDHeader*)fESDObjects->FindObject(fESDListName[kHeader]);
- fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fESDListName[kESDZDC]);
- fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fESDListName[kESDFMD]);
- fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fESDListName[kESDVZERO]);
- fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fESDListName[kESDTZERO]);
- fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kSPDVertex]);
- fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kPrimaryVertex]);
- fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fESDListName[kSPDMult]);
- fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kPHOSTrigger]);
- fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kEMCALTrigger]);
- fTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTracks]);
- fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kMuonTracks]);
- fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kPmdTracks]);
- fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTrdTracks]);
- fV0s = (TClonesArray*)fESDObjects->FindObject(fESDListName[kV0s]);
- fCascades = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCascades]);
- fKinks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kKinks]);
- fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCaloClusters]);
- fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fESDListName[kErrorLogs]);
+ fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
+ fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
+ fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
+ fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
+ fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
+ fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
+ fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
+ fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
+ fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
+ fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
+ fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
+ fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
+ fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
+ fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
+ fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
+ fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
+ fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
+ fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
+ fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
+ fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
}
for(int i = 0;i < fESDObjects->GetEntries();i++){
TObject *fObj = fESDObjects->At(i);
if(fObj->InheritsFrom("TNamed")){
- ((TNamed*)fObj)->SetName(fESDListName[i]);
+ ((TNamed*)fObj)->SetName(fgkESDListName[i]);
}
else if(fObj->InheritsFrom("TClonesArray")){
- ((TClonesArray*)fObj)->SetName(fESDListName[i]);
+ ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
}
}
}
return 0;
}
+Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
+{
+ // fills the provided TRefArray with all found phos clusters
+
+ clusters->Clear();
+
+ AliESDCaloCluster *cl = 0;
+ for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
+
+ if ( (cl = GetCaloCluster(i))) {
+ if (cl->IsPHOS()){
+ clusters->Add(cl);
+ printf("IsPHOS %d Size: %d \n",i,clusters->GetEntriesFast());
+ }
+ }
+ }
+ return clusters->GetEntriesFast();
+}
+
+Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
+{
+ // fills the provided TRefArray with all found phos clusters
+
+ clusters->Clear();
+
+ AliESDCaloCluster *cl = 0;
+ for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
+
+ if ( (cl = GetCaloCluster(i))) {
+ if (cl->IsEMCAL()){
+ clusters->Add(cl);
+ printf("IsEMCAL %d Size: %d \n",i,clusters->GetEntriesFast());
+ }
+ }
+ }
+ return clusters->GetEntriesFast();
+}
+
+
void AliESDEvent::ReadFromTree(TTree *tree){
+ if(!tree){
+ Printf("%s %d AliESDEvent::ReadFromTree() Zero Pointer to Tree \n",(char*)__FILE__,__LINE__);
+ return;
+ }
+
// load the TTree
- tree->LoadTree(0);
+ if(!tree->GetTree())tree->LoadTree(0);
// if we find the "ESD" branch on the tree we do have the old structure
if(tree->GetBranch("ESD")){
- char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
- if (!address) {
- printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
- tree->SetBranchAddress("ESD",&fESDOld);
- } else {
- printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
- printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
- fESDOld = (AliESD*) (*address);
- }
-
-
- CreateStdContent(); // create for copy
- // when reading back we are not owner of the list
- // must not delete it
- fESDObjects->SetOwner(kFALSE);
+ char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
+ if (!address) {
+ printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
+ tree->SetBranchAddress("ESD",&fESDOld);
+ } else {
+ printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
+ printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
+ fESDOld = (AliESD*) (*address);
+ }
+
+ // have already connected the old ESD structure... ?
+ // reuse also the pointer of the AlliESDEvent
+ // otherwise create new ones
+
+ TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
+
+ if(connectedList){
+ // If connected use the connected list of objects
+ fESDObjects->Delete();
+ fESDObjects = connectedList;
+ GetStdContent();
+ fConnected = true;
return;
+ }
+ // else...
+ CreateStdContent(); // create for copy
+ // we are not owner of the list objects
+ // must not delete it
+ fESDObjects->SetOwner(kFALSE);
+ fESDObjects->SetName("ESDObjectsConnectedToTree");
+ tree->GetUserInfo()->Add(fESDObjects);
+ fConnected = true;
+ return;
}
+ delete fESDOld;
fESDOld = 0;
-
-
// Try to find AliESDEvent
AliESDEvent *esdEvent = 0;
esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
- //esdEvent = (AliESDEvent*)tree->GetUserInfo()->FindObject("AliESDEvent");
-
if(esdEvent){
// Check if already connected to tree
TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
return;
}
// Connect to tree
- if(fESDObjects->GetEntries()!=0){
- // this should not happen here put a warning?
- }
// prevent a memory leak when reading back the TList
delete fESDObjects;
fESDObjects = 0;
TNamed *el;
while((el=(TNamed*)next())){
TString bname(el->GetName());
-
if(bname.CompareTo("AliESDfriend")==0)
{
// AliESDfriend does not have a name ...
// must not delete it
fESDObjects->SetOwner(kFALSE);
}
-
-
-
}
// Run
SetRunNumber(fESDOld->GetRunNumber());
SetPeriodNumber(fESDOld->GetPeriodNumber());
- SetMagneticField(fESDRun->GetMagneticField());
+ SetMagneticField(fESDOld->GetMagneticField());
// leave out diamond ...
// SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
// FMD
- SetFMDData(fESDOld->GetFMDData());
+ if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
// T0
// VZERO
if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
- SetVertex(fESDOld->GetVertex());
+ if(fESDOld->GetVertex())SetVertex(fESDOld->GetVertex());
- SetPrimaryVertex(fESDOld->GetPrimaryVertex());
+ if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
- SetMultiplicity(fESDOld->GetMultiplicity());
+ if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
AddTrack(fESDOld->GetTrack(i));
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff