Implemented Copy() function for all esd objects to allow for assignment of AliESDEven...
authorkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 May 2008 09:54:45 +0000 (09:54 +0000)
committerkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 May 2008 09:54:45 +0000 (09:54 +0000)
42 files changed:
STEER/AliESDACORDE.cxx
STEER/AliESDACORDE.h
STEER/AliESDCaloCells.cxx
STEER/AliESDCaloCells.h
STEER/AliESDCaloCluster.cxx
STEER/AliESDCaloCluster.h
STEER/AliESDCaloTrigger.cxx
STEER/AliESDCaloTrigger.h
STEER/AliESDEvent.cxx
STEER/AliESDEvent.h
STEER/AliESDFMD.cxx
STEER/AliESDFMD.h
STEER/AliESDHeader.cxx
STEER/AliESDHeader.h
STEER/AliESDMuonTrack.cxx
STEER/AliESDMuonTrack.h
STEER/AliESDPmdTrack.cxx
STEER/AliESDPmdTrack.h
STEER/AliESDRun.cxx
STEER/AliESDRun.h
STEER/AliESDTZERO.cxx
STEER/AliESDTZERO.h
STEER/AliESDTrdTrack.cxx
STEER/AliESDTrdTrack.h
STEER/AliESDVZERO.cxx
STEER/AliESDVZERO.h
STEER/AliESDVertex.cxx
STEER/AliESDVertex.h
STEER/AliESDZDC.cxx
STEER/AliESDZDC.h
STEER/AliESDcascade.cxx
STEER/AliESDcascade.h
STEER/AliESDkink.cxx
STEER/AliESDkink.h
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliESDv0.cxx
STEER/AliESDv0.h
STEER/AliMultiplicity.cxx
STEER/AliMultiplicity.h
STEER/AliRawDataErrorLog.cxx
STEER/AliRawDataErrorLog.h

index a0c3b8c..f642521 100644 (file)
@@ -52,4 +52,17 @@ AliESDACORDE& AliESDACORDE::operator=(const AliESDACORDE& o)
        return *this;
 }
 
+void AliESDACORDE::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDACORDE *robj = dynamic_cast<AliESDACORDE*>(&obj);
+  if(!robj)return; // not an AliESDACRDE
+  *robj = *this;
+
+}
+
 
index 4da5136..841734f 100644 (file)
@@ -6,26 +6,25 @@
 class AliESDACORDE : public TObject
 {
 
-       public:
-               AliESDACORDE();
-               AliESDACORDE(const AliESDACORDE&);
-                AliESDACORDE(Int_t *ACORDESingleMuon,Int_t *ACORDEMultiMuon); 
-               virtual ~AliESDACORDE() {};
+ public:
+  AliESDACORDE();
+  AliESDACORDE(const AliESDACORDE&);
+  AliESDACORDE(Int_t *ACORDESingleMuon,Int_t *ACORDEMultiMuon); 
+  virtual ~AliESDACORDE() {};
+  virtual void Copy(TObject &) const;
+  void SetACORDEMultiMuon(Bool_t ACORDEMultiMuon[60]){for(Int_t i=0;i<60;i++){fACORDEMultiMuon[i]=ACORDEMultiMuon[i];}}
+  
+  void SetACORDESingleMuon(Bool_t ACORDESingleMuon[60]){for(Int_t i=0;i<60;i++){fACORDESingleMuon[i]=ACORDESingleMuon[i];}} 
+  
        
-               void SetACORDEMultiMuon(Bool_t ACORDEMultiMuon[60]){for(Int_t i=0;i<60;i++){fACORDEMultiMuon[i]=ACORDEMultiMuon[i];}}
-
-               void SetACORDESingleMuon(Bool_t ACORDESingleMuon[60]){for(Int_t i=0;i<60;i++){fACORDESingleMuon[i]=ACORDESingleMuon[i];}} 
-
-       
-               AliESDACORDE &operator=(const AliESDACORDE& source);
-
-       protected:
-
-       Bool_t  fACORDESingleMuon[60];  // array with the Single Muon hits in the 60 Acorde's Modules 
-       Bool_t  fACORDEMultiMuon[60];   // array with the Multi Muon hits in the 60 Acorde's Modules
-
-
-       ClassDef(AliESDACORDE,2)
+  AliESDACORDE &operator=(const AliESDACORDE& source);
+  
+ protected:
+  
+  Bool_t       fACORDESingleMuon[60];  // array with the Single Muon hits in the 60 Acorde's Modules 
+  Bool_t       fACORDEMultiMuon[60];   // array with the Multi Muon hits in the 60 Acorde's Modules
+
+  ClassDef(AliESDACORDE,2)
 
 };
 
index 1a0c3f1..da5c2d9 100644 (file)
@@ -59,10 +59,17 @@ AliESDCaloCells & AliESDCaloCells::operator =(const AliESDCaloCells& source)
   if(&source == this) return *this;
   TNamed::operator=(source);
 
+  if(fNCells != source.fNCells){
+    DeleteContainer();
+    CreateContainer(source.fNCells);
+  }
+
   fNCells = source.fNCells; 
   fIsSorted = source.fIsSorted;
   fType = source.fType;
-  
+
+
+
   for(Int_t i = 0; i < fNCells; i++){
     fCellNumber[i] = source.fCellNumber[i];
     fAmplitude[i] = source.fAmplitude[i];
@@ -73,6 +80,20 @@ AliESDCaloCells & AliESDCaloCells::operator =(const AliESDCaloCells& source)
 
 }
 
