[u/mrichter/AliRoot.git] / STEER / AliESD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           Implementation of the ESD class
//   This is the class to deal with during the phisical analysis of data
//   This class is generated directly by the reconstruction methods
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "TList.h"
#include <TNamed.h>

#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),
  fEMCALClusters(0), 
  fFirstEMCALCluster(-1),
  fPHOSClusters(0), 
  fFirstPHOSCluster(-1)
{
}
//______________________________________________________________________________
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)),
  fEMCALClusters(esd.fEMCALClusters), 
  fFirstEMCALCluster(esd.fFirstEMCALCluster),
  fPHOSClusters(esd.fPHOSClusters), 
  fFirstPHOSCluster(esd.fFirstPHOSCluster)

{
  // 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;

}


//______________________________________________________________________________
AliESD::~AliESD()
{
  //
  // Standard destructor
  //

  delete fESDObjects;
  fESDObjects = 0;

  // everthing on the list gets deleted automatically

  /*
  fHLTConfMapTracks.Delete();
  fHLTHoughTracks.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;

}

//______________________________________________________________________________
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();


  fEMCALClusters=0; 
  fFirstEMCALCluster=-1; 
  fPHOSClusters=0; 
  fFirstPHOSCluster=-1; 
}

Int_t AliESD::AddV0(const AliESDv0 *v) {
  //
  // Add V0
  //
  TClonesArray &fv = *fV0s;
  Int_t idx=fV0s->GetEntriesFast();
  new(fv[idx]) AliESDv0(*v);
  return idx;
}  

//______________________________________________________________________________
void AliESD::Print(Option_t *) const 
{
  //
  // Print header information of the event
  //
  printf("ESD run information\n");
  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
	 GetEventNumberInFile(),
	 GetBunchCrossNumber(),
	 GetOrbitNumber(),
	 GetPeriodNumber(),
	 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("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
	   GetDiamondX(),GetDiamondY());
    printf("SPD Multiplicity. Number of tracklets %d \n",
           fSPDMult->GetNumberOfTracklets());
  printf("Number of tracks: \n");
  printf("                 charged   %d\n", GetNumberOfTracks());
  printf("                 muon      %d\n", GetNumberOfMuonTracks());
  printf("                 pmd       %d\n", GetNumberOfPmdTracks());
  printf("                 trd       %d\n", GetNumberOfTrdTracks());
  printf("                 v0        %d\n", GetNumberOfV0s());
  printf("                 cascades  %d\n", GetNumberOfCascades());
  printf("                 kinks     %d\n", GetNumberOfKinks());
  printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
  printf("                 phos      %d\n", GetNumberOfPHOSClusters());
  printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
  printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
}

void AliESD::SetESDfriend(const AliESDfriend *ev) {
  //
  // Attaches the complementary info to the ESD
  //
  if (!ev) return;

  Int_t ntrk=ev->GetNumberOfTracks();
 
  for (Int_t i=0; i<ntrk; i++) {
    const AliESDfriendTrack *f=ev->GetTrack(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
  //
  if (!ev) return;

  Int_t ntrk=GetNumberOfTracks();

  for (Int_t i=0; i<ntrk; i++) {
    const AliESDtrack *t=GetTrack(i);
    const AliESDfriendTrack *f=t->GetFriendTrack();
    ev->AddTrack(f);
  }
}


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() 
{
  // 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()<kESDListN){
    printf("%s %d AliESD::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->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));
    }
  }

  GetStdContent();
}
Commit	Line	Data
8a8d023f	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
acd84897	16	/* $Id$ */
8a8d023f	17
ae982df3	18	//-----------------------------------------------------------------
	19	// Implementation of the ESD class
	20	// This is the class to deal with during the phisical analysis of data
af7ba10c	21	// This class is generated directly by the reconstruction methods
ae982df3	22	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
ae982df3	23	//-----------------------------------------------------------------
8a8d023f	24
b545009a	25	#include "TList.h"
b545009a	26	#include <TNamed.h>
53203d32	27
b545009a	28	#include "AliESD.h"
	29	#include "AliESDfriend.h"
	30	#include "AliESDVZERO.h"
	31	#include "AliESDHLTtrack.h"
	32	#include "AliESDFMD.h"
53203d32	33
	34
	35	ClassImp(AliESD)
	36
	37	//______________________________________________________________________________
	38	AliESD::AliESD():
	39	fESDObjects(new TList()),
	40	fESDRun(0),
	41	fHeader(0),
	42	fESDZDC(0),
	43	fESDFMD(0),
	44	fESDVZERO(0),
	45	fESDTZERO(0),
	46	fSPDVertex(0),
	47	fPrimaryVertex(0),
	48	fSPDMult(0),
	49	fPHOSTrigger(0),
	50	fEMCALTrigger(0),
	51	fTracks(0),
	52	fMuonTracks(0),
	53	fPmdTracks(0),
	54	fTrdTracks(0),
	55	fV0s(0),
	56	fCascades(0),
	57	fKinks(0),
	58	fCaloClusters(0),
	59	fErrorLogs(0),
85c60a8e	60	fEMCALClusters(0),
	61	fFirstEMCALCluster(-1),
	62	fPHOSClusters(0),
53203d32	63	fFirstPHOSCluster(-1)
9da38871	64	{
873f1f73	65	}
c028b974	66	//______________________________________________________________________________
	67	AliESD::AliESD(const AliESD& esd):
	68	TObject(esd),
53203d32	69	fESDObjects(new TList()),
	70	fESDRun(new AliESDRun(*esd.fESDRun)),
	71	fHeader(new AliESDHeader(*esd.fHeader)),
	72	fESDZDC(new AliESDZDC(*esd.fESDZDC)),
	73	fESDFMD(new AliESDFMD(*esd.fESDFMD)),
	74	fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
	75	fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
	76	fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
	77	fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
	78	fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
	79	fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
	80	fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
	81	fTracks(new TClonesArray(*esd.fTracks)),
	82	fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
	83	fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
	84	fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
	85	fV0s(new TClonesArray(*esd.fV0s)),
	86	fCascades(new TClonesArray(*esd.fCascades)),
	87	fKinks(new TClonesArray(*esd.fKinks)),
	88	fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
	89	fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
c028b974	90	fEMCALClusters(esd.fEMCALClusters),
	91	fFirstEMCALCluster(esd.fFirstEMCALCluster),
	92	fPHOSClusters(esd.fPHOSClusters),
53203d32	93	fFirstPHOSCluster(esd.fFirstPHOSCluster)
53203d32	94
c028b974	95	{
53203d32	96	// CKB init in the constructor list and only add here ...
	97	AddObject(fESDRun);
	98	AddObject(fHeader);
	99	AddObject(fESDZDC);
	100	AddObject(fESDFMD);
	101	AddObject(fESDVZERO);
	102	AddObject(fESDTZERO);
	103	AddObject(fSPDVertex);
	104	AddObject(fPrimaryVertex);
	105	AddObject(fSPDMult);
	106	AddObject(fPHOSTrigger);
	107	AddObject(fEMCALTrigger);
	108	AddObject(fTracks);
	109	AddObject(fMuonTracks);
	110	AddObject(fPmdTracks);
	111	AddObject(fTrdTracks);
	112	AddObject(fV0s);
	113	AddObject(fCascades);
	114	AddObject(fKinks);
	115	AddObject(fCaloClusters);
	116	AddObject(fErrorLogs);
	117
	118	GetStdContent();
	119
c028b974	120	}
c028b974	121
fe12e09c	122	//______________________________________________________________________________
	123	AliESD & AliESD::operator=(const AliESD& source) {
	124
	125	// Assignment operator
	126
	127	if(&source == this) return *this;
53203d32	128	TObject::operator=(source);
	129
	130	fESDRun = new AliESDRun(*source.fESDRun);
	131	fHeader = new AliESDHeader(*source.fHeader);
	132	fESDZDC = new AliESDZDC(*source.fESDZDC);
	133	fESDFMD = new AliESDFMD(*source.fESDFMD);
	134	fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
	135	fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
	136	fSPDVertex = new AliESDVertex(*source.fSPDVertex);
	137	fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
	138	fSPDMult = new AliMultiplicity(*source.fSPDMult);
	139	fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
	140	fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
	141	fTracks = new TClonesArray(*source.fTracks);
	142	fMuonTracks = new TClonesArray(*source.fMuonTracks);
	143	fPmdTracks = new TClonesArray(*source.fPmdTracks);
	144	fTrdTracks = new TClonesArray(*source.fTrdTracks);
	145	fV0s = new TClonesArray(*source.fV0s);
	146	fCascades = new TClonesArray(*source.fCascades);
	147	fKinks = new TClonesArray(*source.fKinks);
	148	fCaloClusters = new TClonesArray(*source.fCaloClusters);
	149	fErrorLogs = new TClonesArray(*source.fErrorLogs);
	150
	151	// CKB this way?? or
	152	// or AddObject( fESDZDC = new AliESDZDC(*source.fESDZDC));
	153
	154	fESDObjects = new TList();
	155	AddObject(fESDRun);
	156	AddObject(fHeader);
	157	AddObject(fESDZDC);
	158	AddObject(fESDFMD);
	159	AddObject(fESDVZERO);
	160	AddObject(fESDTZERO);
	161	AddObject(fSPDVertex);
	162	AddObject(fPrimaryVertex);
	163	AddObject(fSPDMult);
	164	AddObject(fPHOSTrigger);
	165	AddObject(fEMCALTrigger);
	166	AddObject(fTracks);
	167	AddObject(fMuonTracks);
	168	AddObject(fPmdTracks);
	169	AddObject(fTrdTracks);
	170	AddObject(fV0s);
	171	AddObject(fCascades);
	172	AddObject(fKinks);
	173	AddObject(fCaloClusters);
	174	AddObject(fErrorLogs);
	175
fe12e09c	176
fe12e09c	177	fEMCALClusters = source.fEMCALClusters;
	178	fFirstEMCALCluster = source.fFirstEMCALCluster;
	179	fPHOSClusters = source.fPHOSClusters;
	180	fFirstPHOSCluster = source.fFirstPHOSCluster;
53203d32	181
53203d32	182
fe12e09c	183
	184	return *this;
	185
	186	}
	187
e2afb3b6	188
af7ba10c	189	//______________________________________________________________________________
	190	AliESD::~AliESD()
	191	{
	192	//
	193	// Standard destructor
	194	//
53203d32	195
	196	delete fESDObjects;
	197	fESDObjects = 0;
	198
	199	// everthing on the list gets deleted automatically
	200
	201	/*
8bbc564d	202	fHLTConfMapTracks.Delete();
8bbc564d	203	fHLTHoughTracks.Delete();
53203d32	204	fMuonTracks.Delete();
af7ba10c	205	fPmdTracks.Delete();
0ee00e25	206	fTrdTracks.Delete();
af7ba10c	207	fV0s.Delete();
af7ba10c	208	fCascades.Delete();
51ad6848	209	fKinks.Delete();
85c60a8e	210	fCaloClusters.Delete();
53203d32	211	*/
64df000d	212	// fEMCALTriggerPosition->Delete();
	213	// fEMCALTriggerAmplitudes->Delete();
	214	// fPHOSTriggerPosition->Delete();
	215	// fPHOSTriggerAmplitudes->Delete();
	216	// delete fEMCALTriggerPosition;
	217	// delete fEMCALTriggerAmplitudes;
	218	// delete fPHOSTriggerPosition;
	219	// delete fPHOSTriggerAmplitudes;
	220
51ad6848	221	}
51ad6848	222
bf25155c	223	//______________________________________________________________________________
	224	void AliESD::Reset()
	225	{
b545009a	226	// Reset the standard contents
53203d32	227	if(fESDRun) fESDRun->Reset();
	228	if(fHeader) fHeader->Reset();
	229	if(fESDZDC) fESDZDC->Reset();
	230	if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
	231	// if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
	232	// if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
	233	if(fESDTZERO) fESDTZERO->Reset();
	234	// CKB no clear/reset implemented
	235	if(fSPDVertex){
	236	new (fSPDVertex) AliESDVertex();
	237	fSPDVertex->SetName("SPDVertex");
	238	}
	239	if(fPrimaryVertex){
	240	new (fPrimaryVertex) AliESDVertex();
	241	fPrimaryVertex->SetName("PrimaryVertex");
	242	}
	243	if(fSPDMult)new (fSPDMult) AliMultiplicity();
	244	if(fPHOSTrigger)fPHOSTrigger->Reset();
	245	if(fEMCALTrigger)fEMCALTrigger->Reset();
	246	if(fTracks)fTracks->Clear();
	247	if(fMuonTracks)fMuonTracks->Clear();
	248	if(fPmdTracks)fPmdTracks->Clear();
	249	if(fTrdTracks)fTrdTracks->Clear();
	250	if(fV0s)fV0s->Clear();
	251	if(fCascades)fCascades->Clear();
	252	if(fKinks)fKinks->Clear();
	253	if(fCaloClusters)fCaloClusters->Clear();
	254	if(fErrorLogs) fErrorLogs->Clear();
	255
	256
85c60a8e	257	fEMCALClusters=0;
	258	fFirstEMCALCluster=-1;
	259	fPHOSClusters=0;
	260	fFirstPHOSCluster=-1;
bf25155c	261	}
af7ba10c	262
d6a49f20	263	Int_t AliESD::AddV0(const AliESDv0 *v) {
	264	//
	265	// Add V0
	266	//
53203d32	267	TClonesArray &fv = *fV0s;
	268	Int_t idx=fV0s->GetEntriesFast();
	269	new(fv[idx]) AliESDv0(*v);
	270	return idx;
d6a49f20	271	}
d6a49f20	272
af7ba10c	273	//______________________________________________________________________________
	274	void AliESD::Print(Option_t *) const
	275	{
	276	//
	277	// Print header information of the event
	278	//
5f7789fc	279	printf("ESD run information\n");
4d422cad	280	printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
31fd97b2	281	GetEventNumberInFile(),
	282	GetBunchCrossNumber(),
	283	GetOrbitNumber(),
4d422cad	284	GetPeriodNumber(),
ef278eae	285	GetRunNumber(),
b647652d	286	GetTriggerMask(),
ef278eae	287	GetMagneticField() );
53203d32	288	printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
	289	fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
	290	fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
	291	fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
9f57c1aa	292	printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
9f57c1aa	293	GetDiamondX(),GetDiamondY());
32e449be	294	printf("SPD Multiplicity. Number of tracklets %d \n",
53203d32	295	fSPDMult->GetNumberOfTracklets());
ef278eae	296	printf("Number of tracks: \n");
85c60a8e	297	printf(" charged %d\n", GetNumberOfTracks());
ef278eae	298	printf(" muon %d\n", GetNumberOfMuonTracks());
a2882fb4	299	printf(" pmd %d\n", GetNumberOfPmdTracks());
0ee00e25	300	printf(" trd %d\n", GetNumberOfTrdTracks());
ef278eae	301	printf(" v0 %d\n", GetNumberOfV0s());
667ee8bf	302	printf(" cascades %d\n", GetNumberOfCascades());
667ee8bf	303	printf(" kinks %d\n", GetNumberOfKinks());
667ee8bf	304	printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
	305	printf(" phos %d\n", GetNumberOfPHOSClusters());
	306	printf(" emcal %d\n", GetNumberOfEMCALClusters());
	307	printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
