X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliESDEvent.cxx;h=f7268f98cec46546aa0a9726219efb7475a14164;hb=04cd9bcd360d53ac0d1772d679c603d51201ed54;hp=dfb3ae690aba025be2628fa0d4fc2e3ffb946910;hpb=16167d49ce7616ac45413fc6a318890e48690775;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliESDEvent.cxx b/STEER/AliESDEvent.cxx
index dfb3ae690ab..f7268f98cec 100644
--- a/STEER/AliESDEvent.cxx
+++ b/STEER/AliESDEvent.cxx
@@ -17,19 +17,28 @@
 
 //-----------------------------------------------------------------
 //           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"
@@ -58,7 +67,7 @@ ClassImp(AliESDEvent)
 
 // 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",
@@ -261,7 +270,6 @@ void AliESDEvent::Reset()
   
   // Reset the standard contents
   ResetStdContent(); 
-
   if(fESDOld)fESDOld->Reset();
   // call reset for user supplied data?
 }
@@ -273,19 +281,22 @@ void AliESDEvent::ResetStdContent()
   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();
@@ -294,12 +305,12 @@ void AliESDEvent::ResetStdContent()
   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();
 
@@ -380,27 +391,251 @@ void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
   }
 }
 
-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);
@@ -408,17 +643,20 @@ Int_t  AliESDEvent::AddTrack(const 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);
 }
@@ -426,7 +664,8 @@ void AliESDEvent::AddTrdTrack(const 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);
@@ -435,13 +674,15 @@ Int_t AliESDEvent::AddKink(const 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);
@@ -450,47 +691,57 @@ Int_t AliESDEvent::AddCaloCluster(const 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
   //
@@ -524,26 +775,26 @@ void AliESDEvent::GetStdContent()
   // 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]);
 
 }
 
@@ -554,10 +805,10 @@ void AliESDEvent::SetStdNames(){
     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]);
       }
     }
   }
@@ -605,39 +856,97 @@ TObject* AliESDEvent::FindListObject(const char *name){
   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"));
@@ -650,9 +959,6 @@ void AliESDEvent::ReadFromTree(TTree *tree){
       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;
@@ -669,7 +975,6 @@ void AliESDEvent::ReadFromTree(TTree *tree){
     TNamed *el;
     while((el=(TNamed*)next())){
       TString bname(el->GetName());
-      
       if(bname.CompareTo("AliESDfriend")==0)
 	{
 	  // AliESDfriend does not have a name ...
@@ -704,9 +1009,6 @@ void AliESDEvent::ReadFromTree(TTree *tree){
     // must not delete it
     fESDObjects->SetOwner(kFALSE);
   }
-
-
-
 }
 
 
@@ -720,7 +1022,7 @@ void AliESDEvent::CopyFromOldESD()
      // Run
     SetRunNumber(fESDOld->GetRunNumber());
     SetPeriodNumber(fESDOld->GetPeriodNumber());
-    SetMagneticField(fESDRun->GetMagneticField());
+    SetMagneticField(fESDOld->GetMagneticField());
   
     // leave out diamond ...
     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
@@ -745,7 +1047,7 @@ void AliESDEvent::CopyFromOldESD()
 
     // FMD
     
-    SetFMDData(fESDOld->GetFMDData());
+    if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
 
     // T0
 
@@ -756,11 +1058,11 @@ void AliESDEvent::CopyFromOldESD()
     // 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));