+
+void AliESDCaloCells::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDCaloCells *robj = dynamic_cast<AliESDCaloCells*>(&obj);
+  if(!robj)return; // not an AliESDCaloCells
+  *robj = *this;
+
+}
+
 //_______________________________________________________________________
 AliESDCaloCells::~AliESDCaloCells()
 {
index a6534a3..69057c3 100644 (file)
@@ -29,6 +29,7 @@ class AliESDCaloCells : public TNamed
   AliESDCaloCells(const AliESDCaloCells & cells);
   AliESDCaloCells & operator=(const AliESDCaloCells& source);
   virtual ~AliESDCaloCells();
+  virtual void Copy(TObject &obj) const;
   
   Bool_t IsEMCAL() const {return (fType == kEMCALCell);}
   Bool_t IsPHOS() const {return (fType == kPHOSCell);}
index 78f6efa..3c3bc9f 100644 (file)
@@ -133,45 +133,103 @@ AliESDCaloCluster &AliESDCaloCluster::operator=(const AliESDCaloCluster& source)
   for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = source.fPID[i];
   fID = source.fID;
 
-  fNCells= source. fNCells;
+  fNCells= source.fNCells;
+
   if (source.fNCells > 0) {
-    
     if(source.fCellsAbsId){
-      fCellsAbsId = new UShort_t[source.fNCells];
+      if(fNCells != source.fNCells){
+       delete [] fCellsAbsId;
+       fCellsAbsId = new UShort_t[source.fNCells];
+      }
       for (Int_t i=0; i<source.fNCells; i++)
        fCellsAbsId[i]=source.fCellsAbsId[i];
     }
     
     if(source.fCellsAmpFraction){
-      fCellsAmpFraction = new Double32_t[source.fNCells];
+      if(fNCells != source.fNCells){
+       delete [] fCellsAmpFraction;
+       fCellsAmpFraction = new Double32_t[source.fNCells];
+      }
       for (Int_t i=0; i<source.fNCells; i++)
        fCellsAmpFraction[i]=source.fCellsAmpFraction[i];
-    }
-    
+    }  
   }
 
   fNExMax = source.fNExMax;
   fClusterType = source.fClusterType;
 
   //not in use
-  delete fTracksMatched;
-  fTracksMatched = source.fTracksMatched?new TArrayI(*source.fTracksMatched):0x0;
-  delete fLabels;
-  fLabels = source.fLabels?new TArrayI(*source.fLabels):0x0;
-  
-  delete fDigitAmplitude;
-  fDigitAmplitude = source.fDigitAmplitude?new TArrayS(*source.fDigitAmplitude):0x0;
-  
-  delete fDigitTime;
-  fDigitTime = source.fDigitTime?new TArrayS(*source.fDigitTime):0x0;
-  
-  delete fDigitIndex;
-  fDigitIndex = source.fDigitIndex?new TArrayS(*source.fDigitIndex):0x0;
+  if(source.fTracksMatched){
+    // assign or copy construct
+    if(fTracksMatched) *fTracksMatched = *source.fTracksMatched;
+    else fTracksMatched = new TArrayI(*source.fTracksMatched);
+  }
+  else{
+    delete fTracksMatched;
+    fTracksMatched = 0;
+  }
+
+  if(source.fLabels){
+    // assign or copy construct
+    if(fLabels) *fLabels = *source.fLabels;
+    else fLabels = new TArrayI(*source.fLabels);
+  }
+  else{
+    delete fLabels;
+    fLabels = 0;
+  }
+
+
+  if(source.fDigitAmplitude){
+    // assign or copy construct
+    if(fDigitAmplitude) *fDigitAmplitude = *source.fDigitAmplitude;
+    else fDigitAmplitude = new TArrayS(*source.fDigitAmplitude);
+  }
+  else{
+    delete fDigitAmplitude;
+    fDigitAmplitude = 0;
+  }
+
+
+
+  if(source.fDigitTime){
+    // assign or copy construct
+    if(fDigitTime) *fDigitTime = *source.fDigitTime;
+    else fDigitTime = new TArrayS(*source.fDigitTime);
+  }
+  else{
+    delete fDigitTime;
+    fDigitTime = 0;
+  }
+
+
+
+  if(source.fDigitIndex){
+    // assign or copy construct
+    if(fDigitIndex) *fDigitIndex = *source.fDigitIndex;
+    else fDigitIndex = new TArrayS(*source.fDigitIndex);
+  }
+  else{
+    delete fDigitIndex;
+    fDigitIndex = 0;
+  }
   
   return *this;
 
 }
 
+void AliESDCaloCluster::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDCaloCluster *robj = dynamic_cast<AliESDCaloCluster*>(&obj);
+  if(!robj)return; // not an AliESDCluster
+  *robj = *this;
+
+}
 
 //_______________________________________________________________________
 AliESDCaloCluster::~AliESDCaloCluster(){ 
index c8d50bd..6fc951e 100644 (file)
@@ -31,6 +31,7 @@ public:
   AliESDCaloCluster(const AliESDCaloCluster& clus);
   AliESDCaloCluster & operator=(const AliESDCaloCluster& source);
   virtual ~AliESDCaloCluster();
+  virtual void Copy(TObject &) const;
 
   void SetID(Int_t id) {fID = id;}
   Int_t GetID() const {return fID;}
index b83fc1b..d3a8269 100644 (file)
@@ -50,16 +50,43 @@ AliESDCaloTrigger& AliESDCaloTrigger::operator=(const AliESDCaloTrigger& ctrig)
   // assigment operator
   if(this!=&ctrig) {
     TNamed::operator=(ctrig);
-    // CKB dont't want to create leak if fTriggerAmp points to 
-    // something already 
-    delete fTriggerAmplitudes;
-    fTriggerAmplitudes = new TArrayF(*ctrig.fTriggerAmplitudes);
-    delete fTriggerPosition;    
-    fTriggerPosition = new TArrayF(*ctrig.fTriggerPosition);
+    if(ctrig.fTriggerAmplitudes){
+      // asign or copy construct
+      if(fTriggerAmplitudes)*fTriggerAmplitudes = *ctrig.fTriggerAmplitudes;
+      else fTriggerAmplitudes = new TArrayF(*ctrig.fTriggerAmplitudes);
+    }
+    else{
+      delete fTriggerAmplitudes;
+      fTriggerAmplitudes = 0;
+    }
+
+    if(ctrig.fTriggerPosition){
+      // asign or copy construct
+      if(fTriggerPosition)*fTriggerPosition = *ctrig.fTriggerPosition;
+      else fTriggerPosition = new TArrayF(*ctrig.fTriggerPosition);
+    }
+    else{
+      delete fTriggerPosition;
+      fTriggerPosition = 0;
+    }
   } 
   return *this;
 }
 