dd735cf0	308	printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
ef278eae	309	}
d75007f6	310
	311	void AliESD::SetESDfriend(const AliESDfriend *ev) {
	312	//
	313	// Attaches the complementary info to the ESD
	314	//
	315	if (!ev) return;
	316
	317	Int_t ntrk=ev->GetNumberOfTracks();
53203d32	318
d75007f6	319	for (Int_t i=0; i<ntrk; i++) {
	320	const AliESDfriendTrack *f=ev->GetTrack(i);
	321	GetTrack(i)->SetFriendTrack(f);
	322	}
	323	}
	324
b545009a	325	Int_t AliESD::AddTrack(const AliESDtrack *t) {
	326	// Add track
	327	TClonesArray &ftr = *fTracks;
	328	AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
	329	track->SetID(fTracks->GetEntriesFast()-1);
	330	return track->GetID();
	331	}
	332
	333	Int_t AliESD::AddKink(const AliESDkink *c) {
	334	// Add kink
	335	TClonesArray &fk = *fKinks;
	336	AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
	337	kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
	338	return fKinks->GetEntriesFast()-1;
	339	}
	340
	341	Int_t AliESD::AddCaloCluster(const AliESDCaloCluster *c) {
	342	// Add calocluster
	343	TClonesArray &fc = *fCaloClusters;
	344	AliESDCaloCluster clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(c);
	345	clus->SetID(fCaloClusters->GetEntriesFast()-1);
	346	return fCaloClusters->GetEntriesFast()-1;
	347	}
	348
	349
	350	void AliESD::SetFMDData(AliESDFMD * obj) {
	351	// use already allocated space
	352	if(fESDFMD){
	353	new(fESDFMD) AliESDFMD(*obj);
	354	}
	355	}
	356
	357	void AliESD::SetVZEROData(AliESDVZERO * obj){
	358	// use already allocated space
	359	if(fESDVZERO)
	360	new(fESDVZERO) AliESDVZERO(*obj);
	361	}
	362