+void AliESDCaloTrigger::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDCaloTrigger *robj = dynamic_cast<AliESDCaloTrigger*>(&obj);
+  if(!robj)return; // not an AliESDCaloTrigger
+  *robj = *this;
+
+}
+
+
 void AliESDCaloTrigger::Reset()
 {
   // simple reset
index 104ffe0..d5fc630 100644 (file)
@@ -28,16 +28,16 @@ public:
   AliESDCaloTrigger(const  AliESDCaloTrigger& ctrig);
   AliESDCaloTrigger& operator=(const  AliESDCaloTrigger& ctrig);
   virtual ~AliESDCaloTrigger();
+  virtual void Copy(TObject &obj) const;
 
-  // does this create mem leak? CKB use new with placement?
   void AddTriggerPosition(const TArrayF & array)  { 
-    if(fTriggerPosition) delete fTriggerPosition;
-    fTriggerPosition =  new TArrayF(array);
+    if(fTriggerPosition) *fTriggerPosition = array;
+    else fTriggerPosition =  new TArrayF(array);
   }
 
   void AddTriggerAmplitudes(const TArrayF & array) { 
-    if(fTriggerAmplitudes)delete fTriggerAmplitudes;
-    fTriggerAmplitudes  = new TArrayF(array); 
+    if(fTriggerAmplitudes) *fTriggerAmplitudes = array;
+    else fTriggerAmplitudes  = new TArrayF(array); 
   }
   
   void Reset(); 
index 0de296e..9389fc8 100644 (file)
@@ -204,60 +204,60 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
   if(&source == this) return *this;
   AliVEvent::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);
-  fTPCVertex = new AliESDVertex(*source.fTPCVertex);
-  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);
-  fEMCALCells = new AliESDCaloCells(*source.fEMCALCells);
-  fPHOSCells = new AliESDCaloCells(*source.fPHOSCells);
-  fErrorLogs = new TClonesArray(*source.fErrorLogs);
-  fESDACORDE = new AliESDACORDE(*source.fESDACORDE);
-  fESDOld       = new AliESD(*source.fESDOld);
-  fESDFriendOld = new AliESDfriend(*source.fESDFriendOld);
-  // 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(fTPCVertex);
-  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(fEMCALCells);
-  AddObject(fPHOSCells);
-  AddObject(fErrorLogs);
-  AddObject(fESDACORDE);
+  // This assumes that the list is already created
+  // and that the virtual void Copy(Tobject&) function
+  // is correctly implemented in the derived class
+  // otherwise only TObject::Copy() will be used
+
+
+  if((fESDObjects->GetSize()==0)&&(source.fESDObjects->GetSize()>=kESDListN)){
+    // We cover the case that we do not yet have the 
+    // standard content but the source has it
+    CreateStdContent();
+  }
+
+  TIter next(source.GetList());
+  TObject *its = 0;
+  TString name;
+  while ((its = next())) {
+    name.Form("%s", its->GetName());
+    TObject *mine = fESDObjects->FindObject(name.Data());
+    if(!mine){
+      // not in this: can be added to list (to be implemented)
+      AliWarning(Form("%s:%d Could not find %s for copying \n",
+                     (char*)__FILE__,__LINE__,name.Data()));
+      continue;
+    }
+
+    if(!its->InheritsFrom("TCollection")){
+      // simple objects
+      its->Copy(*mine);
+    }
+    else if(its->InheritsFrom("TClonesArray")){
+      // Create or expand the tclonesarray pointers
+      // so we can directly copy to the object
+      TClonesArray *its_tca = (TClonesArray*)its;
+      TClonesArray *mine_tca = (TClonesArray*)mine;
+
+      // this leaves the capacity of the TClonesArray the same
+      // except for a factor of 2 increase when size > capacity
+      // does not release any memory occupied by the tca
+      mine_tca->ExpandCreate(its_tca->GetEntriesFast());
+      for(int i = 0;i < its_tca->GetEntriesFast();++i){
+       // copy 
+       TObject *mine_tca_obj = mine_tca->At(i);
+       TObject *its_tca_obj = its_tca->At(i);
+       // no need to delete first
+       // pointers within the class should be handled by Copy()...
+       // Can there be Empty slots?
+       its_tca_obj->Copy(*mine_tca_obj);
+      }
+    }
+    else{
+      AliWarning(Form("%s:%d cannot copy TCollection \n",
+                     (char*)__FILE__,__LINE__));
+    }
+  }
 
   fConnected = source.fConnected;
   fEMCALClusters = source.fEMCALClusters;
@@ -266,7 +266,6 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
   fFirstPHOSCluster = source.fFirstPHOSCluster;
 
 
-
   return *this;
 
 }
@@ -291,6 +290,19 @@ AliESDEvent::~AliESDEvent()
   
 }
 
+void AliESDEvent::Copy(TObject &obj) const {
+
+  // interface to TOBject::Copy
+  // Copies the content of this into obj!
+  // bascially obj = *this
+
+  if(this==&obj)return;
+  AliESDEvent *robj = dynamic_cast<AliESDEvent*>(&obj);
+  if(!robj)return; // not an AliESEvent
+  *robj = *this;
+  return;
+}
+
 //______________________________________________________________________________
 void AliESDEvent::Reset()
 {
@@ -1045,7 +1057,7 @@ const void AliESDEvent::WriteToTree(TTree* tree) const {
   while ((obj = next())) {
     branchname.Form("%s", obj->GetName());
     if ((kSplitlevel > 1) &&  !obj->InheritsFrom(TClonesArray::Class())) {
-      branchname += ".";
+      if(!branchname.EndsWith("."))branchname += ".";
     }
     tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),
                 kBufsize, kSplitlevel - 1);
@@ -1133,8 +1145,9 @@ void AliESDEvent::ReadFromTree(TTree *tree){
     return;
   }
   
-  delete fESDOld;
-  fESDOld = 0;
+
+    delete fESDOld;
+    fESDOld = 0;
   // Try to find AliESDEvent
   AliESDEvent *esdEvent = 0;
   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
@@ -1149,14 +1162,24 @@ void AliESDEvent::ReadFromTree(TTree *tree){
       fConnected = true;
       return;
     }
+
     // Connect to tree
     // prevent a memory leak when reading back the TList
     delete fESDObjects;
     fESDObjects = 0;
+
+
+
     // create a new TList from the UserInfo TList... 
     // copy constructor does not work...
+
     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
     fESDObjects->SetOwner(kFALSE);
+
+    // in principle
+    // we only need new things in the list if we do no already have it..
+    // TODO just add new entries
+
     if(fESDObjects->GetEntries()<kESDListN){
       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
             (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
@@ -1208,7 +1231,16 @@ void AliESDEvent::ReadFromTree(TTree *tree){
     TNamed *el;
     while((el=(TNamed*)next())){
       TString bname(el->GetName());    
-      tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+      TBranch *br = tree->GetBranch(bname.Data());
+      if(br){
+       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+      }
+      else{
+       br = tree->GetBranch(Form("%s.",bname.Data()));
+       if(br){
+         tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
+       }
+      }
     }
     GetStdContent();
     // when reading back we are not owner of the list 
index 56d0558..8bd1dea 100644 (file)
@@ -87,8 +87,9 @@ public:
   };
 
   AliESDEvent();
-  virtual ~AliESDEvent(); 
-
+  virtual ~AliESDEvent();
+  AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy? 
+  virtual void Copy(TObject& obj) const;
 
   // RUN
   // move this to the UserData!!!
@@ -119,7 +120,7 @@ public:
   void      SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
   void      SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
   void      SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
-  //  void      SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
+  //  void     SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
   void      SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
   void      SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
   
@@ -343,7 +344,6 @@ public:
 
 protected:
   AliESDEvent(const AliESDEvent&);
-  AliESDEvent &operator=(const AliESDEvent& source);
 
 
   TList *fESDObjects;             // List of esd Objects
index c7e367d..9709396 100755 (executable)
@@ -74,6 +74,17 @@ AliESDFMD::operator=(const AliESDFMD& other)
   return *this;
 }
 
+void AliESDFMD::Copy(TObject &obj) const{
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDFMD *robj = dynamic_cast<AliESDFMD*>(&obj);
+  if(!robj)return; // not an AliESDFMD
+  *robj = *this;
+}
+
 //____________________________________________________________________
 void
 AliESDFMD::CheckNeedUShort(TFile* file) 
index 3224fa6..564b206 100755 (executable)
@@ -41,6 +41,8 @@ public:
   AliESDFMD& operator=(const AliESDFMD& other);
   /** Destructor - does nothing */
   virtual ~AliESDFMD() {}
+  virtual void Copy(TObject &obj) const;
+
 
   void Clear(Option_t *option="");
   /** Get the pseudo-multiplicity of 
index 7428776..5141284 100644 (file)
@@ -86,6 +86,19 @@ AliESDHeader& AliESDHeader::operator=(const AliESDHeader &header)
   return *this;
 }
 
+void AliESDHeader::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDHeader *robj = dynamic_cast<AliESDHeader*>(&obj);
+  if(!robj)return; // not an AliESDHeader
+  *robj = *this;
+
+}
+
 
 
 //______________________________________________________________________________
index 8f1bbde..8fe8a63 100644 (file)
@@ -20,6 +20,7 @@ public:
   virtual ~AliESDHeader();
   AliESDHeader(const AliESDHeader& header);
   AliESDHeader& operator=(const AliESDHeader& header);
+  virtual void Copy(TObject &obj) const;
 
   void      SetTriggerMask(ULong64_t n) {fTriggerMask=n;}
   void      SetOrbitNumber(UInt_t n) {fOrbitNumber=n;}
index 90030f0..bef6fd5 100644 (file)
@@ -195,6 +195,20 @@ AliESDMuonTrack& AliESDMuonTrack::operator=(const AliESDMuonTrack& muonTrack)
   return *this;
 }
 
+void AliESDMuonTrack::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDMuonTrack *robj = dynamic_cast<AliESDMuonTrack*>(&obj);
+  if(!robj)return; // not an AliESDMuonTrack
+  *robj = *this;
+
+}
+
+
 //__________________________________________________________________________
 AliESDMuonTrack::~AliESDMuonTrack()
 {
index 00212ff..5daf864 100644 (file)
@@ -27,6 +27,7 @@ public:
   virtual ~AliESDMuonTrack(); // Destructor
   AliESDMuonTrack(const AliESDMuonTrack& esdm);
   AliESDMuonTrack& operator=(const AliESDMuonTrack& esdm);
+  virtual void Copy(TObject &obj) const;
 
   virtual void Clear(Option_t* opt = "");
   
index 9f50623..5a73035 100644 (file)
@@ -68,3 +68,15 @@ AliESDPmdTrack &AliESDPmdTrack::operator=(const AliESDPmdTrack& PMDTrack)
   fNcell  = PMDTrack.fNcell;
   return *this;
 }
+
+void AliESDPmdTrack::Copy(TObject& obj) const {
+
+   // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDPmdTrack *robj = dynamic_cast<AliESDPmdTrack*>(&obj);
+  if(!robj)return; // not an aliesesdpmdtrack
+  *robj = *this;
+}
index 2f41ca8..94d38ab 100644 (file)
@@ -18,6 +18,7 @@ class AliESDPmdTrack : public TObject {
   virtual ~AliESDPmdTrack(){;}
   AliESDPmdTrack (const AliESDPmdTrack &PMDTrack);  // copy constructor
   AliESDPmdTrack &operator=(const AliESDPmdTrack &PMDTrack); // assignment op
+  virtual void Copy(TObject &obj) const;
 
   void SetDetector(Int_t idet) {fDet = idet;}
   
index 707abb5..17027dd 100644 (file)
@@ -67,20 +67,34 @@ AliESDRun& AliESDRun::operator=(const AliESDRun &esd)
   if(this!=&esd) {
     TObject::operator=(esd);
     fRunNumber=esd.fRunNumber;
-    fPeriodNumber=esd.fPeriodNumber;
-    fRecoVersion=esd.fRecoVersion;
-    fMagneticField=esd.fMagneticField;
-    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];
-    fTriggerClasses.Clear();
-    for(Int_t i = 0; i < kNTriggerClasses; i++) {
-      TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
-      if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
-    }
+  fPeriodNumber=esd.fPeriodNumber;
+  fRecoVersion=esd.fRecoVersion;
+  fMagneticField=esd.fMagneticField;
+  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];
+  fTriggerClasses.Clear();
+  for(Int_t i = 0; i < kNTriggerClasses; i++) {
+    TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
+    if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
+  }
+    
   } 
   return *this;
 }
 
+void AliESDRun::Copy(TObject &obj) const{
+
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDRun *robj = dynamic_cast<AliESDRun*>(&obj);
+  if(!robj)return; // not an aliesdrun
+  *robj = *this;
+
+}
+
 void AliESDRun::SetDiamond(const AliESDVertex *vertex) {
   // set the interaction diamond
   fDiamondXY[0]=vertex->GetXv();
index a73f09f..0692b8f 100644 (file)
@@ -23,7 +23,7 @@ public:
   AliESDRun();
   AliESDRun(const AliESDRun& esd);
   AliESDRun& operator=(const AliESDRun& esd);
-
+  virtual void Copy(TObject &obj) const; // Interface for using TOBject::Copy()
 
   Int_t   GetRunNumber() const {return fRunNumber;}
   void    SetRunNumber(Int_t n) {fRunNumber=n;}
index baf6e38..45f7d33 100644 (file)
@@ -61,6 +61,20 @@ AliESDTZERO& AliESDTZERO::operator=(const AliESDTZERO& tzero){
   return *this;
 }
 
+void AliESDTZERO::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDTZERO *robj = dynamic_cast<AliESDTZERO*>(&obj);
+  if(!robj)return; // not an AliESDTZERO
+  *robj = *this;
+
+}
+
+
 //______________________________________________________________________________
 void AliESDTZERO::Reset()
 {
index 55bad43..f50c699 100644 (file)
@@ -21,6 +21,7 @@ public:
   AliESDTZERO();
   AliESDTZERO(const AliESDTZERO& tzero);
   AliESDTZERO& operator=(const AliESDTZERO& tzero);
+  virtual void Copy(TObject &obj) const;
 
   Double_t GetT0zVertex() const {return fT0zVertex;}
   void SetT0zVertex(Double_t z) {fT0zVertex=z;}
index 2c5a60d..365368c 100644 (file)
@@ -100,3 +100,14 @@ AliESDTrdTrack& AliESDTrdTrack::operator=(const AliESDTrdTrack& track)
 
 }
 
+void AliESDTrdTrack::Copy(TObject& obj) const {
+
+   // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDTrdTrack *robj = dynamic_cast<AliESDTrdTrack*>(&obj);
+  if(!robj)return; // not an aliesesdtrdtrack
+  *robj = *this;
+}
index 1d7be7b..23c7e08 100644 (file)
@@ -15,6 +15,7 @@ class AliESDTrdTrack : public TObject {
   virtual ~AliESDTrdTrack(){};
   AliESDTrdTrack(const AliESDTrdTrack& track);
   AliESDTrdTrack& operator=(const AliESDTrdTrack& track);
+  virtual void Copy(TObject &obj) const;
 
   Double_t GetYproj()     const { return fYproj; };
   Double_t GetZproj()     const { return fZproj; };
index 769da3d..be9422e 100644 (file)
@@ -62,3 +62,18 @@ AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
   return *this;
 }
 
+
+void AliESDVZERO::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDVZERO *robj = dynamic_cast<AliESDVZERO*>(&obj);
+  if(!robj)return; // not an AliESDVZERO
+  *robj = *this;
+
+}
+
+
index 42a4169..932ccf3 100644 (file)
@@ -11,6 +11,9 @@ public:
   AliESDVZERO(Int_t NbPMV0A, Int_t NbPMV0C, Int_t MTotV0A, Int_t MTotV0C, 
               Int_t *MRingV0A, Int_t *MRingV0C);
   virtual ~AliESDVZERO() {};
+  AliESDVZERO &operator=(const AliESDVZERO& source);
+  virtual void Copy(TObject &obj) const;
+
   
 // Setters
   virtual void  SetNbPMV0A(Int_t NbPMV0A)  {fNbPMV0A = NbPMV0A;}
@@ -30,7 +33,7 @@ public:
   Int_t* GetMRingV0A() const {return (int*) fMRingV0A;}
   Int_t* GetMRingV0C() const {return (int*) fMRingV0C;}
 
-  AliESDVZERO &operator=(const AliESDVZERO& source);
+  
     
 protected:
   Int_t fMTotV0A;     // Total multiplicity in V0A
index a2a320b..bc65501 100644 (file)
@@ -174,6 +174,21 @@ AliESDVertex &AliESDVertex::operator=(const AliESDVertex &source){
   }
   return *this;
 }
+
+void AliESDVertex::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDVertex *robj = dynamic_cast<AliESDVertex*>(&obj);
+  if(!robj)return; // not an AliESDVertex
+  *robj = *this;
+
+}
+
+
 //--------------------------------------------------------------------------
 void AliESDVertex::SetToZero() {
   //
index 4f764b7..f29b8fc 100644 (file)
@@ -46,6 +46,7 @@ class AliESDVertex : public AliVertex {
               const Char_t *vtxName="Vertex");
   AliESDVertex(const AliESDVertex &source);
   AliESDVertex &operator=(const AliESDVertex &source);
+  virtual void Copy(TObject &obj) const;
 
   virtual ~AliESDVertex() {}
 
index 9ad1ac0..3d7cd62 100644 (file)
@@ -97,6 +97,19 @@ AliESDZDC& AliESDZDC::operator=(const AliESDZDC&zdc)
   return *this;
 }
 
+void AliESDZDC::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDZDC *robj = dynamic_cast<AliESDZDC*>(&obj);
+  if(!robj)return; // not an AliESDZDC
+  *robj = *this;
+
+}
+
 
 //______________________________________________________________________________
 void AliESDZDC::Reset()
index bedd2ad..b52d21d 100644 (file)
@@ -20,6 +20,7 @@ public:
   AliESDZDC();
   AliESDZDC(const AliESDZDC& zdc);
   AliESDZDC& operator=(const AliESDZDC& zdc);
+  virtual void Copy(TObject &obj) const;
 
   Double_t GetZDCN1Energy() const {return fZDCN1Energy;}
   Double_t GetZDCP1Energy() const {return fZDCP1Energy;}
index a0f325b..5e96cb1 100644 (file)
@@ -152,6 +152,44 @@ AliESDcascade::AliESDcascade(const AliESDcascade& cas) :
   }
 }
 
+AliESDcascade& AliESDcascade::operator=(const AliESDcascade& cas){
+
+  // -------
+  // Assigmnet oeprator
+  // -----
+
+  if(this==&cas) return *this;
+  AliESDv0::operator=(cas);
+
+  fEffMassXi = cas.fEffMassXi;
+  fChi2Xi    = cas.fChi2Xi;
+  fDcaXiDaughters = cas.fDcaXiDaughters;
+  fPdgCodeXi      = cas.fPdgCodeXi;
+  fBachIdx        = cas.fBachIdx;
+  for (int i=0; i<3; i++) {
+    fPosXi[i]     = cas.fPosXi[i];
+    fBachMom[i]   = cas.fBachMom[i];
+  }
+  for (int i=0; i<6; i++) {
+    fPosCovXi[i]   = cas.fPosCovXi[i];
+    fBachMomCov[i] = cas.fBachMomCov[i];
+  }
+  return *this;
+}
+
+void AliESDcascade::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDcascade *robj = dynamic_cast<AliESDcascade*>(&obj);
+  if(!robj)return; // not an AliESDcascade
+  *robj = *this;
+
+}
+
 Double_t AliESDcascade::ChangeMassHypothesis(Double_t &v0q, Int_t code) {
   //--------------------------------------------------------------------
   // This function changes the mass hypothesis for this cascade
index b16b83f..b3755d9 100644 (file)
@@ -32,6 +32,8 @@ public:
   AliESDcascade(const AliESDv0 &v0,
                 const AliExternalTrackParam &t, Int_t i);
   ~AliESDcascade();
+  AliESDcascade& operator=(const AliESDcascade&);
+  virtual void Copy(TObject &obj) const;
 
   Double_t ChangeMassHypothesis(Double_t &v0q, Int_t code=kXiMinus); 
 
@@ -69,7 +71,7 @@ protected:
 
 
 private:
-  AliESDcascade& operator=(const AliESDcascade&);
+
 
   ClassDef(AliESDcascade,5) // reconstructed cascade vertex
 };
index 8c7d0e6..a1fe5e8 100644 (file)
@@ -130,6 +130,20 @@ AliESDkink& AliESDkink::operator=(const AliESDkink &source)
   return *this;
 }
 
+void AliESDkink::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDkink *robj = dynamic_cast<AliESDkink*>(&obj);
+  if(!robj)return; // not an AliESDkink
+  *robj = *this;
+
+}
+
+
 void AliESDkink::SetMother(const AliExternalTrackParam & pmother)  {
   //
   // set mother
index 217369f..300210a 100644 (file)
@@ -23,6 +23,7 @@ public:
   AliESDkink();             //constructor
   AliESDkink(const AliESDkink &source);             //constructor
   AliESDkink& operator=(const AliESDkink &source);
+  virtual void Copy(TObject &obj) const;
   //
   void SetID(Short_t id){fID=id;}
   Short_t GetID(){return fID;}
index 6b7cfc6..2c0644a 100644 (file)
@@ -420,6 +420,185 @@ AliESDtrack::~AliESDtrack(){
   delete fFriendTrack;
 }
 
+AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
+  
+
+  if(&source == this) return *this;
+  AliExternalTrackParam::operator=(source);
+
+  
+  if(source.fCp){
+    // we have the trackparam: assign or copy construct
+    if(fCp)*fCp = *source.fCp;
+    else fCp = new AliExternalTrackParam(*source.fCp);
+  }
+  else{
+    // no track param delete the old one
+    if(fCp)delete fCp;
+    fCp = 0;
+  }
+
+  if(source.fIp){
+    // we have the trackparam: assign or copy construct
+    if(fIp)*fIp = *source.fIp;
+    else fIp = new AliExternalTrackParam(*source.fIp);
+  }
+  else{
+    // no track param delete the old one
+    if(fIp)delete fIp;
+    fIp = 0;
+  }
+
+
+  if(source.fTPCInner){
+    // we have the trackparam: assign or copy construct
+    if(fTPCInner) *fTPCInner = *source.fTPCInner;
+    else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
+  }
+  else{
+    // no track param delete the old one
+    if(fTPCInner)delete fTPCInner;
+    fTPCInner = 0;
+  }
+
+
+  if(source.fOp){
+    // we have the trackparam: assign or copy construct
+    if(fOp) *fOp = *source.fOp;
+    else fOp = new AliExternalTrackParam(*source.fOp);
+  }
+  else{
+    // no track param delete the old one
+    if(fOp)delete fOp;
+    fOp = 0;
+  }
+
+  // copy also the friend track 
+  // use copy constructor
+  if(source.fFriendTrack){
+    // we have the trackparam: assign or copy construct
+    delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
+  }
+  else{
+    // no track param delete the old one
+    delete fFriendTrack; fFriendTrack= 0;
+  }
+
+  fTPCClusterMap = source.fTPCClusterMap; 
+  fTPCSharedMap  = source.fTPCSharedMap;  
+  // the simple stuff
+  fFlags    = source.fFlags; 
+  fID       = source.fID;             
+  fLabel    = source.fLabel;
+  fITSLabel = source.fITSLabel;
+  for(int i = 0; i< 12;++i){
+    fITSModule[i] = source.fITSModule[i];
+  }
+  fTPCLabel = source.fTPCLabel; 
+  fTRDLabel = source.fTRDLabel;
+  for(int i = 0; i< 3;++i){
+    fTOFLabel[i] = source.fTOFLabel[i];    
+  }
+  fTOFCalChannel = source.fTOFCalChannel;
+  fTOFindex      = source.fTOFindex;
+  fHMPIDqn       = source.fHMPIDqn;
+  fHMPIDcluIdx   = source.fHMPIDcluIdx; 
+  fEMCALindex    = source.fEMCALindex;
+
+  for(int i = 0; i< 3;++i){
+    fKinkIndexes[i] = source.fKinkIndexes[i]; 
+    fV0Indexes[i]   = source.fV0Indexes[i]; 
+  }
+
+  for(int i = 0; i< AliPID::kSPECIES;++i){
+    fR[i]     = source.fR[i];
+    fITSr[i]  = source.fITSr[i];
+    fTPCr[i]  = source.fTPCr[i];
+    fTRDr[i]  = source.fTRDr[i];
+    fTOFr[i]  = source.fTOFr[i];
+    fHMPIDr[i] = source.fHMPIDr[i];
+    fTrackTime[i] = source.fTrackTime[i];  
+  }
+
+  fHMPIDtrkTheta = source.fHMPIDtrkTheta;
+  fHMPIDtrkPhi   = source.fHMPIDtrkPhi;
+  fHMPIDsignal   = source.fHMPIDsignal; 
+
+  
+  fTrackLength   = source. fTrackLength;
+  fD  = source.fD; 
+  fZ  = source.fZ; 
+  fCdd = source.fCdd;
+  fCdz = source.fCdz;
+  fCzz = source.fCzz;
+
+  fCchi2     = source.fCchi2;
+  fITSchi2   = source.fITSchi2;             
+  fTPCchi2   = source.fTPCchi2;            
+  fTRDchi2   = source.fTRDchi2;      
+  fTOFchi2   = source.fTOFchi2;      
+  fHMPIDchi2 = source.fHMPIDchi2;      
+
+
+  fITSsignal  = source.fITSsignal;     
+  fTPCsignal  = source.fTPCsignal;     
+  fTPCsignalS = source.fTPCsignalS;    
+  for(int i = 0; i< 4;++i){
+    fTPCPoints[i] = source.fTPCPoints[i];  
+  }
+  fTRDsignal = source.fTRDsignal;
+
+  for(int i = 0;i < kNPlane;++i){
+    fTRDTimBin[i] = source.fTRDTimBin[i];   
+    for(int j = 0;j < kNSlice;++j){
+      fTRDsignals[i][j] = source.fTRDsignals[i][j];
+    }
+  }
+  fTRDQuality =   source.fTRDQuality;     
+  fTRDBudget  =   source.fTRDBudget;      
+  fTOFsignal  =   source.fTOFsignal;     
+  fTOFsignalToT = source.fTOFsignalToT;   
+  fTOFsignalRaw = source.fTOFsignalRaw;  
+  fTOFsignalDz  = source.fTOFsignalDz;      
+  
+  for(int i = 0;i<10;++i){
+    fTOFInfo[i] = source.fTOFInfo[i];    
+  }
+
+  fHMPIDtrkX = source.fHMPIDtrkX; 
+  fHMPIDtrkY = source.fHMPIDtrkY; 
+  fHMPIDmipX = source.fHMPIDmipX;
+  fHMPIDmipY = source.fHMPIDmipY; 
+
+  fTPCncls    = source.fTPCncls;      
+  fTPCnclsF   = source.fTPCnclsF;     
+  fTPCsignalN = source.fTPCsignalN;   
+
+  fITSncls = source.fITSncls;       
+  fITSClusterMap = source.fITSClusterMap; 
+  fTRDncls   = source.fTRDncls;       
+  fTRDncls0  = source.fTRDncls0;      
+  fTRDpidQuality  = source.fTRDpidQuality; 
+  return *this;
+}
+
+
+
+void AliESDtrack::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
+  if(!robj)return; // not an AliESDtrack
+  *robj = *this;
+
+}
+
+
+
 void AliESDtrack::AddCalibObject(TObject * object){
   //
   // add calib object to the list
index f3c9618..4f68c21 100644 (file)
@@ -40,10 +40,10 @@ public:
   AliESDtrack(const AliESDtrack& track);
   AliESDtrack(TParticle * part);
   virtual ~AliESDtrack();
+  virtual void Copy(TObject &obj) const;
   const AliESDfriendTrack *GetFriendTrack() const {return fFriendTrack;}
   void SetFriendTrack(const AliESDfriendTrack *t) {
     delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*t);
-    // CKB
   }
   void ReleaseESDfriendTrack() { delete fFriendTrack;  fFriendTrack=0; }
   void AddCalibObject(TObject * object);     // add calib object to the list
@@ -383,7 +383,7 @@ protected:
 
  private:
 
-  AliESDtrack & operator=(const AliESDtrack & ) {return *this;}
+  AliESDtrack & operator=(const AliESDtrack & );
 
   ClassDef(AliESDtrack,42)  //ESDtrack 
 };
index eba32ce..62b6c67 100644 (file)
@@ -129,6 +129,7 @@ AliESDv0::AliESDv0(const AliESDv0& v0) :
   for (Int_t i=0;i<4;i++){fCausality[i]=v0.fCausality[i];}
 }
 
+
 AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
                    const AliExternalTrackParam &t2, Int_t i2) :
   TObject(),
@@ -194,6 +195,71 @@ AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
   for (Int_t i=0;i<4;i++){fCausality[i]=0;}
 }
 
+AliESDv0& AliESDv0::operator=(const AliESDv0 &v0){
+
+
+  //--------------------------------------------------------------------
+  // The assingment operator
+  //--------------------------------------------------------------------
+
+  if(this==&v0)return *this;
+  TObject::operator=(v0);
+  fParamN  = v0.fParamN;
+  fParamP  = v0.fParamP;
+  fEffMass = v0.fEffMass;
+  fDcaV0Daughters = v0.fDcaV0Daughters;
+  fChi2V0 = v0.fChi2V0;
+  fRr = v0.fRr;
+  fDistSigma    = v0.fDistSigma;
+  fChi2Before   = v0.fChi2Before;
+  fChi2After    = v0.fChi2After;
+  fPointAngleFi = v0.fPointAngleFi;
+  fPointAngleTh = v0.fPointAngleTh;
+  fPointAngle   = v0.fPointAngle;
+  fPdgCode      = v0.fPdgCode;
+  fNidx         = v0.fNidx;
+  fPidx         = v0.fPidx;
+  fStatus       = v0.fStatus;
+  fNBefore      = v0.fNBefore;
+  fNAfter       = v0.fNAfter;
+  fOnFlyStatus  = v0.fOnFlyStatus;
+
+  for (int i=0; i<3; i++) {
+    fPos[i]  = v0.fPos[i];
+    fNmom[i] = v0.fNmom[i];
+    fPmom[i] = v0.fPmom[i];
+  }
+  for (int i=0; i<6; i++) {
+    fPosCov[i]  = v0.fPosCov[i];
+  }
+  for (Int_t i=0; i<2; i++) {
+    fNormDCAPrim[i]=v0.fNormDCAPrim[i];
+  }
+  for (Int_t i=0;i<6;i++){
+      fClusters[0][i]=v0.fClusters[0][i]; 
+      fClusters[1][i]=v0.fClusters[1][i];
+  }
+  for (Int_t i=0;i<3;i++){
+      fAngle[i]=v0.fAngle[i];
+  }
+  for (Int_t i=0;i<4;i++){fCausality[i]=v0.fCausality[i];}
+
+  return *this;
+}
+
+void AliESDv0::Copy(TObject& obj) const {
+
+   // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliESDv0 *robj = dynamic_cast<AliESDv0*>(&obj);
+  if(!robj)return; // not an aliesesv0
+  *robj = *this;
+}
+
+
 AliESDv0::~AliESDv0(){
   //--------------------------------------------------------------------
   // Empty destructor
index 8da2738..0ae196d 100644 (file)
@@ -27,6 +27,8 @@ public:
 
   AliESDv0(const AliESDv0&);
   virtual ~AliESDv0();
+  AliESDv0& operator=(const AliESDv0&);
+  virtual void Copy(TObject &obj) const;
 
   Double_t ChangeMassHypothesis(Int_t code=kK0Short); 
 
@@ -141,7 +143,6 @@ protected:
   static const AliESDV0Params fgkParams;  //! resolution and likelihood parameterization  
 
 private:
-  AliESDv0& operator=(const AliESDv0&);
 
   ClassDef(AliESDv0,4)      // ESD V0 vertex
 };
index 960968a..d3332f8 100644 (file)
@@ -96,6 +96,20 @@ AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
   return *this;
 }
 
+void AliMultiplicity::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliMultiplicity *robj = dynamic_cast<AliMultiplicity*>(&obj);
+  if(!robj)return; // not an AliMultiplicity
+  *robj = *this;
+
+}
+
+
 //______________________________________________________________________
 void AliMultiplicity::Duplicate(const AliMultiplicity& m){
   // used by copy constructor and assignment operator
index 4cef32d..9c5a3cc 100644 (file)
@@ -19,6 +19,7 @@ class AliMultiplicity : public TObject {
                   Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps);
   AliMultiplicity(const AliMultiplicity& m);
   AliMultiplicity& operator=(const AliMultiplicity& m);
+  virtual void Copy(TObject &obj) const;
   virtual ~AliMultiplicity();
 // methods to access tracklet information
   Int_t GetNumberOfTracklets() const {return fNtracks;}
index a3a65db..83b72cf 100644 (file)
@@ -91,6 +91,19 @@ AliRawDataErrorLog & AliRawDataErrorLog::operator=(const AliRawDataErrorLog &sou
   return *this;
 }
 
+void AliRawDataErrorLog::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliRawDataErrorLog *robj = dynamic_cast<AliRawDataErrorLog*>(&obj);
+  if(!robj)return; // not an AliRawDataErrorLog
+  *robj = *this;
+
+}
+
 //_____________________________________________________________________________
 Int_t AliRawDataErrorLog::Compare(const TObject *obj) const
 {
index 7c6b9be..32f7c97 100644 (file)
@@ -38,7 +38,8 @@ class AliRawDataErrorLog: public TNamed {
   AliRawDataErrorLog(const AliRawDataErrorLog & source);
   AliRawDataErrorLog & operator=(const AliRawDataErrorLog & source);
   virtual ~AliRawDataErrorLog() {};
-
+  virtual void Copy(TObject &obj) const;
+  
   Int_t              GetEventNumber() const { return fEventNumber; }
   Int_t              GetDdlID()       const { return fDdlID; }
   ERawDataErrorLevel GetErrorLevel()  const { return fErrorLevel; }