d75007f6	363	void AliESD::GetESDfriend(AliESDfriend *ev) const {
	364	//
	365	// Extracts the complementary info from the ESD
	366	//
	367	if (!ev) return;
	368
	369	Int_t ntrk=GetNumberOfTracks();
	370
	371	for (Int_t i=0; i<ntrk; i++) {
	372	const AliESDtrack *t=GetTrack(i);
	373	const AliESDfriendTrack *f=t->GetFriendTrack();
	374	ev->AddTrack(f);
	375	}
	376	}
53203d32	377
b545009a	378
53203d32	379	void AliESD::AddObject(TObject* obj)
	380	{
	381	// Add an object to the list of object.
	382	// Please be aware that in order to increase performance you should
	383	// refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
	384	fESDObjects->AddLast(obj);
	385	}
	386
b545009a	387
53203d32	388	void AliESD::GetStdContent()
	389	{
	390	// set pointers for standard content
	391
	392	fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
	393	fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
	394	fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
	395	fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
	396	fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
	397	fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
	398	fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
	399	fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
	400	fSPDMult = (AliMultiplicity*)fESDObjects->At(kSPDMult);
	401	fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
	402	fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
	403	fTracks = (TClonesArray*)fESDObjects->At(kTracks);
	404	fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
	405	fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
	406	fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
	407	fV0s = (TClonesArray*)fESDObjects->At(kV0s);
	408	fCascades = (TClonesArray*)fESDObjects->At(kCascades);
	409	fKinks = (TClonesArray*)fESDObjects->At(kKinks);
	410	fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
	411	fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
	412
	413	}
	414
	415	void AliESD::SetStdNames(){
b545009a	416	// Set the names of the standard contents
53203d32	417	fSPDVertex->SetName("SPDVertex");
	418	fPrimaryVertex->SetName("PrimaryVertex");
	419	fPHOSTrigger->SetName("PHOSTrigger");
	420	fEMCALTrigger->SetName("EMCALTrigger");
	421	fTracks->SetName("Tracks");
	422	fMuonTracks->SetName("MuonTracks");
	423	fPmdTracks->SetName("PmdTracks");
	424	fTrdTracks->SetName("TrdTracks");
	425	fV0s->SetName("V0s");
	426	fCascades->SetName("Cascades");
	427	fKinks->SetName("Kinks");
	428	fCaloClusters->SetName("CaloClusters");
	429
	430	}
	431
	432	void AliESD::CreateStdContent()
	433	{
	434	// create the standard AOD content and set pointers
	435
	436	// create standard objects and add them to the TList of objects
	437	AddObject(new AliESDRun());
	438	AddObject(new AliESDHeader());
	439	AddObject(new AliESDZDC());
	440	AddObject(new AliESDFMD());
	441	AddObject(new AliESDVZERO());
	442	AddObject(new AliESDTZERO());
	443	AddObject(new AliESDVertex());
	444	AddObject(new AliESDVertex());
	445	AddObject(new AliMultiplicity());
	446	AddObject(new AliESDCaloTrigger());
	447	AddObject(new AliESDCaloTrigger());
	448	AddObject(new TClonesArray("AliESDtrack",0));
	449	AddObject(new TClonesArray("AliESDMuonTrack",0));
	450	AddObject(new TClonesArray("AliESDPmdTrack",0));
	451	AddObject(new TClonesArray("AliESDTrdTrack",0));
	452	AddObject(new TClonesArray("AliESDv0",0));
	453	AddObject(new TClonesArray("AliESDcascade",0));
	454	AddObject(new TClonesArray("AliESDkink",0));
	455	AddObject(new TClonesArray("AliESDCaloCluster",0));
	456	AddObject(new TClonesArray("AliRawDataErrorLog",0));
	457
	458	// check the order of the indices against enum...
	459
	460	// read back pointers
	461	GetStdContent();
	462	// set names
	463	SetStdNames();
	464
	465	}
	466
	467	void AliESD::ReadFromTree(TTree *tree){
	468
	469
	470	// is this really so smart that an ESDObject has a pointer to a list
	471	// of another ESDObject...
	472
	473	fESDObjects = (TList)((AliESD)tree->GetTree()->GetUserInfo()->FindObject("AliESD"))->GetList();
	474
53203d32	475	// if list is empty
	476	// we could still set the branch adresses based on
	477	// tree->GetListOfBranches() CKB
	478	// or create standard list
	479
2c48fa12	480	if(fESDObjects->GetEntries()<kESDListN){
	481	printf("%s %d AliESD::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
	482	}
	483
	484
	485
53203d32	486	// set the branch addresses
	487	TIter next(fESDObjects);
	488	TNamed *el;
	489	while((el=(TNamed*)next())){
	490	TString bname(el->GetName());
	491
	492	if(bname.CompareTo("AliESDfriend")==0)
	493	{
	494	// AliESDfriend does not have a name ...
	495	tree->SetBranchStatus("ESDfriend.*",1);
53203d32	496	tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
	497
	498
	499	}
	500	else{
53203d32	501	tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
	502	}
	503	}
	504
	505	GetStdContent();
	506	}
	507
	508
	509