/* History of cvs commits:
*
* $Log$
+ * Revision 1.12 2007/06/11 20:43:06 hristov
+ * Changes required by the updated AliESDCaloCluster (Gustavo)
+ *
* Revision 1.11 2007/03/30 13:50:34 gustavo
* PID for particles with E < 5 GeV was not done, temporal solution found (Guenole)
*
// #include "AliLoader.h"
// #include "AliStack.h"
// #include "AliESDtrack.h"
-// #include "AliESD.h"
+// #include "AliESDEvent.h"
#include "AliLog.h"
#include "AliEMCALPID.h"
}
//______________________________________________
-void AliEMCALPID::RunPID(AliESD *esd)
+void AliEMCALPID::RunPID(AliESDEvent *esd)
{
//
// Make the PID for all the EMCAL clusters containedin the ESDs File
/* History of cvs commits:
*
* $Log$
+ * Revision 1.12 2007/02/20 20:17:43 hristov
+ * Corrected array size, removed warnings (icc)
+ *
* Revision 1.11 2006/12/19 08:49:35 gustavo
* New PID class for EMCAL, bayesian analysis done with ESD data, PID information filled when calling AliEMCALPID in AliEMCALReconstructor::FillESD()
*
#include "TTask.h"
#include "TArrayD.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliPID.h"
class AliEMCALPID : public TTask {
AliEMCALPID();
virtual ~AliEMCALPID() { }
- void RunPID(AliESD *esd);
+ void RunPID(AliESDEvent *esd);
void ComputePID(Double_t energy, Double_t lambda0); // give the PID of a cluster
TArrayD DistLambda0(Double_t energy, Int_t nature); // compute lambda0 distributions
#include "AliEMCALReconstructor.h"
#include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliRunLoader.h"
#include "AliEMCALLoader.h"
}
//____________________________________________________________________________
-void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
+void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const
{
// Called by AliReconstruct after Reconstruct() and global tracking and vertexing
const double timeScale = 1.e+11; // transition constant from sec to 0.01 ns
class AliEMCALDigitizer ;
class AliEMCALClusterizer ;
class AliEMCALSDigitizer ;
-class AliESD ;
+class AliESDEvent ;
class AliRawReader ;
// --- Standard library ---
Bool_t Debug() const { return fDebug ; }
using AliReconstructor::FillESD;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const ;
AliTracker* CreateTracker (AliRunLoader* )const{return new AliEMCALTracker;}
using AliReconstructor::Reconstruct;
virtual void Reconstruct(AliRunLoader* runLoader) const ;
#include <TGeoMatrix.h>
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliKalmanTrack.h"
#include "AliEMCALRecPoint.h"
//
//------------------------------------------------------------------------------
//
-Int_t AliEMCALTracker::LoadClusters(AliESD *esd)
+Int_t AliEMCALTracker::LoadClusters(AliESDEvent *esd)
{
//
// Load EMCAL clusters in the form of AliESDCaloClusters,
//
//------------------------------------------------------------------------------
//
-Int_t AliEMCALTracker::LoadTracks(AliESD *esd)
+Int_t AliEMCALTracker::LoadTracks(AliESDEvent *esd)
{
//
// Load ESD tracks.
//
//------------------------------------------------------------------------------
//
-Int_t AliEMCALTracker::PropagateBack(AliESD* esd)
+Int_t AliEMCALTracker::PropagateBack(AliESDEvent* esd)
{
//
// Main operation method.
class TList;
class TTree;
class TObjArray;
-class AliESD;
+class AliESDEvent;
class AliESDCaloCluster;
class AliEMCALTrack;
class AliEMCALRecPoint;
virtual ~AliEMCALTracker() {Clear();}
virtual void Clear(Option_t *option="ALL");
- virtual Int_t Clusters2Tracks(AliESD*) {return -1;}
+ virtual Int_t Clusters2Tracks(AliESDEvent*) {return -1;}
virtual Int_t LoadClusters(TTree*);
- Int_t LoadClusters(AliESD* esd);
- Int_t LoadTracks(AliESD* esd);
- virtual Int_t PropagateBack(AliESD* esd);
- virtual Int_t RefitInward(AliESD*) {return -1;}
+ Int_t LoadClusters(AliESDEvent* esd);
+ Int_t LoadTracks(AliESDEvent* esd);
+ virtual Int_t PropagateBack(AliESDEvent* esd);
+ virtual Int_t RefitInward(AliESDEvent*) {return -1;}
virtual void UnloadClusters();
virtual AliCluster* GetCluster(Int_t) const {return NULL;};
TTree* SearchTrueMatches();
#include <AliRunLoader.h>
#include <AliRun.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include <AliESDfriend.h>
#include <AliMagFMaps.h>
#include <AliCDBManager.h>
fESDFile = new TFile(esd_path);
if(fESDFile->IsZombie() == kFALSE)
{
- fESD = new AliESD();
+ fESD = new AliESDEvent();
fESDTree = (TTree*) fESDFile->Get("esdTree");
if (fESDTree != 0)
{
return gEvent->fRunLoader;
}
-AliESD* Event::AssertESD()
+AliESDEvent* Event::AssertESD()
{
static const Exc_t eH("Event::AssertESD ");
#include <Reve/EventBase.h>
class AliRunLoader;
-class AliESD;
+class AliESDEvent;
class AliESDfriend;
class AliMagF;
TFile* fESDFile;
TTree* fESDTree;
- AliESD* fESD;
+ AliESDEvent* fESD;
AliESDfriend* fESDfriend;
Bool_t fESDfriendExists;
Int_t GetEventId() const { return fEventId; }
AliRunLoader* GetRunLoader() const { return fRunLoader; }
TTree* GetESDTree() const { return fESDTree; }
- AliESD* GetESD() const { return fESD; }
+ AliESDEvent* GetESD() const { return fESD; }
AliESDfriend* GetESDfriend() const { return fESDfriend; }
Bool_t GetESDfriendExists() const { return fESDfriendExists; }
virtual const Text_t* GetTitle() const { return fPath.Data(); }
static AliRunLoader* AssertRunLoader();
- static AliESD* AssertESD();
+ static AliESDEvent* AssertESD();
static AliESDfriend* AssertESDfriend();
static AliMagF* AssertMagField();
#include <AliLog.h>
#include <AliESDMuonTrack.h>
#include <AliTrackReference.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include <AliRunLoader.h>
#include <AliRun.h>
setw(8) << setprecision(4) <<
mtp->P() << " GeV/c" << endl;
- AliESD* esd = Alieve::Event::AssertESD();
+ AliESDEvent* esd = Alieve::Event::AssertESD();
Double_t spdVertexX = 0;
Double_t spdVertexY = 0;
}
if (fIsESDTrack) {
- AliESD* esd = Alieve::Event::AssertESD();
+ AliESDEvent* esd = Alieve::Event::AssertESD();
ULong64_t triggerMask = esd->GetTriggerMask();
cout << endl;
#include "AliFMDReconstructor.h" // ALIFMDRECONSTRUCTOR_H
#include "AliFMDRawReader.h" // ALIFMDRAWREADER_H
#include "AliFMDRecPoint.h" // ALIFMDMULTNAIIVE_H
-#include "AliESD.h" // ALIESD_H
+#include "AliESDEvent.h" // ALIESDEVENT_H
#include <AliESDFMD.h> // ALIESDFMD_H
#include <TH1.h>
#include <TH2.h>
void
AliFMDReconstructor::FillESD(TTree* /* digitsTree */,
TTree* /* clusterTree */,
- AliESD* esd) const
+ AliESDEvent* esd) const
{
// nothing to be done
// FIXME: The vertex may not be known when Reconstruct is executed,
}
//____________________________________________________________________
void
-AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESD*) const
+AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent*) const
{
// Cannot be used. See member function with same name but with 2
// TTree arguments. Make sure you do local reconstrucion
}
//____________________________________________________________________
void
-AliFMDReconstructor::FillESD(AliRunLoader*,AliESD*) const
+AliFMDReconstructor::FillESD(AliRunLoader*,AliESDEvent*) const
{
// Cannot be used. See member function with same name but with 2
// TTree arguments. Make sure you do local reconstrucion
}
//____________________________________________________________________
void
-AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESD*) const
+AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESDEvent*) const
{
// Cannot be used. See member function with same name but with 2
// TTree arguments. Make sure you do local reconstrucion
class AliFMDDigit;
class AliRawReader;
class AliRunLoader;
-class AliESD;
+class AliESDEvent;
class AliESDFMD;
class TH1;
@param esd ESD object to store data in.
*/
virtual void FillESD(TTree* digitsTree, TTree* clusterTree,
- AliESD* esd) const;
+ AliESDEvent* esd) const;
/** Not used */
- virtual void SetESD(AliESD* esd) { fESD = esd; }
+ virtual void SetESD(AliESDEvent* esd) { fESD = esd; }
/** Set the noise factor
@param f Factor to use */
virtual void SetNoiseFactor(Float_t f=3) { fNoiseFactor = f; }
Bool_t fAngleCorrect; // Whether to angle correct
mutable Vertex_t fVertexType; // What kind of vertex we got
AliRunLoader* fRunLoader; // Run loader passed to Init
- AliESD* fESD; // ESD object(?)
+ AliESDEvent* fESD; // ESD object(?)
Bool_t fDiagnostics; // Wheter to do diagnostics
TH1* fDiagStep1; // Diagnostics histogram
TH1* fDiagStep2; // Diagnostics histogram
/** Hide base classes unused function */
void Reconstruct(AliRunLoader*, AliRawReader*) const;
/** Hide base classes unused function */
- void FillESD(AliRawReader*, TTree*, AliESD*) const;
+ void FillESD(AliRawReader*, TTree*, AliESDEvent*) const;
/** Hide base classes unused function */
- void FillESD(AliRunLoader*, AliESD*) const;
+ void FillESD(AliRunLoader*, AliESDEvent*) const;
/** Hide base classes unused function */
- void FillESD(AliRunLoader*, AliRawReader*, AliESD*) const;
+ void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const;
- ClassDef(AliFMDReconstructor, 0) // class for the FMD reconstruction
+ ClassDef(AliFMDReconstructor, 1) // class for the FMD reconstruction
};
#endif
//____________________________________________________________________
/**
* Default implementation as sources do not have a real FillESD method.
*/
- int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd) {
+ int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd) {
if (esd==NULL && runLoader==NULL) {
// get rid of 'unused parameter' warning
}
return fpRawReader!=NULL?fpRawReader:fgpRawReader;
}
-int AliHLTOfflineInterface::SetESD(Int_t eventNo, AliESD* pESD)
+int AliHLTOfflineInterface::SetESD(Int_t eventNo, AliESDEvent* pESD)
{
fpESD=pESD;
return 0;
}
-AliESD* AliHLTOfflineInterface::GetESD() const
+AliESDEvent* AliHLTOfflineInterface::GetESD() const
{
return fpESD;
}
return iResult;
}
-int AliHLTOfflineInterface::FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESD* esd)
+int AliHLTOfflineInterface::FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
{
// see header file for class documentation
int iResult=0;
class AliRunLoader;
class AliRawReader;
-class AliESD;
+class AliESDEvent;
class TTree;
/******************************************************************************/
* The class implements the basic interface to the AliRoot objects during
* reconstructions.
* It serves as a base class for offline source and sink interface components
- * and provides access methods for the AliRunLoader, AliRawReader and AliESD
+ * and provides access methods for the AliRunLoader, AliRawReader and AliESDEvent
* objects. The AliRunLoader and the AliRawReader are fixed during one run,
- * while the AliESD object will be changed from event to event.<br>
+ * while the AliESDEvent object will be changed from event to event.<br>
* \em Note: The digits and clusters trees are not available through this
* interface class as they are completetly detector (AliLoader) dependend.
*
/**
* Set AliRoot ESD for the current event.
*/
- int SetESD(Int_t eventNo, AliESD* pESD);
+ int SetESD(Int_t eventNo, AliESDEvent* pESD);
/**
* Get the AliRoot ESD
*/
- AliESD* GetESD() const;
+ AliESDEvent* GetESD() const;
/**
* Set AliRoot external params.
* @param eventNo event No. \em Note: this is an internal enumeration of the
* processed events.
* @param runLoader the AliRoot runloader
- * @param esd an AliESD instance
+ * @param esd an AliESDEvent instance
* @return neg. error code if failed
*/
- virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd)=0;
+ virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)=0;
/**
* Fill ESD for one event.
* @param eventNo event No. \em Note: this is an internal enumeration of the
* processed events.
* @param runLoader the AliRoot runloader
- * @param esd an AliESD instance
+ * @param esd an AliESDEvent instance
* @return neg. error code if failed
*/
- static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+ static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
/**
* Reset AliRoot internal params of all active components.
/** private AliRoot raw reader instance */
AliRawReader* fpRawReader; //! transient
/** AliRoot HLT ESD instance */
- AliESD* fpESD; //! transient
+ AliESDEvent* fpESD; //! transient
/** the list of active interfaces */
static AliHLTOfflineInterface* fAnchor; //! transient
/** number of interfaces */
static int fCount; //! see above
- ClassDef(AliHLTOfflineInterface, 2);
+ ClassDef(AliHLTOfflineInterface, 3);
};
#endif
return iResult;
}
-int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd)
+int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
{
// see header file for class documentation
int iResult=0;
class AliHLTTask;
class AliRunLoader;
class AliRawReader;
-class AliESD;
+class AliESDEvent;
class TObjArray;
class TStopwatch;
* processing counter and is not related to the nature/
* origin of the event
* @param runLoader the AliRoot runloader
- * @param esd an AliESD instance
+ * @param esd an AliESDEvent instance
* @return neg. error code if failed
*/
- int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+ int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
/**
* Load component libraries.
// Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
//-------------------------------------------------------------------------
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliHLTITStrack.h"
#include "AliHLTITStracker.h"
return 0;
}
-Int_t AliHLTITStracker::Clusters2Tracks(AliESD *event) {
+Int_t AliHLTITStracker::Clusters2Tracks(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions reconstructs HLT ITS tracks
//--------------------------------------------------------------------
return 0;
}
-Int_t AliHLTITStracker::PropagateBack(AliESD *event) {
+Int_t AliHLTITStracker::PropagateBack(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
//--------------------------------------------------------------------
return 0;
}
-Int_t AliHLTITStracker::RefitInward(AliESD *event) {
+Int_t AliHLTITStracker::RefitInward(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions refits ITS tracks using the
// "inward propagated" TPC tracks
#include "AliITStrackerV2.h"
-class AliESD;
+class AliESDEvent;
class AliHLTITStrack;
//-------------------------------------------------------------------------
AliHLTITStracker():AliITStrackerV2(){ fConstraint[0]=1; fConstraint[1]=0; }
AliHLTITStracker(const Char_t *geom) : AliITStrackerV2(geom){ fConstraint[0]=1; fConstraint[1]=0; }
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
ClassDef(AliHLTITStracker,1) //HLT ITS tracker
};
return iResult;
}
-int AliHLTSampleOfflineSinkComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd)
+int AliHLTSampleOfflineSinkComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
{
// see header file for class documentation
int iResult=0;
* @param eventNo event No. \em Note: this is an internal enumeration of the
* processed events.
* @param runLoader the AliRoot runloader
- * @param esd an AliESD instance
+ * @param esd an AliESDEvent instance
* @return neg. error code if failed
*/
- int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+ int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
protected:
/**
*/
#include "AliHLTTPCEsdWriterComponent.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "TTree.h"
#include "AliHLTTPCTrack.h"
#include "AliHLTTPCTrackArray.h"
{
// see header file for class documentation
int iResult=0;
- fESD = new AliESD;
+ fESD = new AliESDEvent;
+ fESD->CreateStdContent();
if (fESD) {
fTree = new TTree("esdTree", "Tree with HLT ESD objects");
if (fTree) {
- fTree->Branch("ESD", "AliESD", &fESD);
+ fESD->WriteToTree(fTree);
}
delete fESD;
fESD=NULL;
int iResult=0;
TTree* pTree=fTree;
if (pTree) {
- fESD = new AliESD;
+ fESD = new AliESDEvent;
+ fESD->CreateStdContent();
if (fESD) {
- AliESD* pESD=fESD;
+ AliESDEvent* pESD=fESD;
const AliHLTComponentBlockData* iter = NULL;
AliHLTTPCTrackletData* inPtr=NULL;
pTree->Fill();
}
- fESD=NULL;
+ fESD->Reset();
delete pESD;
} else {
iResult=-ENOMEM;
return iResult;
}
-int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD)
+int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD)
{
// see header file for class documentation
int iResult=0;
// forward declarations
class TTree;
-class AliESD;
+class AliESDEvent;
class AliHLTTPCTrackArray;
/**
* @param pESD pointer to ESD
* @return neg. error code if failed
*/
- int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD);
+ int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD);
/** the ESD tree */
TTree* fTree; //! transient value
/** the ESD */
- AliESD* fESD; //! transient value
+ AliESDEvent* fESD; //! transient value
- ClassDef(AliHLTTPCEsdWriterComponent, 0)
+ ClassDef(AliHLTTPCEsdWriterComponent, 1)
};
#endif
#endif // HAVE_THREAD
#include <AliRunLoader.h>
#include <AliRawEvent.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include <AliESDHLTtrack.h>
#if __GNUC__ >= 3
}
}
-Int_t AliHLTTPCHough::FillESD(AliESD *esd)
+Int_t AliHLTTPCHough::FillESD(AliESDEvent *esd)
{
// Fill the found hough transform tracks
// into the ESD. The tracks are stored as
#endif // HAVE_THREAD
class AliRunLoader;
class AliRawEvent;
-class AliESD;
+class AliESDEvent;
class AliESDHLTtrack;
/**
void EvaluatePatch(Int_t i,Int_t roadwidth,Int_t nrowstomiss);
void WriteTracks(Int_t slice,Char_t *path="./");
void WriteTracks(Char_t *path);
- Int_t FillESD(AliESD *esd);
+ Int_t FillESD(AliESDEvent *esd);
void WriteDigits(Char_t *outfile="output_digits.root");
void InitEvaluate();
void DoBench(Char_t *filename);
// Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
//-------------------------------------------------------------------------
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliRunLoader.h"
#include "AliHLTTPCHoughTracker.h"
#include "AliHLTTPCHough.h"
fRunLoader = runLoader;
}
-Int_t AliHLTTPCHoughTracker::Clusters2Tracks(AliESD *event)
+Int_t AliHLTTPCHoughTracker::Clusters2Tracks(AliESDEvent *event)
{
//--------------------------------------------------------------------
// This method reconstructs HLT TPC Hough tracks
#include "AliTracker.h"
class AliRunLoader;
-class AliESD;
+class AliESDEvent;
//-------------------------------------------------------------------------
class AliHLTTPCHoughTracker : public AliTracker {
public:
AliHLTTPCHoughTracker(AliRunLoader *runLoader);
- Int_t Clusters2Tracks(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
- Int_t PropagateBack(AliESD */*event*/) {return 0;}
- Int_t RefitInward(AliESD */*event*/) {return 0;}
+ Int_t PropagateBack(AliESDEvent */*event*/) {return 0;}
+ Int_t RefitInward(AliESDEvent */*event*/) {return 0;}
Int_t LoadClusters(TTree */*cf*/) {return 0;}
void UnloadClusters() {return;}
#include "AliTRDclusterizerV1HLT.h"
#include "AliTRDReconstructor.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliTRDtrackerHLT.h"
#include "AliTRDCalibraFillHisto.h"
#include "AliMagFMaps.h"
AliTRDReconstructor::SetSeedingOn(kTRUE);
- AliESD *esd = new AliESD();
-
+ AliESDEvent *esd = new AliESDEvent();
+ esd->CreateStdContent();
//fTracker->MakeSeedsMI(3, 5, esd);
fTracker->PropagateBack(esd);
#include <TTreeStream.h>
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliAlignObj.h"
#include "AliRieman.h"
#include "AliTrackPointArray.h"
}
//_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::Clusters2Tracks(AliESD *event)
+Int_t AliTRDtrackerHLT::Clusters2Tracks(AliESDEvent *event)
{
//
// Finds tracks within the TRD. The ESD event is expected to contain seeds
}
//_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::PropagateBack(AliESD *event)
+Int_t AliTRDtrackerHLT::PropagateBack(AliESDEvent *event)
{
//
// Gets seeds from ESD event. The seeds are AliTPCtrack's found and
}
//_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::RefitInward(AliESD *event)
+Int_t AliTRDtrackerHLT::RefitInward(AliESDEvent *event)
{
//
// Refits tracks within the TRD. The ESD event is expected to contain seeds
}
//_____________________________________________________________________________
-void AliTRDtrackerHLT::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESD *esd)
+void AliTRDtrackerHLT::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESDEvent *esd)
{
//
// Creates seeds using clusters between position inner plane and outer plane
class AliTRDtracklet;
class AliTRDcluster;
class AliTRDseed;
-class AliESD;
+class AliESDEvent;
class TTreeSRedirector;
///////////////////////////////////////////////////////////////////////////////
return (AliCluster *) fClusters->UncheckedAt(index); }
static Int_t Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
virtual void CookLabel(AliKalmanTrack *t, Float_t wrong) const;
Int_t FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
, Int_t *clusters, AliTRDtracklet &tracklet);
- void MakeSeedsMI(Int_t inner, Int_t outer, AliESD *esd = 0);
+ void MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
protected:
}
#ifdef use_aliroot
-Int_t AliHLTHough::FillESD(AliESD *esd)
+Int_t AliHLTHough::FillESD(AliESDEvent *esd)
{
// Fill the found hough transform tracks
// into the ESD. The tracks are stored as
#include <../RAW/AliRawEvent.h>
#endif
#ifdef use_aliroot
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include <AliESDHLTtrack.h>
#endif
void WriteTracks(Int_t slice,Char_t *path="./");
void WriteTracks(Char_t *path);
#ifdef use_aliroot
- Int_t FillESD(AliESD *esd);
+ Int_t FillESD(AliESDEvent *esd);
#endif
void WriteDigits(Char_t *outfile="output_digits.root");
void InitEvaluate();
#include <AliRunLoader.h>
#include <AliHeader.h>
#include <AliGenEventHeader.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include <AliESDHLTtrack.h>
#include "AliHLTStandardIncludes.h"
}
void AliHLTReconstructor::FillESD(AliRunLoader* runLoader,
- AliESD* esd) const
+ AliESDEvent* esd) const
{
//fill the esd file with found tracks
if(!runLoader) {
*/
}
-void AliHLTReconstructor::FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const
+void AliHLTReconstructor::FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const
{
//fill esd with tracks from conformal mapping
/*
*/
}
-void AliHLTReconstructor::FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const
+void AliHLTReconstructor::FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const
{
//fill esd with tracks from hough
char filename[256];
// AliTracker* CreateTracker(AliRunLoader*) const;
/** fill esd for one event */
- void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const{
AliReconstructor::Reconstruct(digitsTree,clustersTree);
}
virtual void FillESD(TTree* digitsTree, TTree* clustersTree,
- AliESD* esd) const {
+ AliESDEvent* esd) const {
AliReconstructor::FillESD(digitsTree,clustersTree,esd);
}
virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree,
- AliESD* esd) const {
+ AliESDEvent* esd) const {
AliReconstructor::FillESD(rawReader,clustersTree,esd);
}
virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const {
+ AliRawReader* rawReader, AliESDEvent* esd) const {
AliReconstructor:: FillESD(runLoader,rawReader,esd);
}
void SetDoBench(Bool_t b){fDoBench=b;}
private:
void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const;
void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const;
- void FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const;
- void FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const;
+ void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const;
+ void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const;
Bool_t fDoHough; //do the hough transform
Bool_t fDoTracker; //do the standard conformal tracker
// Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
//-------------------------------------------------------------------------
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliRunLoader.h"
#include "AliHLTTPCtracker.h"
#include "AliHLTHough.h"
fRunLoader = runLoader;
}
-Int_t AliHLTTPCtracker::Clusters2Tracks(AliESD *event)
+Int_t AliHLTTPCtracker::Clusters2Tracks(AliESDEvent *event)
{
//--------------------------------------------------------------------
// This method reconstructs HLT TPC Hough tracks
#include "AliHLTTransform.h"
class AliRunLoader;
-class AliESD;
+class AliESDEvent;
//-------------------------------------------------------------------------
class AliHLTTPCtracker : public AliTracker {
public:
AliHLTTPCtracker(AliRunLoader *runLoader);
- Int_t Clusters2Tracks(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
- Int_t PropagateBack(AliESD */*event*/) {return 0;}
- Int_t RefitInward(AliESD */*event*/) {return 0;}
+ Int_t PropagateBack(AliESDEvent */*event*/) {return 0;}
+ Int_t RefitInward(AliESDEvent */*event*/) {return 0;}
Int_t LoadClusters(TTree */*cf*/) {return 0;}
void UnloadClusters() {return;}
#include "AliHMPIDCluster.h" //GetTrackPoint(),PropagateBack()
#include "AliHMPIDParam.h" //GetTrackPoint(),PropagateBack()
#include "AliHMPIDRecon.h" //Recon()
-#include <AliESD.h> //PropagateBack(),Recon()
+#include <AliESDEvent.h> //PropagateBack(),Recon()
#include <AliRun.h> //GetTrackPoint(),PropagateBack()
#include <AliTrackPointArray.h> //GetTrackPoint()
#include <AliAlignObj.h> //GetTrackPoint()
return 0;
}//LoadClusters()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDTracker::PropagateBack(AliESD *pEsd)
+Int_t AliHMPIDTracker::PropagateBack(AliESDEvent *pEsd)
{
// Interface pure virtual in AliTracker. Invoked from AliReconstruction::RunTracking() after invocation of AliTracker::LoadClusters() once per event
// Agruments: pEsd - pointer to ESD
return Recon(pEsd,fClu,(TObjArray*)pNmeanEnt->GetObject());
}//PropagateBack()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDTracker::Recon(AliESD *pEsd,TObjArray *pClus,TObjArray *pNmean)
+Int_t AliHMPIDTracker::Recon(AliESDEvent *pEsd,TObjArray *pClus,TObjArray *pNmean)
{
// Static method to reconstruct Theta Ckov for all valid tracks of a given event.
// Arguments: pEsd- pointer ESD; pClu- pointer to clusters for all chambers; pNmean - pointer to all function Nmean=f(time)
// HMPID base class fo tracking
//.
-class AliESD; //Recon()
+class AliESDEvent; //Recon()
class AliESDtrack; //IntTrkCha()
class AliHMPIDTracker : public AliTracker
{
//framework part
AliCluster *GetCluster (Int_t )const {return 0;} //pure virtual from AliTracker
Bool_t GetTrackPoint (Int_t idx,AliTrackPoint &pt)const; // from AliTracker
- Int_t Clusters2Tracks(AliESD * ) {return 0;} //pure virtual from AliTracker
+ Int_t Clusters2Tracks(AliESDEvent * ) {return 0;} //pure virtual from AliTracker
Int_t LoadClusters (TTree *pCluTr ); //pure virtual from AliTracker
- Int_t PropagateBack (AliESD *pEsd ); //pure virtual from AliTracker
- Int_t RefitInward (AliESD * ) {return 0;} //pure virtual from AliTracker
+ Int_t PropagateBack (AliESDEvent *pEsd ); //pure virtual from AliTracker
+ Int_t RefitInward (AliESDEvent * ) {return 0;} //pure virtual from AliTracker
void UnloadClusters ( ) { } //pure virtual from AliTracker
//private part
static Int_t IntTrkCha (AliESDtrack *pTrk,Float_t &xPc,Float_t &yPc ); //find track-PC intersection, retuns chamber ID
- static Int_t Recon (AliESD *pEsd,TObjArray *pCluAll,TObjArray *pNmean=0); //do actual job, returns status code
+ static Int_t Recon (AliESDEvent *pEsd,TObjArray *pCluAll,TObjArray *pNmean=0); //do actual job, returns status code
static Int_t ReconHiddenTrk(Int_t iCh,AliESDtrack *pTrk,TClonesArray *pClus,TObjArray *pNmean);//do actual job with Hidden Track Algorithm
protected:
TObjArray *fClu; //! each chamber holds it's one list of clusters
#include "AliITSVertexer3D.h"
#include "AliITSVertexerZ.h"
#include "AliITSVertexerCosmics.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliITSpidESD.h"
#include "AliITSpidESD1.h"
#include "AliITSpidESD2.h"
//_____________________________________________________________________________
void AliITSReconstructor::FillESD(AliRunLoader* runLoader,
- AliESD* esd) const
+ AliESDEvent* esd) const
{
// make PID, find V0s and cascade
AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const;
virtual AliVertexer* CreateVertexer(AliRunLoader* runLoader) const;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
virtual void FillESD(TTree* digitsTree, TTree* clustersTree,
- AliESD* esd) const
+ AliESDEvent* esd) const
{AliReconstructor::FillESD(digitsTree, clustersTree, esd);}
virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree,
- AliESD* esd) const
+ AliESDEvent* esd) const
{AliReconstructor::FillESD(rawReader, clustersTree, esd);}
virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const
+ AliRawReader* rawReader, AliESDEvent* esd) const
{AliReconstructor::FillESD(runLoader,rawReader, esd);}
void SetRecoParam(AliITSRecoParam * param){ fgkRecoParam = param;}
//#include <Rtypes.h>
#include <TObject.h>
-class AliESD;
+class AliESDEvent;
class AliITSpidESD : public TObject {
public:
AliITSpidESD();
virtual ~AliITSpidESD() {}
- virtual Int_t MakePID(AliESD *event) =0;
+ virtual Int_t MakePID(AliESDEvent *event) =0;
static Double_t Bethe(Double_t p,Double_t mass);
private:
ClassDef(AliITSpidESD,1) // ITS PID class
//-----------------------------------------------------------------
#include "AliITSpidESD.h"
#include "AliITSpidESD1.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp(AliITSpidESD1)
//_________________________________________________________________________
-Int_t AliITSpidESD1::MakePID(AliESD *event)
+Int_t AliITSpidESD1::MakePID(AliESDEvent *event)
{
//
// This function calculates the "detector response" PID probabilities
AliITSpidESD1();
AliITSpidESD1(Double_t *param);
virtual ~AliITSpidESD1() {}
- virtual Int_t MakePID(AliESD *event);
+ virtual Int_t MakePID(AliESDEvent *event);
private:
Double_t fRes; // relative dEdx resolution
//-----------------------------------------------------------------------//
#include "AliITSpidESD2.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliITStrackV2.h"
#include "AliITSRecPoint.h"
}
//_________________________________________________________________________
-Int_t AliITSpidESD2::MakePID(AliESD *event)
+Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
{
//
AliITSpidESD2();
AliITSpidESD2(AliITStrackerMI *tracker,AliITSLoader* loader);
virtual ~AliITSpidESD2();
- virtual Int_t MakePID(AliESD *event);
+ virtual Int_t MakePID(AliESDEvent *event);
AliITSpidESD2(const AliITSpidESD2 &ob); // copy constructor
AliITSpidESD2& operator=(const AliITSpidESD2 & source); // ass. op.
#include <TTreeStream.h>
#include <TTree.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliV0.h"
#include "AliHelix.h"
#include "AliITSRecPoint.h"
return 0;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) {
+Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions reconstructs ITS tracks
// The clusters must be already loaded !
return 0;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::PropagateBack(AliESD *event) {
+Int_t AliITStrackerMI::PropagateBack(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
// The clusters must be loaded !
return 0;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::RefitInward(AliESD *event) {
+Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions refits ITS tracks using the
// "inward propagated" TPC tracks
return res;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UpdateTPCV0(AliESD *event){
+void AliITStrackerMI::UpdateTPCV0(AliESDEvent *event){
//
//try to update, or reject TPC V0s
//
//
}
//------------------------------------------------------------------------
-void AliITStrackerMI::FindV02(AliESD *event)
+void AliITStrackerMI::FindV02(AliESDEvent *event)
{
//
// V0 finder
delete pvertex;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::RefitV02(AliESD *event)
+void AliITStrackerMI::RefitV02(AliESDEvent *event)
{
//
//try to refit V0s in the third path of the reconstruction
class TTree;
class TTreeSRedirector;
-class AliESD;
+class AliESDEvent;
#include <TObjArray.h>
#include "AliITSRecPoint.h"
{return fgLayers[layn].GetNumberOfClusters();}
Int_t LoadClusters(TTree *cf);
void UnloadClusters();
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
Bool_t RefitAt(Double_t x, AliITStrackMI *seed,
const AliITStrackMI *t, Bool_t extra=kFALSE);
Bool_t RefitAt(Double_t x, AliITStrackMI *seed, const Int_t *clindex);
protected:
Int_t GetNearestLayer(const Double_t *xr) const; //get nearest upper layer close to the point xr
- void FindV02(AliESD *event); //try to find V0
- void RefitV02(AliESD *event); //try to refit V0's
- void UpdateTPCV0(AliESD *event); //try to update, or reject TPC V0s
+ void FindV02(AliESDEvent *event); //try to find V0
+ void RefitV02(AliESDEvent *event); //try to refit V0's
+ void UpdateTPCV0(AliESDEvent *event); //try to update, or reject TPC V0s
void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
void CookLabel(AliITStrackMI *t,Float_t wrong) const;
Double_t GetEffectiveThickness(Double_t y, Double_t z) const;
Int_t fLayersNotToSkip[kMaxLayer]; // layer masks
Int_t fLastLayerToTrackTo; // the innermost layer to track to
Float_t * fCoeficients; //! working array with errors and mean cluser shape
- AliESD * fEsd; //! pointer to the ESD event
+ AliESDEvent * fEsd; //! pointer to the ESD event
TTreeSRedirector *fDebugStreamer; //!debug streamer
private:
AliITStrackerMI(const AliITStrackerMI &tracker);
AliITStrackerMI & operator=(const AliITStrackerMI &tracker);
- ClassDef(AliITStrackerMI,2) //ITS tracker MI
+ ClassDef(AliITStrackerMI,3) //ITS tracker MI
};
#include <TObjArray.h>
#include <TTree.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDVertex.h"
#include "AliESDtrack.h"
#include "AliITSVertexer.h"
}
//____________________________________________________________________________
-Int_t AliITStrackerSA::Clusters2Tracks(AliESD *event){
+Int_t AliITStrackerSA::Clusters2Tracks(AliESDEvent *event){
// This method is used to find and fit the tracks. By default the corresponding
// method in the parent class is invoked. In this way a combined tracking
// TPC+ITS is performed. If the flag fITSStandAlone is true, the tracking
//______________________________________________________________________
-Int_t AliITStrackerSA::FindTracks(AliESD* event){
+Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){
// Track finder using the ESD object
class AliESDVertex;
class AliITSVertexer;
class TTree;
+class AliESDEvent;
class TArrayD;
class AliITStrackerSA : public AliITStrackerMI {
AliITStrackerSA(const AliITStrackerSA& tracker);
AliITStrackerSA& operator=(const AliITStrackerSA& source);
virtual ~AliITStrackerSA();
- virtual Int_t Clusters2Tracks(AliESD *event);
- Int_t FindTracks(AliESD* event);
+ virtual Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t FindTracks(AliESDEvent* event);
AliITStrackV2* FitTrack(AliITStrackSA* tr,Double_t* primaryVertex);
TClonesArray** fCluLayer; //! array with clusters
TClonesArray** fCluCoord; //! array with cluster info
- ClassDef(AliITStrackerSA,4)
+ ClassDef(AliITStrackerSA,5)
};
#endif
#include "AliITSgeomTGeo.h"
#include "AliAlignObj.h"
#include "AliITSRecPoint.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliITSRecPoint.h"
#include "AliITSReconstructor.h"
#include "AliITStrackerV2.h"
return 0;
}
-Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
+Int_t AliITStrackerV2::Clusters2Tracks(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions reconstructs ITS tracks
// The clusters must be already loaded !
return 0;
}
-Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
+Int_t AliITStrackerV2::PropagateBack(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
// The clusters must be loaded !
return 0;
}
-Int_t AliITStrackerV2::RefitInward(AliESD *event) {
+Int_t AliITStrackerV2::RefitInward(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions refits ITS tracks using the
// "inward propagated" TPC tracks
#include "AliITStrackV2.h"
class AliITSRecPoint;
-class AliESD;
+class AliESDEvent;
class TTree;
}
Int_t LoadClusters(TTree *cf);
void UnloadClusters();
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
Bool_t RefitAt(Double_t x, AliITStrackV2 *seed,
const AliITStrackV2 *t, Bool_t extra=kFALSE);
void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
class TTree;
class AliRunLoader;
class AliRawReader;
-class AliESD;
+class AliESDEvent;
class AliMonitorTrend;
virtual void CreateBranches(TTree* tree);
virtual void FillHistos(AliRunLoader* runLoader,
AliRawReader* rawReader,
- AliESD* esd) = 0;
+ AliESDEvent* esd) = 0;
protected:
TFolder* fFolder; // sub folder for monitor histograms
//_____________________________________________________________________________
void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/,
- AliRawReader* /*rawReader*/, AliESD* /*esd*/)
+ AliRawReader* /*rawReader*/, AliESDEvent* /*esd*/)
{
// fill the HLT monitor histogrms
virtual void CreateHistos(TFolder* folder);
virtual void FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd);
+ AliRawReader* rawReader, AliESDEvent* esd);
private:
AliMonitorHLT(const AliMonitorHLT& monitor);
//_____________________________________________________________________________
void AliMonitorHLTHough::FillHistos(AliRunLoader* /*runLoader*/,
AliRawReader* /*rawReader*/,
- AliESD* /*esd*/)
+ AliESDEvent* /*esd*/)
{
// fill the HLT Hough transform monitor histograms
virtual void CreateHistos(TFolder* folder);
virtual void FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd);
+ AliRawReader* rawReader, AliESDEvent* esd);
private:
AliMonitorHLTHough(const AliMonitorHLTHough& monitor);
#include <TVector3.h>
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliITSRawStreamSDD.h"
#include "AliITSRawStreamSSD.h"
#include "AliITSclusterV2.h"
//_____________________________________________________________________________
void AliMonitorITS::FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd)
+ AliRawReader* rawReader, AliESDEvent* esd)
{
// fill the ITS monitor histogrms
virtual void CreateHistos(TFolder* folder);
virtual void FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd);
+ AliRawReader* rawReader, AliESDEvent* esd);
private:
AliMonitorITS(const AliMonitorITS& monitor);
#include <TSocket.h>
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliITSclustererV2.h"
#include "AliITSgeom.h"
#include "AliITStrackerV2.h"
AliInfo(Form("run: %d event: %d %d\n", rawReader.GetRunNumber(),
rawReader.GetEventId()[0], rawReader.GetEventId()[1]));
- AliESD esd;
+ AliESDEvent esd;
if (IsSelected("TPC")) {
CheckForConnections();
if (!ReconstructTPC(&rawReader, &esd)) return kFALSE;
}
//_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESDEvent* esd)
{
// find TPC clusters and tracks
}
//_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESDEvent* esd)
{
// find ITS clusters and tracks
}
//_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructV0s(AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructV0s(AliESDEvent* esd)
{
// find V0s
#include <TString.h>
#include <TSystem.h>
-class AliESD;
+class AliESDEvent;
class AliITSgeom;
class AliRawReader;
class AliRunLoader;
Bool_t CheckForNewFile();
Bool_t ProcessFile();
Int_t GetNumberOfEvents(const char* fileName) const;
- Bool_t ReconstructTPC(AliRawReader* rawReader, AliESD* esd);
- Bool_t ReconstructITS(AliRawReader* rawReader, AliESD* esd);
- Bool_t ReconstructV0s(AliESD* esd);
+ Bool_t ReconstructTPC(AliRawReader* rawReader, AliESDEvent* esd);
+ Bool_t ReconstructITS(AliRawReader* rawReader, AliESDEvent* esd);
+ Bool_t ReconstructV0s(AliESDEvent* esd);
void CreateHLT(const char* fileName);
void CreateHLTHough(const char* fileName);
Bool_t ReconstructHLT(Int_t iEvent);
#include <TVector3.h>
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliMonitorDataTPC.h"
#include "AliMonitorHisto.h"
#include "AliMonitorTPC.h"
//_____________________________________________________________________________
void AliMonitorTPC::FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd)
+ AliRawReader* rawReader, AliESDEvent* esd)
{
// fill the TPC monitor histogrms
virtual void CreateHistos(TFolder* folder);
virtual void CreateBranches(TTree* tree);
virtual void FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd);
+ AliRawReader* rawReader, AliESDEvent* esd);
private:
AliMonitorTPC(const AliMonitorTPC& monitor);
#include "AliMonitorV0s.h"
#include "AliMonitorHisto.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliLog.h"
#include <TFolder.h>
#include <TPDGCode.h>
//_____________________________________________________________________________
void AliMonitorV0s::FillHistos(AliRunLoader* /*runLoader*/,
- AliRawReader*, AliESD* esd)
+ AliRawReader*, AliESDEvent* esd)
{
// fill the V0s monitor histogrms
virtual void CreateHistos(TFolder* folder);
virtual void FillHistos(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd);
+ AliRawReader* rawReader, AliESDEvent* esd);
private:
AliMonitorV0s(const AliMonitorV0s& monitor);
if (!AliHLTTransform::Init("./", kFALSE)) {
::Fatal("AliHLTTransform::Init", "HLT initialization failed");
}
- AliESD *esd = new AliESD;
+ AliESDEvent *esd = new AliESDEvent;
+ esd->CreateStdContent();
// AliKalmanTrack::SetConvConst(
// 1000/0.299792458/AliHLTTransform::GetSolenoidField()
// );
#include "AliStack.h"
#include "AliTrackReference.h"
#include "AliTracker.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliMagFMaps.h"
#include "AliLog.h"
Double_t fPxRec1, fPyRec1, fPzRec1, fE1;
Int_t fZ1;
- AliESD* fESD = new AliESD();
+ AliESDEvent* fESD = new AliESDEvent();
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree)
{
# include "TString.h"
#endif
-class AliESD;
+class AliESDEvent;
class TTree;
class TH1F ;
#include "AliMUONVClusterStore.h"
#include "AliMUONVTriggerStore.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliESDVertex.h"
#include "AliLoader.h"
//_____________________________________________________________________________
Int_t
-AliMUONTracker::Clusters2Tracks(AliESD* esd)
+AliMUONTracker::Clusters2Tracks(AliESDEvent* esd)
{
/// Performs the tracking and store the resulting tracks in both
/// the TreeT and the ESD
}
//_____________________________________________________________________________
-Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESD* esd)
+Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd)
{
/// Performs the tracking
//_____________________________________________________________________________
void
-AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESD* esd) const
+AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const
{
/// Fill the ESD from the trackStore
#include "AliTracker.h"
class AliCluster;
-class AliESD;
+class AliESDEvent;
class AliLoader;
class AliMUONDigitMaker;
class AliMUONGeometryTransformer;
virtual ~AliMUONTracker();
/// Main entry point.
- virtual Int_t Clusters2Tracks(AliESD* esd);
+ virtual Int_t Clusters2Tracks(AliESDEvent* esd);
///
virtual Int_t LoadClusters(TTree* clustersTree);
virtual void UnloadClusters();
/// Dummy implementation
- virtual Int_t PropagateBack(AliESD* /*event*/) {return 0;}
+ virtual Int_t PropagateBack(AliESDEvent* /*event*/) {return 0;}
/// Dummy implementation
- virtual Int_t RefitInward(AliESD* /*event*/) {return 0;}
+ virtual Int_t RefitInward(AliESDEvent* /*event*/) {return 0;}
/// Dummy implementation
virtual AliCluster *GetCluster(Int_t /*index*/) const {return 0;}
/// Set option
/// Not implemented
AliMUONTracker& operator=(const AliMUONTracker& rhs);
- Int_t Clusters2Tracks(TTree& tracksTree, AliESD* esd);
+ Int_t Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd);
- void FillESD(AliMUONVTrackStore& trackStore, AliESD* esd) const;
+ void FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const;
private:
AliLoader* fLoader; //!< loader to get access to trees
/* History of cvs commits:
*
* $Log$
+ * Revision 1.38 2007/04/01 15:40:15 kharlov
+ * Correction for actual vertex position implemented
+ *
* Revision 1.37 2006/08/29 11:41:19 kharlov
* Missing implementation of ctors and = operator are added
*
// --- Standard library ---
// --- AliRoot header files ---
-class AliESD ;
+class AliESDEvent ;
class AliPHOSGeometry ;
class AliPHOSClusterizer ;
class AliPHOSTrackSegmentMaker ;
Int_t GetFirstEvent() const {return fFirstEvent; }
Int_t GetLastEvent() const {return fLastEvent; }
- void SetESD(AliESD *esd) { fESD = esd; }
+ void SetESD(AliESDEvent *esd) { fESD = esd; }
virtual const char * Version() const { Warning("Version", "not defined" ) ; return 0 ; }
virtual void WriteRecParticles() = 0;
TString fEventFolderName ; // event folder name
Int_t fFirstEvent; // first event to process
Int_t fLastEvent; // last event to process
- AliESD * fESD; //! ESD object
+ AliESDEvent * fESD; //! ESD object
private:
virtual void Init() { Warning("Init", "not defined" ) ; }
- ClassDef(AliPHOSPID,4) // Particle Identifier algorithm (base class)
+ ClassDef(AliPHOSPID,5) // Particle Identifier algorithm (base class)
} ;
/* History of cvs commits:
*
* $Log$
+ * Revision 1.111 2007/05/04 14:49:29 policheh
+ * AliPHOSRecPoint inheritance from AliCluster
+ *
* Revision 1.110 2007/04/24 10:08:03 kharlov
* Vertex extraction from GenHeader
*
#include "AliPHOS.h"
#include "AliPHOSPIDv1.h"
#include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDVertex.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
// --- Standard library ---
// --- AliRoot header files ---
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliPHOSReconstructor.h"
#include "AliPHOSClusterizerv1.h"
#include "AliPHOSTrackSegmentMakerv1.h"
{
// method called by AliReconstruction;
// Only the clusterization is performed,; the rest of the reconstruction is done in FillESD because the track
- // segment maker needs access to the AliESD object to retrieve the tracks reconstructed by
+ // segment maker needs access to the AliESDEvent object to retrieve the tracks reconstructed by
// the global tracking.
TString headerFile(runLoader->GetFileName()) ;
{
// method called by AliReconstruction;
// Only the clusterization is performed,; the rest of the reconstruction is done in FillESD because the track
- // segment maker needs access to the AliESD object to retrieve the tracks reconstructed by
+ // segment maker needs access to the AliESDEvent object to retrieve the tracks reconstructed by
// the global tracking.
// Here we reconstruct from Raw Data
}
//____________________________________________________________________________
-void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
+void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const
{
// This function creates AliESDtracks from AliPHOSRecParticles
// and
//____________________________________________________________________________
void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const
+ AliRawReader* rawReader, AliESDEvent* esd) const
{
//This function creates AliESDtracks from AliPHOSRecParticles
//and writes them to the ESD in the case of raw data reconstruction.
/* History of cvs commits:
*
* $Log$
+ * Revision 1.9 2006/11/15 16:05:03 kharlov
+ * New FillESD() for raw data is added
+ *
* Revision 1.8 2005/05/28 14:19:04 schutz
* Compilation warnings fixed by T.P.
*
class AliPHOSTrackSegmentMaker ;
class AliPHOSPID ;
class AliPHOSSDigitizer ;
-class AliESD ;
+class AliESDEvent ;
class AliRawReader;
// --- Standard library ---
static Bool_t Debug() { return fgDebug ; }
AliTracker *CreateTracker(AliRunLoader* runLoader) const;
using AliReconstructor::FillESD;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
- virtual void FillESD(AliRunLoader* runLoader,AliRawReader* rawReader,AliESD* esd) const;
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const ;
+ virtual void FillESD(AliRunLoader* runLoader,AliRawReader* rawReader,AliESDEvent* esd) const;
using AliReconstructor::Reconstruct;
virtual void Reconstruct(AliRunLoader* runLoader) const ;
virtual void Reconstruct(AliRunLoader* runLoader, AliRawReader * rawreader) const ;
/* History of cvs commits:
*
* $Log$
+ * Revision 1.40 2006/08/29 11:41:19 kharlov
+ * Missing implementation of ctors and = operator are added
+ *
* Revision 1.39 2006/08/25 16:00:53 kharlov
* Compliance with Effective C++AliPHOSHit.cxx
*
class AliPHOSClusterizer ;
class AliPHOSGeometry ;
-class AliESD ;
+class AliESDEvent ;
class AliPHOSTrackSegmentMaker : public TTask {
void SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
void SetEventFolderName(TString name) { fEventFolderName = name ; }
- void SetESD(AliESD *esd) { fESD = esd; }
+ void SetESD(AliESDEvent *esd) { fESD = esd; }
TString GetEventFolderName() const {return fEventFolderName;}
Int_t GetFirstEvent() const {return fFirstEvent; }
Int_t GetLastEvent() const {return fLastEvent; }
- AliESD *GetESD() const {return fESD; }
+ AliESDEvent *GetESD() const {return fESD; }
virtual void WriteTrackSegments() = 0;
TString fEventFolderName ; // event folder name
Int_t fFirstEvent; // first event to process
Int_t fLastEvent; // last event to process
- AliESD * fESD; //! ESD object
+ AliESDEvent * fESD; //! ESD object
- ClassDef( AliPHOSTrackSegmentMaker,4) // Algorithm class to make PHOS track segments (Base Class)
+ ClassDef( AliPHOSTrackSegmentMaker,5) // Algorithm class to make PHOS track segments (Base Class)
};
#endif // ALIPHOSTRACKSEGMENTMAKER_H
/* History of cvs commits:
*
* $Log$
+ * Revision 1.89 2007/07/03 08:13:04 kharlov
+ * Bug fix in CPV local coordinates
+ *
* Revision 1.88 2007/06/27 09:11:07 kharlov
* Bug fix for CPV-EMC distance
*
#include "AliPHOSTrackSegment.h"
#include "AliPHOSLink.h"
#include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp( AliPHOSTrackSegmentMakerv1)
/* History of cvs commits:
*
* $Log$
+ * Revision 1.4 2007/05/04 14:49:29 policheh
+ * AliPHOSRecPoint inheritance from AliCluster
+ *
* Revision 1.3 2007/04/25 19:39:42 kharlov
* Track extracpolation improved
*
#include "AliPHOSTrackSegment.h"
#include "AliPHOSLink.h"
#include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp( AliPHOSTrackSegmentMakerv2)
#include "AliPHOSTrackSegmentMakerv2.h"
#include "AliPHOSPIDv1.h"
#include "AliRunLoader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
//-------------------------------------------------------------------------
// PHOS tracker.
// Matches ESD tracks with the PHOS and makes the PID.
-// Currently, has only one function implemented : PropagateBack(AliESD*)
+// Currently, has only one function implemented : PropagateBack(AliESDEvent*)
//-------------------------------------------------------------------------
ClassImp(AliPHOSTracker)
Bool_t AliPHOSTracker::fgDebug = kFALSE ;
-Int_t AliPHOSTracker::PropagateBack(AliESD *esd) {
+Int_t AliPHOSTracker::PropagateBack(AliESDEvent *esd) {
// Called by AliReconstruction
// Creates the tracksegments and Recparticles
// Makes the PID
#include <AliLog.h>
class AliCluster;
-class AliESD;
+class AliESDEvent;
class TTree;
class AliRunLoader;
return *this;
}
- Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
- Int_t RefitInward(AliESD *) {AliDebug(1,"Start.");return 0;}
+ Int_t Clusters2Tracks(AliESDEvent *) {AliDebug(1,"Start.");return 0;}
+ Int_t RefitInward(AliESDEvent *) {AliDebug(1,"Start.");return 0;}
void UnloadClusters() {AliDebug(1,"Start.");}
AliCluster *GetCluster(Int_t ) const {AliDebug(1,"Start.");return 0;}
- Int_t PropagateBack(AliESD *);
+ Int_t PropagateBack(AliESDEvent *);
Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
static void SetDebug() { fgDebug = kTRUE ; }
#include "AliPMDtracker.h"
#include "AliRawReader.h"
#include "AliESDPmdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliLog.h"
ClassImp(AliPMDReconstructor)
// ------------------------------------------------------------------------ //
-//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESD* esd) const
+//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESDEvent* esd) const
//{
// AliLoader* loader = runLoader->GetLoader("PMDLoader");
// if (!loader) {
// ------------------------------------------------------------------------ //
void AliPMDReconstructor::FillESD(AliRawReader* /*rawReader*/,
- TTree* clustersTree, AliESD* esd) const
+ TTree* clustersTree, AliESDEvent* esd) const
{
AliPMDtracker pmdtracker;
pmdtracker.LoadClusters(clustersTree);
}
// ------------------------------------------------------------------------ //
void AliPMDReconstructor::FillESD(TTree * /*digitsTree*/,
- TTree* clustersTree, AliESD* esd) const
+ TTree* clustersTree, AliESDEvent* esd) const
{
AliPMDtracker pmdtracker;
pmdtracker.LoadClusters(clustersTree);
virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
- //virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ //virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree,
- AliESD* esd) const;
+ AliESDEvent* esd) const;
virtual void FillESD(TTree* /*digitsTree*/, TTree* clustersTree,
- AliESD* esd) const;
+ AliESDEvent* esd) const;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const {
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const {
AliReconstructor::FillESD(runLoader,esd);
}
virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const {
+ AliRawReader* rawReader, AliESDEvent* esd) const {
AliReconstructor::FillESD(runLoader,rawReader,esd);
}
#include "AliPMDtracker.h"
#include "AliESDPmdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliLog.h"
ClassImp(AliPMDtracker)
fTreeR = treein;
}
//--------------------------------------------------------------------//
-void AliPMDtracker::Clusters2Tracks(AliESD *event)
+void AliPMDtracker::Clusters2Tracks(AliESDEvent *event)
{
// Converts digits to recpoints after running clustering
// algorithm on CPV plane and PREshower plane
class AliPMDUtility;
class AliPMDDiscriminator;
-class AliESD;
+class AliESDEvent;
class AliPMDtracker:public TObject
{
virtual ~AliPMDtracker();
void LoadClusters(TTree *treein);
- void Clusters2Tracks(AliESD *event);
+ void Clusters2Tracks(AliESDEvent *event);
void SetVertex(Double_t vtx[3], Double_t evtx[3]);
void ResetClusters();
#include <TObject.h>
class AliRawEvent;
-class AliESD;
+class AliESDEvent;
class AliFilter: public TObject {
public:
- virtual Bool_t Filter(AliRawEvent* event, AliESD* esd) = 0;
+ virtual Bool_t Filter(AliRawEvent* event, AliESDEvent* esd) = 0;
private:
ClassDef(AliFilter, 0) // base class for high level filter algorithms
}
//_____________________________________________________________________________
-Bool_t AliHoughFilter::Filter(AliRawEvent* event, AliESD* esd)
+Bool_t AliHoughFilter::Filter(AliRawEvent* event, AliESDEvent* esd)
{
// Run fast online reconstruction
// based on the HLT tracking algorithms
//_____________________________________________________________________________
-void AliHoughFilter::RunITSvertexer(AliESD* esd, TTree *treeClusters)
+void AliHoughFilter::RunITSvertexer(AliESDEvent* esd, TTree *treeClusters)
{
// Run SPD vertexerZ
// Store the result in the ESD
}
//_____________________________________________________________________________
-void AliHoughFilter::RunTPCtracking(AliRawEvent* event, AliESD* esd)
+void AliHoughFilter::RunTPCtracking(AliRawEvent* event, AliESDEvent* esd)
{
// Run hough transform tracking in TPC
// The z of the vertex is taken from the ESD
}
//_____________________________________________________________________________
-void AliHoughFilter::RunITStracking(AliESD* esd, TTree *treeClusters)
+void AliHoughFilter::RunITStracking(AliESDEvent* esd, TTree *treeClusters)
{
// Run the ITS tracker
// The tracks from the HT TPC tracking are used as seeds
public:
AliHoughFilter();
- virtual Bool_t Filter(AliRawEvent* event, AliESD* esd);
+ virtual Bool_t Filter(AliRawEvent* event, AliESDEvent* esd);
void RunITSclusterer(AliRawEvent* event, TTree *treeClusters);
- void RunITSvertexer(AliESD* esd, TTree *treeClusters);
- void RunTPCtracking(AliRawEvent* event, AliESD* esd);
- void RunITStracking(AliESD* esd, TTree *treeClusters);
+ void RunITSvertexer(AliESDEvent* esd, TTree *treeClusters);
+ void RunTPCtracking(AliRawEvent* event, AliESDEvent* esd);
+ void RunITStracking(AliESDEvent* esd, TTree *treeClusters);
private:
AliHoughFilter(const AliHoughFilter&);
AliHoughFilter &operator=(const AliHoughFilter&);
#include "libDateEb.h"
#endif
+#include "AliMDC.h"
+
#include <AliLog.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include "AliRawEvent.h"
#include "AliRawEventHeaderBase.h"
#include "AliRawEventTag.h"
#include "AliFilter.h"
-#include "AliMDC.h"
+
ClassImp(AliMDC)
"TStreamerInfo()");
if (fFilterMode != kFilterOff) {
- fESD = new AliESD;
+ fESD = new AliESDEvent();
}
// Create the guid files folder if it does not exist
class AliTagDB;
class AliRawEventTag;
class AliStats;
-class AliESD;
+class AliESDEvent;
+
+#include "AliRawEvent.h"
+#include "AliESDEvent.h"
+#include "AliStats.h"
+#include "AliRawDB.h"
+#include "AliTagDB.h"
+#include "AliRawData.h"
+#include "AliRawDataArray.h"
+#include "AliRawEventTag.h"
class AliMDC : public TObject {
};
AliRawEvent *fEvent; // produced AliRawEvent
- AliESD *fESD; // pointer to HLT ESD object
+ AliESDEvent *fESD; // pointer to HLT ESD object
AliStats *fStats; // statistics
AliRawDB *fRawDB; // raw data DB
AliTagDB *fTagDB; // tag DB
Bool_t isSwapped, char*& data);
Int_t ReadRawData(AliRawData &raw, Int_t size, char*& data);
- ClassDef(AliMDC,0) // MDC processor
+ ClassDef(AliMDC,1) // MDC processor
};
#endif
//______________________________________________________________________________
AliRawCastorDB::AliRawCastorDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName)
: AliRawDB(event, esd, compress, fileName)
public:
AliRawCastorDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName = NULL);
~AliRawCastorDB() { Close(); }
#include <TObjString.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliRawEvent.h"
#include "AliRawDataArray.h"
#include "AliRawEventHeaderBase.h"
//______________________________________________________________________________
AliRawDB::AliRawDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName) :
fRawDB(NULL),
fESDTree = new TTree("esdTree", Form("ALICE HLT ESD tree (%s)", GetAliRootTag()));
fESDTree->SetAutoSave(2000000000); // autosave when 2 Gbyte written
split = 0;
- fESDTree->Branch("ESD", "AliESD", &fESD, bufsize, split);
+ fESDTree->Branch("ESD", "AliESDEvent", &fESD, bufsize, split);
}
}
class AliRawDataArray;
class AliStats;
class TFile;
-class AliESD;
+class AliESDEvent;
class AliRawDB : public TObject {
public:
AliRawDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName = NULL);
virtual ~AliRawDB();
AliRawEvent *fEvent; // AliRawEvent via which data is stored
AliRawDataArray *fDetRawData[AliDAQ::kNDetectors+1]; // Detectors raw-data payload
TTree *fESDTree; // tree for storing HLT ESD information
- AliESD *fESD; // pointer to HLT ESD object
+ AliESDEvent *fESD; // pointer to HLT ESD object
Int_t fCompress; // compression mode (1 default)
Double_t fMaxSize; // maximum size in bytes of the raw DB
TString fFS1; // first raw DB file system location
AliRawDB(const AliRawDB& rawDB);
AliRawDB& operator = (const AliRawDB& rawDB);
- ClassDef(AliRawDB,0) // Raw DB
+ ClassDef(AliRawDB,1) // Raw DB
};
#endif
//______________________________________________________________________________
AliRawNullDB::AliRawNullDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName)
: AliRawDB(event, esd, compress, fileName)
public:
AliRawNullDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName);
~AliRawNullDB() { Close(); }
//______________________________________________________________________________
AliRawRFIODB::AliRawRFIODB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName)
: AliRawDB(event, esd, compress, fileName)
public:
AliRawRFIODB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName = NULL);
~AliRawRFIODB() { Close(); }
//______________________________________________________________________________
AliRawRootdDB::AliRawRootdDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName)
: AliRawDB(event, esd, compress, fileName)
public:
AliRawRootdDB(AliRawEvent *event,
- AliESD *esd,
+ AliESDEvent *esd,
Int_t compress,
const char* fileName = NULL);
~AliRawRootdDB() { Close(); }
#include <TObjArray.h>
#include <TTree.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDv0.h"
#include "AliESDcascade.h"
#include "AliCascadeVertexer.h"
AliCascadeVertexer::fgRmax=100.; //max radius of the fiducial volume
-Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESD *event) {
+Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESDEvent *event) {
//--------------------------------------------------------------------
// This function reconstructs cascade vertices
// Adapted to the ESD by I.Belikov (Jouri.Belikov@cern.ch)
#include "TObject.h"
-class AliESD;
+class AliESDEvent;
class TTree;
class AliESDv0;
class AliExternalTrackParam;
void SetCuts(const Double_t cuts[8]);
static void SetDefaultCuts(const Double_t cuts[8]);
- Int_t V0sTracks2CascadeVertices(AliESD *event);
+ Int_t V0sTracks2CascadeVertices(AliESDEvent *event);
Double_t PropagateToDCA(AliESDv0 *vtx,AliExternalTrackParam *trk,Double_t b);
void GetCuts(Double_t cuts[8]) const;
// 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),
+ fEventNumberInFile(0),
+ fBunchCrossNumber(0),
+ fOrbitNumber(0),
+ fPeriodNumber(0),
+ fRunNumber(0),
+ fTimeStamp(0),
+ fEventType(0),
+ fTriggerMask(0),
+ fTriggerCluster(0),
+ fRecoVersion(0),
+ fMagneticField(0),
+ fZDCN1Energy(0),
+ fZDCP1Energy(0),
+ fZDCN2Energy(0),
+ fZDCP2Energy(0),
+ fZDCEMEnergy(0),
+ fZDCParticipants(0),
+ fT0zVertex(0),
+ fSPDVertex(),
+ fPrimaryVertex(),
+ fSPDMult(),
+ fT0timeStart(0),
+ fTracks("AliESDtrack",15000),
+ fHLTConfMapTracks("AliESDHLTtrack",25000),
+ fHLTHoughTracks("AliESDHLTtrack",15000),
+ fMuonTracks("AliESDMuonTrack",30),
+ fPmdTracks("AliESDPmdTrack",3000),
+ fTrdTracks("AliESDTrdTrack",300),
+ fV0s("AliESDv0",200),
+ fCascades("AliESDcascade",20),
+ fKinks("AliESDkink",4000),
+ fCaloClusters("AliESDCaloCluster",10000),
fEMCALClusters(0),
fFirstEMCALCluster(-1),
+ fEMCALTriggerPosition(0x0),
+ fEMCALTriggerAmplitudes(0x0),
fPHOSClusters(0),
- fFirstPHOSCluster(-1)
+ fFirstPHOSCluster(-1),
+ fPHOSTriggerPosition(0x0),
+ fPHOSTriggerAmplitudes(0x0),
+ fESDFMD(0x0),
+ fESDVZERO(0x0),
+ fErrorLogs("AliRawDataErrorLog",5)
+
{
+ for (Int_t i=0; i<24; i++) {
+ fT0time[i] = 0;
+ fT0amplitude[i] = 0;
+ }
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
}
//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
TObject(esd),
- fESDObjects(new TList()),
- fESDRun(new AliESDRun(*esd.fESDRun)),
- fHeader(new AliESDHeader(*esd.fHeader)),
- fESDZDC(new AliESDZDC(*esd.fESDZDC)),
- fESDFMD(new AliESDFMD(*esd.fESDFMD)),
- fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
- fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
- fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
- fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
- fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
- fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
- fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
- fTracks(new TClonesArray(*esd.fTracks)),
- fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
- fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
- fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
- fV0s(new TClonesArray(*esd.fV0s)),
- fCascades(new TClonesArray(*esd.fCascades)),
- fKinks(new TClonesArray(*esd.fKinks)),
- fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
- fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
+ fEventNumberInFile(esd.fEventNumberInFile),
+ fBunchCrossNumber(esd.fBunchCrossNumber),
+ fOrbitNumber(esd.fOrbitNumber),
+ fPeriodNumber(esd.fPeriodNumber),
+ fRunNumber(esd.fRunNumber),
+ fTimeStamp(esd.fTimeStamp),
+ fEventType(esd.fEventType),
+ fTriggerMask(esd.fTriggerMask),
+ fTriggerCluster(esd.fTriggerCluster),
+ fRecoVersion(esd.fRecoVersion),
+ fMagneticField(esd.fMagneticField),
+ fZDCN1Energy(esd.fZDCN1Energy),
+ fZDCP1Energy(esd.fZDCP1Energy),
+ fZDCN2Energy(esd.fZDCN2Energy),
+ fZDCP2Energy(esd.fZDCP2Energy),
+ fZDCEMEnergy(esd.fZDCEMEnergy),
+ fZDCParticipants(esd.fZDCParticipants),
+ fT0zVertex(esd.fT0zVertex),
+ fSPDVertex(esd.fSPDVertex),
+ fPrimaryVertex(esd.fPrimaryVertex),
+ fSPDMult(esd.fSPDMult),
+ fT0timeStart(esd.fT0timeStart),
+ fTracks(*((TClonesArray*)esd.fTracks.Clone())),
+ fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
+ fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
+ fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
+ fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
+ fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
+ fV0s(*((TClonesArray*)esd.fV0s.Clone())),
+ fCascades(*((TClonesArray*)esd.fCascades.Clone())),
+ fKinks(*((TClonesArray*)esd.fKinks.Clone())),
+ fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
fEMCALClusters(esd.fEMCALClusters),
fFirstEMCALCluster(esd.fFirstEMCALCluster),
+ fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
+ fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
fPHOSClusters(esd.fPHOSClusters),
- fFirstPHOSCluster(esd.fFirstPHOSCluster)
-
+ fFirstPHOSCluster(esd.fFirstPHOSCluster),
+ fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
+ fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
+ fESDFMD(esd.fESDFMD),
+ fESDVZERO(esd.fESDVZERO),
+ fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
{
- // CKB init in the constructor list and only add here ...
- AddObject(fESDRun);
- AddObject(fHeader);
- AddObject(fESDZDC);
- AddObject(fESDFMD);
- AddObject(fESDVZERO);
- AddObject(fESDTZERO);
- AddObject(fSPDVertex);
- AddObject(fPrimaryVertex);
- AddObject(fSPDMult);
- AddObject(fPHOSTrigger);
- AddObject(fEMCALTrigger);
- AddObject(fTracks);
- AddObject(fMuonTracks);
- AddObject(fPmdTracks);
- AddObject(fTrdTracks);
- AddObject(fV0s);
- AddObject(fCascades);
- AddObject(fKinks);
- AddObject(fCaloClusters);
- AddObject(fErrorLogs);
-
- GetStdContent();
-
+ for (Int_t i=0; i<24; i++) {
+ fT0time[i] = esd.fT0time[i];
+ fT0amplitude[i] = esd.fT0amplitude[i];
+ }
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
}
//______________________________________________________________________________
// 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);
-
+ fEventNumberInFile = source.fEventNumberInFile;
+ fBunchCrossNumber = source.fBunchCrossNumber;
+ fOrbitNumber = source.fOrbitNumber;
+ fPeriodNumber = source.fPeriodNumber;
+ fRunNumber = source.fRunNumber;
+ fTimeStamp = source.fTimeStamp;
+ fEventType = source.fEventType;
+ fTriggerMask = source.fTriggerMask;
+ fTriggerCluster = source.fTriggerCluster;
+ fRecoVersion = source.fRecoVersion;
+ fMagneticField = source.fMagneticField;
+ fZDCN1Energy = source.fZDCN1Energy;
+ fZDCP1Energy = source.fZDCP1Energy;
+ fZDCN2Energy = source.fZDCN2Energy;
+ fZDCP2Energy = source.fZDCP2Energy;
+ fZDCEMEnergy = source.fZDCEMEnergy;
+ fZDCParticipants = source.fZDCParticipants;
+ fT0zVertex = source.fT0zVertex;
+ fSPDVertex = source.fSPDVertex;
+ fPrimaryVertex = source.fPrimaryVertex;
+ fSPDMult = source.fSPDMult;
+ fT0timeStart = source.fT0timeStart;
+ fTracks = *((TClonesArray*)source.fTracks.Clone());
+ fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
+ fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
+ fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
+ fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
+ fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
+ fV0s = *((TClonesArray*)source.fV0s.Clone());
+ fCascades = *((TClonesArray*)source.fCascades.Clone());
+ fKinks = *((TClonesArray*)source.fKinks.Clone());
+ fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
fEMCALClusters = source.fEMCALClusters;
fFirstEMCALCluster = source.fFirstEMCALCluster;
fPHOSClusters = source.fPHOSClusters;
fFirstPHOSCluster = source.fFirstPHOSCluster;
-
-
+ fESDFMD = source.fESDFMD;
+ fESDVZERO = source.fESDVZERO;
+ fEMCALTriggerPosition=source. fEMCALTriggerPosition;
+ fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
+ fPHOSTriggerPosition=source.fPHOSTriggerPosition;
+ fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
+ fErrorLogs = *((TClonesArray*)source.fErrorLogs.Clone());
+
+ for (Int_t i=0; i<24; i++) {
+ fT0time[i] = source.fT0time[i];
+ fT0amplitude[i] = source.fT0amplitude[i];
+ }
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=source.fDiamondXY[i];
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=source.fDiamondCovXY[i];
return *this;
//
// Standard destructor
//
-
- delete fESDObjects;
- fESDObjects = 0;
-
- // everthing on the list gets deleted automatically
-
- /*
+ fTracks.Delete();
fHLTConfMapTracks.Delete();
fHLTHoughTracks.Delete();
- fMuonTracks.Delete();
+ fMuonTracks.Delete();
fPmdTracks.Delete();
fTrdTracks.Delete();
fV0s.Delete();
fCascades.Delete();
fKinks.Delete();
fCaloClusters.Delete();
- */
+ delete fESDFMD;
+ delete fESDVZERO;
// fEMCALTriggerPosition->Delete();
// fEMCALTriggerAmplitudes->Delete();
// fPHOSTriggerPosition->Delete();
// delete fEMCALTriggerAmplitudes;
// delete fPHOSTriggerPosition;
// delete fPHOSTriggerAmplitudes;
+ fErrorLogs.Delete();
}
//______________________________________________________________________________
void AliESD::Reset()
{
- // Reset the standard contents
- if(fESDRun) fESDRun->Reset();
- if(fHeader) fHeader->Reset();
- if(fESDZDC) fESDZDC->Reset();
- if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
- // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
- // if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
- if(fESDTZERO) fESDTZERO->Reset();
- // CKB no clear/reset implemented
- if(fSPDVertex){
- new (fSPDVertex) AliESDVertex();
- fSPDVertex->SetName("SPDVertex");
- }
- if(fPrimaryVertex){
- new (fPrimaryVertex) AliESDVertex();
- fPrimaryVertex->SetName("PrimaryVertex");
- }
- if(fSPDMult)new (fSPDMult) AliMultiplicity();
- if(fPHOSTrigger)fPHOSTrigger->Reset();
- if(fEMCALTrigger)fEMCALTrigger->Reset();
- if(fTracks)fTracks->Clear();
- if(fMuonTracks)fMuonTracks->Clear();
- if(fPmdTracks)fPmdTracks->Clear();
- if(fTrdTracks)fTrdTracks->Clear();
- if(fV0s)fV0s->Clear();
- if(fCascades)fCascades->Clear();
- if(fKinks)fKinks->Clear();
- if(fCaloClusters)fCaloClusters->Clear();
- if(fErrorLogs) fErrorLogs->Clear();
-
-
+ fEventNumberInFile=0;
+ fBunchCrossNumber=0;
+ fOrbitNumber=0;
+ fPeriodNumber=0;
+ fRunNumber=0;
+ fTimeStamp = 0;
+ fEventType = 0;
+ fTriggerMask=0;
+ fTriggerCluster=0;
+ fRecoVersion=0;
+ fMagneticField=0;
+ fZDCN1Energy=0;
+ fZDCP1Energy=0;
+ fZDCN2Energy=0;
+ fZDCP2Energy=0;
+ fZDCEMEnergy=0;
+ fZDCParticipants=0;
+ fT0zVertex=0;
+ fT0timeStart = 0;
+ new (&fSPDVertex) AliESDVertex();
+ new (&fPrimaryVertex) AliESDVertex();
+ new (&fSPDMult) AliMultiplicity();
+ fTracks.Clear();
+ fHLTConfMapTracks.Clear();
+ fHLTHoughTracks.Clear();
+ fMuonTracks.Clear();
+ fPmdTracks.Clear();
+ fTrdTracks.Clear();
+ fV0s.Clear();
+ fCascades.Clear();
+ fCaloClusters.Clear();
fEMCALClusters=0;
fFirstEMCALCluster=-1;
fPHOSClusters=0;
fFirstPHOSCluster=-1;
+ if (fESDFMD) fESDFMD->Clear();
+// fEMCALTriggerPosition->Clear();
+// fEMCALTriggerAmplitudes->Clear();
+// fPHOSTriggerPosition->Clear();
+// fPHOSTriggerAmplitudes->Clear();
+ fErrorLogs.Clear();
}
Int_t AliESD::AddV0(const AliESDv0 *v) {
//
// Add V0
//
- TClonesArray &fv = *fV0s;
- Int_t idx=fV0s->GetEntriesFast();
- new(fv[idx]) AliESDv0(*v);
- return idx;
+ Int_t idx=fV0s.GetEntriesFast();
+ new(fV0s[idx]) AliESDv0(*v);
+ return idx;
}
//______________________________________________________________________________
GetRunNumber(),
GetTriggerMask(),
GetMagneticField() );
- printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
- fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
- fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
- fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
+ printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
+ fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
+ fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
+ fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
GetDiamondX(),GetDiamondY());
printf("SPD Multiplicity. Number of tracklets %d \n",
- fSPDMult->GetNumberOfTracklets());
+ fSPDMult.GetNumberOfTracklets());
+ printf("Event from reconstruction version %d \n",fRecoVersion);
printf("Number of tracks: \n");
printf(" charged %d\n", GetNumberOfTracks());
+ printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks());
+ printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks());
printf(" muon %d\n", GetNumberOfMuonTracks());
printf(" pmd %d\n", GetNumberOfPmdTracks());
printf(" trd %d\n", GetNumberOfTrdTracks());
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
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();
-}
-
-
-
#include <TClonesArray.h>
#include <TObject.h>
-#include <TTree.h>
#include <TArrayF.h>
-class TList;
-
-
#include "AliESDMuonTrack.h"
#include "AliESDPmdTrack.h"
#include "AliESDTrdTrack.h"
#include "AliESDcascade.h"
#include "AliESDkink.h"
#include "AliESDtrack.h"
+#include "AliESDHLTtrack.h"
#include "AliESDCaloCluster.h"
#include "AliESDv0.h"
#include "AliESDFMD.h"
#include "AliESDVZERO.h"
#include "AliMultiplicity.h"
#include "AliRawDataErrorLog.h"
-#include "AliESDRun.h"
-#include "AliESDHeader.h"
-#include "AliESDZDC.h"
-#include "AliESDTZERO.h"
-#include "AliESDCaloTrigger.h"
class AliESDfriend;
-class AliESDVZERO;
-class AliESDHLTtrack;
-class AliESDFMD;
class AliESD : public TObject {
public:
-
-
- enum ESDListIndex_t {kESDRun,
- kHeader,
- kESDZDC,
- kESDFMD,
- kESDVZERO,
- kESDTZERO,
- kSPDVertex,
- kPrimaryVertex,
- kSPDMult,
- kPHOSTrigger,
- kEMCALTrigger,
- kTracks,
- kMuonTracks,
- kPmdTracks,
- kTrdTracks,
- kV0s,
- kCascades,
- kKinks,
- kCaloClusters,
- kErrorLogs,
- kESDListN
- };
-
AliESD();
virtual ~AliESD();
-
- // RUN
- // move this to the UserData!!!
- const AliESDRun* GetESDRun() const {return fESDRun;}
-
- // Delegated methods for fESDRun
- void SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
- Int_t GetRunNumber() const {return fESDRun->GetRunNumber();}
- void SetPeriodNumber(Int_t n){fESDRun->SetPeriodNumber(n);}
- Int_t GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
- void SetMagneticField(Float_t mf){fESDRun->SetMagneticField(mf);}
- Float_t GetMagneticField() const {return fESDRun->GetMagneticField();}
- void SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
- Float_t GetDiamondX() const {return fESDRun->GetDiamondX();}
- Float_t GetDiamondY() const {return fESDRun->GetDiamondY();}
- Float_t GetSigma2DiamondX() const {return fESDRun->GetSigma2DiamondX();}
- Float_t GetSigma2DiamondY() const {return fESDRun->GetSigma2DiamondY();}
- void GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}
-
-
- // HEADER
- const AliESDHeader* GetHeader() const {return fHeader;}
-
- // Delegated methods for fHeader
- void SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
- void SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
- 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 SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
- void SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
- ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
- UInt_t GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
- UInt_t GetTimeStamp() const { return fHeader->GetTimeStamp();}
- UInt_t GetEventType() const { return fHeader->GetEventType();}
- Int_t GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
- UShort_t GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
- UChar_t GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
-
- // ZDC CKB: put this in the header?
- const AliESDZDC* GetESDZDC() const {return fESDZDC;}
-
- // Delegated methods for fESDZDC
- Float_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
- Float_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
- Float_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
- Float_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
- Float_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
- Int_t GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
- void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
- Float_t n2Energy, Float_t p2Energy, Int_t participants)
- {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, n2Energy, p2Energy, participants);}
-
-
- // FMD
- void SetFMDData(AliESDFMD * obj);
- AliESDFMD *GetFMDData(){ return fESDFMD; }
-
-
- // TZERO CKB: put this in the header?
- const AliESDTZERO* GetESDTZERO() const {return fESDTZERO;}
- // delegetated methods for fESDTZERO
-
- Float_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
- void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
- Float_t GetT0() const {return fESDTZERO->GetT0();}
- void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
- const Float_t * GetT0time() const {return fESDTZERO->GetT0time();}
- void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
- const Float_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
- void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
-
- // VZERO
- AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
- void SetVZEROData(AliESDVZERO * obj);
-
-
void SetESDfriend(const AliESDfriend *f);
void GetESDfriend(AliESDfriend *f) const;
-
-
- void SetVertex(const AliESDVertex *vertex) {
- *fSPDVertex = *vertex;
- fSPDVertex->SetName("fSPDVertex");// error prone use class wide names?
- //CKB or new with placement
+ void SetEventNumberInFile(Int_t n) {fEventNumberInFile=n;}
+ void SetBunchCrossNumber(UShort_t n) {fBunchCrossNumber=n;}
+ void SetOrbitNumber(UInt_t n) {fOrbitNumber=n;}
+ void SetPeriodNumber(UInt_t n) {fPeriodNumber=n;}
+ void SetRunNumber(Int_t n) {fRunNumber=n;}
+ void SetTimeStamp(UInt_t timeStamp){fTimeStamp = timeStamp;}
+ void SetEventType(UInt_t eventType){fEventType = eventType;}
+ void SetTriggerMask(ULong64_t n) {fTriggerMask=n;}
+ void SetTriggerCluster(UChar_t n) {fTriggerCluster = n;}
+ void SetMagneticField(Float_t mf){fMagneticField = mf;}
+ Float_t GetMagneticField() const {return fMagneticField;}
+
+ AliESDtrack *GetTrack(Int_t i) const {
+ return (AliESDtrack *)fTracks.UncheckedAt(i);
}
- const AliESDVertex *GetVertex() const {return fSPDVertex;}
-
- void SetPrimaryVertex(const AliESDVertex *vertex) {
- *fPrimaryVertex = *vertex;
- fPrimaryVertex->SetName("fPrimaryVertex");// error prone use class wide names?
+ AliESDHLTtrack *GetHLTConfMapTrack(Int_t i) const {
+ return (AliESDHLTtrack *)fHLTConfMapTracks.UncheckedAt(i);
}
- const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}
-
- void SetMultiplicity(const AliMultiplicity *mul) {
- *fSPDMult = *mul;
- // CKB
- // new (&fSPDMult) AliMultiplicity(*mul);
+ AliESDHLTtrack *GetHLTHoughTrack(Int_t i) const {
+ return (AliESDHLTtrack *)fHLTHoughTracks.UncheckedAt(i);
}
- const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
-
- AliESDtrack *GetTrack(Int_t i) const {
- return (AliESDtrack *)fTracks->UncheckedAt(i);
+ AliESDMuonTrack *GetMuonTrack(Int_t i) const {
+ return (AliESDMuonTrack *)fMuonTracks.UncheckedAt(i);
}
- Int_t AddTrack(const AliESDtrack *t);
-
-
- AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
- // return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
- return 0;
+ AliESDPmdTrack *GetPmdTrack(Int_t i) const {
+ return (AliESDPmdTrack *)fPmdTracks.UncheckedAt(i);
}
- void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
- printf("ESD:: AddHLTConfMapTrack do nothing \n");
- // TClonesArray &fhlt = *fHLTConfMapTracks;
- // new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+ AliESDTrdTrack *GetTrdTrack(Int_t i) const {
+ return (AliESDTrdTrack *)fTrdTracks.UncheckedAt(i);
}
-
- AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
- // return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
- return 0;
+ Int_t AddTrack(const AliESDtrack *t) {
+ AliESDtrack * track = new(fTracks[fTracks.GetEntriesFast()]) AliESDtrack(*t);
+ track->SetID(fTracks.GetEntriesFast()-1);
+ return track->GetID();
+
}
- void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
- printf("ESD:: AddHLTHoughTrack do nothing \n");
- // TClonesArray &fhlt = *fHLTHoughTracks;
- // new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+ void AddHLTConfMapTrack(const AliESDHLTtrack *t) {
+ new(fHLTConfMapTracks[fHLTConfMapTracks.GetEntriesFast()]) AliESDHLTtrack(*t);
}
-
- AliESDMuonTrack *GetMuonTrack(Int_t i) const {
- return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
+ void AddHLTHoughTrack(const AliESDHLTtrack *t) {
+ new(fHLTHoughTracks[fHLTHoughTracks.GetEntriesFast()]) AliESDHLTtrack(*t);
}
void AddMuonTrack(const AliESDMuonTrack *t) {
- TClonesArray &fmu = *fMuonTracks;
- new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
- }
-
- AliESDPmdTrack *GetPmdTrack(Int_t i) const {
- return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
+ new(fMuonTracks[fMuonTracks.GetEntriesFast()]) AliESDMuonTrack(*t);
}
void AddPmdTrack(const AliESDPmdTrack *t) {
- TClonesArray &fpmd = *fPmdTracks;
- new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
- }
-
- AliESDTrdTrack *GetTrdTrack(Int_t i) const {
- return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
+ new(fPmdTracks[fPmdTracks.GetEntriesFast()]) AliESDPmdTrack(*t);
}
void AddTrdTrack(const AliESDTrdTrack *t) {
- TClonesArray &ftrd = *fTrdTracks;
- new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
+ new(fTrdTracks[fTrdTracks.GetEntriesFast()]) AliESDTrdTrack(*t);
}
AliESDv0 *GetV0(Int_t i) const {
- return (AliESDv0*)fV0s->UncheckedAt(i);
+ return (AliESDv0 *)fV0s.UncheckedAt(i);
}
Int_t AddV0(const AliESDv0 *v);
AliESDcascade *GetCascade(Int_t i) const {
- return (AliESDcascade *)fCascades->UncheckedAt(i);
+ return (AliESDcascade *)fCascades.UncheckedAt(i);
}
void AddCascade(const AliESDcascade *c) {
- TClonesArray &fc = *fCascades;
- new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
+ new(fCascades[fCascades.GetEntriesFast()]) AliESDcascade(*c);
}
AliESDkink *GetKink(Int_t i) const {
- return (AliESDkink *)fKinks->UncheckedAt(i);
+ return (AliESDkink *)fKinks.UncheckedAt(i);
+ }
+ Int_t AddKink(const AliESDkink *c) {
+ AliESDkink * kink = new(fKinks[fKinks.GetEntriesFast()]) AliESDkink(*c);
+ kink->SetID(fKinks.GetEntriesFast());
+ return fKinks.GetEntriesFast()-1;
}
- Int_t AddKink(const AliESDkink *c);
AliESDCaloCluster *GetCaloCluster(Int_t i) const {
- return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
+ return (AliESDCaloCluster *)fCaloClusters.UncheckedAt(i);
+ }
+ Int_t AddCaloCluster(const AliESDCaloCluster *c) {
+ AliESDCaloCluster *clus = new(fCaloClusters[fCaloClusters.GetEntriesFast()]) AliESDCaloCluster(*c);
+ clus->SetID(fCaloClusters.GetEntriesFast()-1);
+ return fCaloClusters.GetEntriesFast()-1;
}
- Int_t AddCaloCluster(const AliESDCaloCluster *c);
+
+ void AddPHOSTriggerPosition(TArrayF array) { fPHOSTriggerPosition = new TArrayF(array) ; }
+ void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTriggerAmplitudes = new TArrayF(array) ; }
+ void AddEMCALTriggerPosition(TArrayF array) { fEMCALTriggerPosition = new TArrayF(array) ; }
+ void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTriggerAmplitudes = new TArrayF(array) ; }
- AliRawDataErrorLog *GetErrorLog(Int_t i) const {
- return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
+ void SetVertex(const AliESDVertex *vertex) {
+ new (&fSPDVertex) AliESDVertex(*vertex);
}
- void AddRawDataErrorLog(const AliRawDataErrorLog *log) {
- // CKB inline this??
- TClonesArray &errlogs = *fErrorLogs;
- new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
+ const AliESDVertex *GetVertex() const {return &fSPDVertex;}
+
+ void SetMultiplicity(const AliMultiplicity *mul) {
+ new (&fSPDMult) AliMultiplicity(*mul);
}
- Int_t GetNumberOfErrorLogs() const {return fErrorLogs->GetEntriesFast();}
+ const AliMultiplicity *GetMultiplicity() const {return &fSPDMult;}
-
- void AddPHOSTriggerPosition(TArrayF array) { fPHOSTrigger->AddTriggerPosition(array); }
- void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
- void AddEMCALTriggerPosition(TArrayF array) { fEMCALTrigger->AddTriggerPosition(array); }
- void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
-
-
- Int_t GetNumberOfTracks() const {return fTracks->GetEntriesFast();}
- Int_t GetNumberOfHLTConfMapTracks() const {return 0;}
- // fHLTConfMapTracks->GetEntriesFast();}
- Int_t GetNumberOfHLTHoughTracks() const {return 0; }
- // fHLTHoughTracks->GetEntriesFast(); }
-
- Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
- Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
- Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
- Int_t GetNumberOfV0s() const {return fV0s->GetEntriesFast();}
- Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
- Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
- Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
+ void SetPrimaryVertex(const AliESDVertex *vertex) {
+ new (&fPrimaryVertex) AliESDVertex(*vertex);
+ }
+ const AliESDVertex *GetPrimaryVertex() const {return &fPrimaryVertex;}
+
+ void SetDiamond(const AliESDVertex *vertex) {
+ fDiamondXY[0]=vertex->GetXv();
+ fDiamondXY[1]=vertex->GetYv();
+ Double_t cov[6];
+ vertex->GetCovMatrix(cov);
+ fDiamondCovXY[0]=cov[0];
+ fDiamondCovXY[1]=cov[1];
+ fDiamondCovXY[2]=cov[2];
+ }
+ Float_t GetDiamondX() const {return fDiamondXY[0];}
+ Float_t GetDiamondY() const {return fDiamondXY[1];}
+ Float_t GetSigma2DiamondX() const {return fDiamondCovXY[0];}
+ Float_t GetSigma2DiamondY() const {return fDiamondCovXY[2];}
+ void GetDiamondCovXY(Float_t cov[3]) const {
+ for(Int_t i=0;i<3;i++) cov[i]=fDiamondCovXY[i]; return;
+ }
+
+ Int_t GetEventNumberInFile() const {return fEventNumberInFile;}
+ UShort_t GetBunchCrossNumber() const {return fBunchCrossNumber;}
+ UInt_t GetOrbitNumber() const {return fOrbitNumber;}
+ UInt_t GetPeriodNumber() const {return fPeriodNumber;}
+ Int_t GetRunNumber() const {return fRunNumber;}
+ UInt_t GetTimeStamp() const { return fTimeStamp;}
+ UInt_t GetEventType() const { return fEventType;}
+ ULong64_t GetTriggerMask() const {return fTriggerMask;}
+ UChar_t GetTriggerCluster() const {return fTriggerCluster;}
+
+ Int_t GetNumberOfTracks() const {return fTracks.GetEntriesFast();}
+ Int_t GetNumberOfHLTConfMapTracks() const {return fHLTConfMapTracks.GetEntriesFast();}
+ Int_t GetNumberOfHLTHoughTracks() const {return fHLTHoughTracks.GetEntriesFast();}
+ Int_t GetNumberOfMuonTracks() const {return fMuonTracks.GetEntriesFast();}
+ Int_t GetNumberOfPmdTracks() const {return fPmdTracks.GetEntriesFast();}
+ Int_t GetNumberOfTrdTracks() const {return fTrdTracks.GetEntriesFast();}
+ Int_t GetNumberOfV0s() const {return fV0s.GetEntriesFast();}
+ Int_t GetNumberOfCascades() const {return fCascades.GetEntriesFast();}
+ Int_t GetNumberOfKinks() const {return fKinks.GetEntriesFast();}
+ Int_t GetNumberOfCaloClusters() const {return fCaloClusters.GetEntriesFast();}
Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
void SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
void SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
- TArrayF *GetEMCALTriggerPosition() const {return fEMCALTrigger->GetTriggerPosition();}
- TArrayF *GetEMCALTriggerAmplitudes() const {return fEMCALTrigger->GetTriggerAmplitudes();}
+ TArrayF *GetEMCALTriggerPosition() const {return fEMCALTriggerPosition;}
+ TArrayF *GetEMCALTriggerAmplitudes() const {return fEMCALTriggerAmplitudes;}
Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
void SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
void SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; }
Int_t GetFirstPHOSCluster() const { return fFirstPHOSCluster ; }
- TArrayF *GetPHOSTriggerPosition() const {return fPHOSTrigger->GetTriggerPosition();}
- TArrayF *GetPHOSTriggerAmplitudes() const {return fPHOSTrigger->GetTriggerAmplitudes();}
+ TArrayF *GetPHOSTriggerPosition() const {return fPHOSTriggerPosition;}
+ TArrayF *GetPHOSTriggerAmplitudes() const {return fPHOSTriggerAmplitudes;}
+
+
+ Float_t GetT0zVertex() const {return fT0zVertex;}
+ void SetT0zVertex(Float_t z) {fT0zVertex=z;}
+ Float_t GetT0() const {return fT0timeStart;}
+ void SetT0(Float_t timeStart) {fT0timeStart = timeStart;}
+ const Float_t * GetT0time() const {return fT0time;}
+ void SetT0time(Float_t time[24]) {
+ for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
+ }
+ const Float_t * GetT0amplitude() const {return fT0amplitude;}
+ void SetT0amplitude(Float_t amp[24]) {
+ for (Int_t i=0; i<24; i++) fT0amplitude[i] = amp[i];
+ }
+
+ Float_t GetZDCN1Energy() const {return fZDCN1Energy;}
+ Float_t GetZDCP1Energy() const {return fZDCP1Energy;}
+ Float_t GetZDCN2Energy() const {return fZDCN2Energy;}
+ Float_t GetZDCP2Energy() const {return fZDCP2Energy;}
+ Float_t GetZDCEMEnergy() const {return fZDCEMEnergy;}
+ Int_t GetZDCParticipants() const {return fZDCParticipants;}
+ void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
+ Float_t n2Energy, Float_t p2Energy, Int_t participants)
+ {fZDCN1Energy=n1Energy; fZDCP1Energy=p1Energy; fZDCEMEnergy=emEnergy;
+ fZDCN2Energy=n2Energy; fZDCP2Energy=p2Energy; fZDCParticipants=participants;}
- void ResetV0s() { fV0s->Clear(); }
- void ResetCascades() { fCascades->Clear(); }
+ void ResetV0s() { fV0s.Clear(); }
+ void ResetCascades() { fCascades.Clear(); }
void Reset();
void Print(Option_t *option="") const;
- void AddObject(TObject* obj);
- void ReadFromTree(TTree *tree);
- const void WriteToTree(TTree* tree) const {tree->Branch(fESDObjects);}
- void GetStdContent();
- void CreateStdContent();
- void SetStdNames();
- TList* GetList(){return fESDObjects;}
+ void SetFMDData(AliESDFMD * obj) { fESDFMD = new AliESDFMD(*obj); }
+ AliESDFMD *GetFMDData(){ return fESDFMD; }
+
+ void SetVZEROData(AliESDVZERO * obj) { fESDVZERO = new AliESDVZERO(*obj); }
+ AliESDVZERO *GetVZEROData(){ return fESDVZERO; }
-protected:
- AliESD(const AliESD&);
+ AliRawDataErrorLog *GetErrorLog(Int_t i) const {
+ return (AliRawDataErrorLog *)fErrorLogs.UncheckedAt(i);
+ }
+ void AddRawDataErrorLog(const AliRawDataErrorLog *log) {
+ new(fErrorLogs[fErrorLogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
+ }
+ Int_t GetNumberOfErrorLogs() const {return fErrorLogs.GetEntriesFast();}
+ AliESD(const AliESD&);
AliESD &operator=(const AliESD& source);
+protected:
+
+
- TList *fESDObjects; // List of esd Objects
-
- AliESDRun *fESDRun; //! Run information tmp put in the Userdata
- AliESDHeader *fHeader; //! ESD Event Header
- AliESDZDC *fESDZDC; //! ZDC information
- AliESDFMD *fESDFMD; //! FMD object containing rough multiplicity
- AliESDVZERO *fESDVZERO; //! VZERO object containing rough multiplicity
- AliESDTZERO *fESDTZERO; //! TZEROObject
- AliESDVertex *fSPDVertex; //! Primary vertex estimated by the SPD
- AliESDVertex *fPrimaryVertex; //! Primary vertex estimated using ESD tracks
- AliMultiplicity *fSPDMult; //! SPD tracklet multiplicity
- AliESDCaloTrigger* fPHOSTrigger; //! PHOS Trigger information
- AliESDCaloTrigger* fEMCALTrigger; //! PHOS Trigger information
-
- TClonesArray *fTracks; //! ESD tracks
- // TClonesArray *fHLTConfMapTracks; //! HLT ESD tracks from Conformal Mapper method
- // TClonesArray *fHLTHoughTracks; //! HLT ESD tracks from Hough Transform method
- TClonesArray *fMuonTracks; //! MUON ESD tracks
- TClonesArray *fPmdTracks; //! PMD ESD tracks
- TClonesArray *fTrdTracks; //! TRD ESD tracks (triggered)
- TClonesArray *fV0s; //! V0 vertices
- TClonesArray *fCascades; //! Cascade vertices
- TClonesArray *fKinks; //! Kinks
- TClonesArray *fCaloClusters; //! Calorimeter clusters for PHOS/EMCAL
- TClonesArray *fErrorLogs; //! Raw-data reading error messages
-
-
- // Remove this stuff CKB
+ // Event Identification
+
+ Int_t fEventNumberInFile;// running Event count in the file
+ UShort_t fBunchCrossNumber;// Bunch Crossing Number
+ UInt_t fOrbitNumber; // Orbit Number
+ UInt_t fPeriodNumber; // Period Number
+ Int_t fRunNumber; // Run Number
+ UInt_t fTimeStamp; // Time stamp
+ UInt_t fEventType; // Type of Event
+ ULong64_t fTriggerMask; // Trigger Type (mask)
+ UChar_t fTriggerCluster; // Trigger cluster (mask)
+ Int_t fRecoVersion; // Version of reconstruction
+ Float_t fMagneticField; // Solenoid Magnetic Field in kG : for compatibility with AliMagF
+
+ Float_t fZDCN1Energy; // reconstructed energy in the neutron ZDC
+ Float_t fZDCP1Energy; // reconstructed energy in the proton ZDC
+ Float_t fZDCN2Energy; // reconstructed energy in the neutron ZDC
+ Float_t fZDCP2Energy; // reconstructed energy in the proton ZDC
+ Float_t fZDCEMEnergy; // reconstructed energy in the electromagnetic ZDC
+ Int_t fZDCParticipants; // number of participants estimated by the ZDC
+
+ Float_t fT0zVertex; // vertex z position estimated by the T0
+ AliESDVertex fSPDVertex; // Primary vertex estimated by the SPD
+ AliESDVertex fPrimaryVertex; // Primary vertex estimated using ESD tracks
+ Float_t fDiamondXY[2]; // Interaction diamond (x,y) in RUN
+ Float_t fDiamondCovXY[3]; // Interaction diamond covariance (x,y) in RUN
+ AliMultiplicity fSPDMult; // SPD tracklet multiplicity
+
+ Float_t fT0timeStart; // interaction time estimated by the T0
+ Float_t fT0time[24]; // best TOF on each T0 PMT
+ Float_t fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
+
+ TClonesArray fTracks; // ESD tracks
+ TClonesArray fHLTConfMapTracks;// HLT ESD tracks from Conformal Mapper method
+ TClonesArray fHLTHoughTracks; // HLT ESD tracks from Hough Transform method
+ TClonesArray fMuonTracks; // MUON ESD tracks
+ TClonesArray fPmdTracks; // PMD ESD tracks
+ TClonesArray fTrdTracks; // TRD ESD tracks (triggered)
+ TClonesArray fV0s; // V0 vertices
+ TClonesArray fCascades; // Cascade vertices
+ TClonesArray fKinks; // Kinks
+ TClonesArray fCaloClusters; // Calorimeter clusters for PHOS/EMCAL
Int_t fEMCALClusters; // Number of EMCAL clusters (subset of caloclusters)
Int_t fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list
+ TArrayF *fEMCALTriggerPosition; ///(x,y,z of 2x2 and x,y,z of nxn) not position of centroid but of patch corner
+ TArrayF *fEMCALTriggerAmplitudes; //(2x2 max ampl, 2x2 amp out of patch, nxn max ampl, nxn amp out of patch)
Int_t fPHOSClusters; // Number of PHOS clusters (subset of caloclusters)
Int_t fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list
+ TArrayF *fPHOSTriggerPosition; //(x,y,z of 2x2 and x,y,z of nxn), not position of centroid but of patch corner
+ TArrayF *fPHOSTriggerAmplitudes; //(2x2 max ampl, 2x2 amp out of patch, nxn max ampl, nxn amp out of patch)
+
+ AliESDFMD *fESDFMD; // FMD object containing rough multiplicity
+ AliESDVZERO *fESDVZERO; // VZERO object containing rough multiplicity
+
+ TClonesArray fErrorLogs; // Raw-data reading error messages
- ClassDef(AliESD,23) //ESD class
+ ClassDef(AliESD,21) //ESD class
};
#endif
--- /dev/null
+/**************************************************************************
+ * 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 "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDVZERO.h"
+#include "AliESDHLTtrack.h"
+#include "AliESDFMD.h"
+#include "AliESD.h"
+
+
+ClassImp(AliESDEvent)
+
+//______________________________________________________________________________
+AliESDEvent::AliESDEvent():
+ 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),
+ fESDOld(0),
+ fEMCALClusters(0),
+ fFirstEMCALCluster(-1),
+ fPHOSClusters(0),
+ fFirstPHOSCluster(-1)
+{
+}
+//______________________________________________________________________________
+AliESDEvent::AliESDEvent(const AliESDEvent& 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)),
+ fESDOld(new AliESD(*esd.fESDOld)),
+ 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();
+
+}
+
+//______________________________________________________________________________
+AliESDEvent & AliESDEvent::operator=(const AliESDEvent& 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);
+ fESDOld = new AliESD(*source.fESDOld);
+ // 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;
+
+}
+
+
+//______________________________________________________________________________
+AliESDEvent::~AliESDEvent()
+{
+ //
+ // 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 AliESDEvent::Reset()
+{
+
+
+ // Reset the standard contents
+ ResetStdContent();
+
+ if(fESDOld)fESDOld->Reset();
+
+}
+
+void AliESDEvent::ResetStdContent()
+{
+ // 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 AliESDEvent::AddV0(const AliESDv0 *v) {
+ //
+ // Add V0
+ //
+ TClonesArray &fv = *fV0s;
+ Int_t idx=fV0s->GetEntriesFast();
+ new(fv[idx]) AliESDv0(*v);
+ return idx;
+}
+
+//______________________________________________________________________________
+void AliESDEvent::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 AliESDEvent::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 AliESDEvent::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 AliESDEvent::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 AliESDEvent::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 AliESDEvent::SetFMDData(AliESDFMD * obj) {
+ // use already allocated space
+ if(fESDFMD){
+ new(fESDFMD) AliESDFMD(*obj);
+ }
+}
+
+void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
+ // use already allocated space
+ if(fESDVZERO)
+ new(fESDVZERO) AliESDVZERO(*obj);
+}
+
+void AliESDEvent::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 AliESDEvent::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->SetOwner(kTRUE);
+ fESDObjects->AddLast(obj);
+}
+
+
+void AliESDEvent::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 AliESDEvent::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 AliESDEvent::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 AliESDEvent::ReadFromTree(TTree *tree){
+
+
+ // if we just replace the TList we produce a memory leak...
+ // so better replace the TList
+
+ 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;
+
+
+
+ // if we find the esd on the tree we do have the old structuru
+ if(tree->GetBranch("ESD")){
+ printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
+ tree->SetBranchAddress("ESD",&fESDOld);
+ fESDObjects = new TList();
+ CreateStdContent(); // create for copy
+ // when reading back we are not owner of the list
+ // must not delete it
+ fESDObjects->SetOwner(kFALSE);
+ return;
+ }
+
+ fESDOld = 0;
+
+
+ // Try to find AliESDEvent
+ AliESDEvent *esdEvent = 0;
+ esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
+
+
+ if(esdEvent){
+ // create a new TList from the UserInfo TList...
+ // copy constructor does not work...
+ fESDObjects = (TList*)(esdEvent->GetList()->Clone());
+ // fESDObjects = esdEvent->GetList();
+ 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);
+ }
+ // 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); // Use a flag to activate...
+ tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
+ }
+ else{
+ tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+ }
+ }
+ GetStdContent();
+ // when reading back we are not owner of the list
+ // must not delete it
+ fESDObjects->SetOwner(kFALSE);
+ }// no esdEvent
+ else {
+ // Hack.... we can't get the list from the user data try create and set it by hand...
+ fESDObjects = new TList();
+ CreateStdContent();
+ TIter next(fESDObjects);
+ TNamed *el;
+ while((el=(TNamed*)next())){
+ TString bname(el->GetName());
+ tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+ }
+ GetStdContent();
+ // when reading back we are not owner of the list
+ // must not delete it
+ fESDObjects->SetOwner(kFALSE);
+ }
+
+
+
+}
+
+
+void AliESDEvent::CopyFromOldESD()
+{
+ // Method which copies over everthing from the old esd structure to the
+ // new
+
+ if(fESDOld){
+ ResetStdContent();
+ // Run
+ SetRunNumber(fESDOld->GetRunNumber());
+ SetPeriodNumber(fESDOld->GetPeriodNumber());
+ SetMagneticField(fESDRun->GetMagneticField());
+
+ // leave out diamond ...
+ // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
+
+ // header
+ SetTriggerMask(fESDOld->GetTriggerMask());
+ SetOrbitNumber(fESDOld->GetOrbitNumber());
+ SetTimeStamp(fESDOld->GetTimeStamp());
+ SetEventType(fESDOld->GetEventType());
+ SetEventNumberInFile(fESDOld->GetEventNumberInFile());
+ SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
+ SetTriggerCluster(fESDOld->GetTriggerCluster());
+
+ // ZDC
+
+ SetZDC(fESDOld->GetZDCN1Energy(),
+ fESDOld->GetZDCP1Energy(),
+ fESDOld->GetZDCEMEnergy(),
+ fESDOld->GetZDCN2Energy(),
+ fESDOld->GetZDCP2Energy(),
+ fESDOld->GetZDCParticipants());
+
+ // FMD
+
+ SetFMDData(fESDOld->GetFMDData());
+
+ // T0
+
+ SetT0zVertex(fESDOld->GetT0zVertex());
+ SetT0(fESDOld->GetT0());
+ // leave amps out
+
+ // VZERO
+ SetVZEROData(fESDOld->GetVZEROData());
+
+ SetVertex(fESDOld->GetVertex());
+
+ SetPrimaryVertex(fESDOld->GetPrimaryVertex());
+
+ SetMultiplicity(fESDOld->GetMultiplicity());
+
+ for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
+ AddTrack(fESDOld->GetTrack(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
+ AddMuonTrack(fESDOld->GetMuonTrack(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
+ AddPmdTrack(fESDOld->GetPmdTrack(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
+ AddTrdTrack(fESDOld->GetTrdTrack(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
+ AddV0(fESDOld->GetV0(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
+ AddCascade(fESDOld->GetCascade(i));
+ }
+
+ for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
+ AddKink(fESDOld->GetKink(i));
+ }
+
+
+ for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
+ AddCaloCluster(fESDOld->GetCaloCluster(i));
+ }
+ }// if fesdold
+}
+
+
+
--- /dev/null
+// -*- mode: C++ -*-
+#ifndef ALIESDEVENT_H
+#define ALIESDEVENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+
+/* $Id$ */
+
+//-------------------------------------------------------------------------
+// Class AliESD
+// This is the class to deal with during the physical analysis of data
+//
+// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
+//-------------------------------------------------------------------------
+
+#include <TClonesArray.h>
+#include <TObject.h>
+#include <TTree.h>
+#include <TArrayF.h>
+
+class TList;
+
+
+#include "AliESDMuonTrack.h"
+#include "AliESDPmdTrack.h"
+#include "AliESDTrdTrack.h"
+#include "AliESDVertex.h"
+#include "AliESDcascade.h"
+#include "AliESDkink.h"
+#include "AliESDtrack.h"
+#include "AliESDCaloCluster.h"
+#include "AliESDv0.h"
+#include "AliESDFMD.h"
+#include "AliESDVZERO.h"
+#include "AliMultiplicity.h"
+#include "AliRawDataErrorLog.h"
+#include "AliESDRun.h"
+#include "AliESDHeader.h"
+#include "AliESDZDC.h"
+#include "AliESDTZERO.h"
+#include "AliESDCaloTrigger.h"
+
+class AliESDfriend;
+class AliESDVZERO;
+class AliESDHLTtrack;
+class AliESDFMD;
+class AliESD;
+
+class AliESDEvent : public TObject {
+public:
+
+
+ enum ESDListIndex_t {kESDRun,
+ kHeader,
+ kESDZDC,
+ kESDFMD,
+ kESDVZERO,
+ kESDTZERO,
+ kSPDVertex,
+ kPrimaryVertex,
+ kSPDMult,
+ kPHOSTrigger,
+ kEMCALTrigger,
+ kTracks,
+ kMuonTracks,
+ kPmdTracks,
+ kTrdTracks,
+ kV0s,
+ kCascades,
+ kKinks,
+ kCaloClusters,
+ kErrorLogs,
+ kESDListN
+ };
+
+ AliESDEvent();
+ virtual ~AliESDEvent();
+
+
+ // RUN
+ // move this to the UserData!!!
+ const AliESDRun* GetESDRun() const {return fESDRun;}
+
+ // Delegated methods for fESDRun
+ void SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
+ Int_t GetRunNumber() const {return fESDRun->GetRunNumber();}
+ void SetPeriodNumber(Int_t n){fESDRun->SetPeriodNumber(n);}
+ Int_t GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
+ void SetMagneticField(Float_t mf){fESDRun->SetMagneticField(mf);}
+ Float_t GetMagneticField() const {return fESDRun->GetMagneticField();}
+ void SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
+ Float_t GetDiamondX() const {return fESDRun->GetDiamondX();}
+ Float_t GetDiamondY() const {return fESDRun->GetDiamondY();}
+ Float_t GetSigma2DiamondX() const {return fESDRun->GetSigma2DiamondX();}
+ Float_t GetSigma2DiamondY() const {return fESDRun->GetSigma2DiamondY();}
+ void GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}
+
+
+ // HEADER
+ const AliESDHeader* GetHeader() const {return fHeader;}
+
+ // Delegated methods for fHeader
+ void SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
+ void SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
+ 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 SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
+ void SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
+ ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
+ UInt_t GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
+ UInt_t GetTimeStamp() const { return fHeader->GetTimeStamp();}
+ UInt_t GetEventType() const { return fHeader->GetEventType();}
+ Int_t GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
+ UShort_t GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
+ UChar_t GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
+
+ // ZDC CKB: put this in the header?
+ const AliESDZDC* GetESDZDC() const {return fESDZDC;}
+
+ // Delegated methods for fESDZDC
+ Float_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
+ Float_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
+ Float_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
+ Float_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
+ Float_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
+ Int_t GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
+ void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
+ Float_t n2Energy, Float_t p2Energy, Int_t participants)
+ {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, n2Energy, p2Energy, participants);}
+
+
+ // FMD
+ void SetFMDData(AliESDFMD * obj);
+ AliESDFMD *GetFMDData(){ return fESDFMD; }
+
+
+ // TZERO CKB: put this in the header?
+ const AliESDTZERO* GetESDTZERO() const {return fESDTZERO;}
+ // delegetated methods for fESDTZERO
+
+ Float_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
+ void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
+ Float_t GetT0() const {return fESDTZERO->GetT0();}
+ void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
+ const Float_t * GetT0time() const {return fESDTZERO->GetT0time();}
+ void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
+ const Float_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
+ void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
+
+ // VZERO
+ AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
+ void SetVZEROData(AliESDVZERO * obj);
+
+
+ void SetESDfriend(const AliESDfriend *f);
+ void GetESDfriend(AliESDfriend *f) const;
+
+
+
+ void SetVertex(const AliESDVertex *vertex) {
+ *fSPDVertex = *vertex;
+ fSPDVertex->SetName("SPDVertex");// error prone use class wide names?
+ //CKB or new with placement
+ }
+ const AliESDVertex *GetVertex() const {return fSPDVertex;}
+
+ void SetPrimaryVertex(const AliESDVertex *vertex) {
+ *fPrimaryVertex = *vertex;
+ fPrimaryVertex->SetName("PrimaryVertex");// error prone use class wide names?
+ }
+ const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}
+
+ void SetMultiplicity(const AliMultiplicity *mul) {
+ *fSPDMult = *mul;
+ // CKB
+ // new (&fSPDMult) AliMultiplicity(*mul);
+ }
+ const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
+
+ AliESDtrack *GetTrack(Int_t i) const {
+ return (AliESDtrack *)fTracks->UncheckedAt(i);
+ }
+ Int_t AddTrack(const AliESDtrack *t);
+
+
+ AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
+ // return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
+ return 0;
+ }
+ void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
+ printf("ESD:: AddHLTConfMapTrack do nothing \n");
+ // TClonesArray &fhlt = *fHLTConfMapTracks;
+ // new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+ }
+
+
+ AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
+ // return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
+ return 0;
+ }
+ void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
+ printf("ESD:: AddHLTHoughTrack do nothing \n");
+ // TClonesArray &fhlt = *fHLTHoughTracks;
+ // new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+ }
+
+ AliESDMuonTrack *GetMuonTrack(Int_t i) const {
+ return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
+ }
+ void AddMuonTrack(const AliESDMuonTrack *t) {
+ TClonesArray &fmu = *fMuonTracks;
+ new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
+ }
+
+ AliESDPmdTrack *GetPmdTrack(Int_t i) const {
+ return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
+ }
+ void AddPmdTrack(const AliESDPmdTrack *t) {
+ TClonesArray &fpmd = *fPmdTracks;
+ new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
+ }
+
+ AliESDTrdTrack *GetTrdTrack(Int_t i) const {
+ return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
+ }
+ void AddTrdTrack(const AliESDTrdTrack *t) {
+ TClonesArray &ftrd = *fTrdTracks;
+ new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
+ }
+
+ AliESDv0 *GetV0(Int_t i) const {
+ return (AliESDv0*)fV0s->UncheckedAt(i);
+ }
+ Int_t AddV0(const AliESDv0 *v);
+
+ AliESDcascade *GetCascade(Int_t i) const {
+ return (AliESDcascade *)fCascades->UncheckedAt(i);
+ }
+ void AddCascade(const AliESDcascade *c) {
+ TClonesArray &fc = *fCascades;
+ new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
+ }
+
+ AliESDkink *GetKink(Int_t i) const {
+ return (AliESDkink *)fKinks->UncheckedAt(i);
+ }
+ Int_t AddKink(const AliESDkink *c);
+
+ AliESDCaloCluster *GetCaloCluster(Int_t i) const {
+ return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
+ }
+ Int_t AddCaloCluster(const AliESDCaloCluster *c);
+
+ AliRawDataErrorLog *GetErrorLog(Int_t i) const {
+ return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
+ }
+ void AddRawDataErrorLog(const AliRawDataErrorLog *log) {
+ // CKB inline this??
+ TClonesArray &errlogs = *fErrorLogs;
+ new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
+ }
+ Int_t GetNumberOfErrorLogs() const {return fErrorLogs->GetEntriesFast();}
+
+
+ void AddPHOSTriggerPosition(TArrayF array) { fPHOSTrigger->AddTriggerPosition(array); }
+ void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
+ void AddEMCALTriggerPosition(TArrayF array) { fEMCALTrigger->AddTriggerPosition(array); }
+ void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
+
+
+ Int_t GetNumberOfTracks() const {return fTracks->GetEntriesFast();}
+ Int_t GetNumberOfHLTConfMapTracks() const {return 0;}
+ // fHLTConfMapTracks->GetEntriesFast();}
+ Int_t GetNumberOfHLTHoughTracks() const {return 0; }
+ // fHLTHoughTracks->GetEntriesFast(); }
+
+ Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
+ Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
+ Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
+ Int_t GetNumberOfV0s() const {return fV0s->GetEntriesFast();}
+ Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
+ Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
+ Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
+
+ Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
+ void SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
+ Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
+ void SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
+ TArrayF *GetEMCALTriggerPosition() const {return fEMCALTrigger->GetTriggerPosition();}
+ TArrayF *GetEMCALTriggerAmplitudes() const {return fEMCALTrigger->GetTriggerAmplitudes();}
+
+ Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
+ void SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
+ void SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; }
+ Int_t GetFirstPHOSCluster() const { return fFirstPHOSCluster ; }
+ TArrayF *GetPHOSTriggerPosition() const {return fPHOSTrigger->GetTriggerPosition();}
+ TArrayF *GetPHOSTriggerAmplitudes() const {return fPHOSTrigger->GetTriggerAmplitudes();}
+
+ void ResetV0s() { fV0s->Clear(); }
+ void ResetCascades() { fCascades->Clear(); }
+ void Reset();
+
+ void Print(Option_t *option="") const;
+
+ void AddObject(TObject* obj);
+ void ReadFromTree(TTree *tree);
+ AliESD *GetAliESDOld(){return fESDOld;}
+ const void WriteToTree(TTree* tree) const {tree->Branch(fESDObjects);}
+ void GetStdContent();
+ void ResetStdContent();
+ void CreateStdContent();
+ void SetStdNames();
+ void CopyFromOldESD();
+ TList* GetList(){return fESDObjects;}
+
+protected:
+ AliESDEvent(const AliESDEvent&);
+ AliESDEvent &operator=(const AliESDEvent& source);
+
+
+ TList *fESDObjects; // List of esd Objects
+
+ AliESDRun *fESDRun; //! Run information tmp put in the Userdata
+ AliESDHeader *fHeader; //! ESD Event Header
+ AliESDZDC *fESDZDC; //! ZDC information
+ AliESDFMD *fESDFMD; //! FMD object containing rough multiplicity
+ AliESDVZERO *fESDVZERO; //! VZERO object containing rough multiplicity
+ AliESDTZERO *fESDTZERO; //! TZEROObject
+ AliESDVertex *fSPDVertex; //! Primary vertex estimated by the SPD
+ AliESDVertex *fPrimaryVertex; //! Primary vertex estimated using ESD tracks
+ AliMultiplicity *fSPDMult; //! SPD tracklet multiplicity
+ AliESDCaloTrigger* fPHOSTrigger; //! PHOS Trigger information
+ AliESDCaloTrigger* fEMCALTrigger; //! PHOS Trigger information
+
+ TClonesArray *fTracks; //! ESD tracks
+ TClonesArray *fMuonTracks; //! MUON ESD tracks
+ TClonesArray *fPmdTracks; //! PMD ESD tracks
+ TClonesArray *fTrdTracks; //! TRD ESD tracks (triggered)
+ TClonesArray *fV0s; //! V0 vertices
+ TClonesArray *fCascades; //! Cascade vertices
+ TClonesArray *fKinks; //! Kinks
+ TClonesArray *fCaloClusters; //! Calorimeter clusters for PHOS/EMCAL
+ TClonesArray *fErrorLogs; //! Raw-data reading error messages
+
+
+
+ AliESD *fESDOld; //! Old esd Structure
+
+
+ // Remove this stuff CKB
+ Int_t fEMCALClusters; // Number of EMCAL clusters (subset of caloclusters)
+ Int_t fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list
+
+ Int_t fPHOSClusters; // Number of PHOS clusters (subset of caloclusters)
+ Int_t fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list
+
+ ClassDef(AliESDEvent,1) //ESDEvent class
+};
+#endif
+
//-----------------------------------------------------------------
#include "AliESDpid.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp(AliESDpid)
//_________________________________________________________________________
-Int_t AliESDpid::MakePID(AliESD *event)
+Int_t AliESDpid::MakePID(AliESDEvent *event)
{
//
// Combine the information of various detectors
//-------------------------------------------------------
#include <Rtypes.h>
-class AliESD;
+class AliESDEvent;
class AliESDpid {
public:
AliESDpid(){}
virtual ~AliESDpid() {}
- static Int_t MakePID(AliESD *event);
+ static Int_t MakePID(AliESDEvent *event);
private:
- ClassDef(AliESDpid,1) // TPC PID class
+ ClassDef(AliESDpid,2) // TPC PID class
};
#endif
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliRawEventHeaderBase.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDfriend.h"
#include "AliESDVertex.h"
#include "AliMultiplicity.h"
}
// get the possibly already existing ESD file and tree
- AliESD* esd = new AliESD(); AliESD* hltesd = new AliESD();
+ AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
TFile* fileOld = NULL;
TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
if (!gSystem->AccessPathName("AliESDs.root")){
}
TTree* tree = new TTree("esdTree", "Tree with ESD objects");
- esd = new AliESD();
+ esd = new AliESDEvent();
esd->CreateStdContent();
esd->WriteToTree(tree);
TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- hltesd = new AliESD();
+ hltesd = new AliESDEvent();
hltesd->CreateStdContent();
hltesd->WriteToTree(hlttree);
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
+Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
{
// run the barrel tracking
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
{
// run the HLT barrel tracking
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunMuonTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
{
// run the muon spectrometer tracking
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
{
// run the barrel tracking
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
+Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
{
// fill the event summary data
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd)
+Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
{
// Reads the trigger decision which is
// stored in Trigger.root file and fills
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillRawEventHeaderESD(AliESD*& esd)
+Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
{
//
// Filling information from RawReader Header
//_____________________________________________________________________________
-Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
+
+Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
{
// read the ESD event from a file
gROOT->cd();
delete esd;
- esd = (AliESD*) file->Get("ESD");
+ esd = (AliESDEvent*) file->Get("ESD");
file->Close();
delete file;
return kTRUE;
+
}
+
+
//_____________________________________________________________________________
-void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
+void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
{
// write the ESD event to a file
}
Int_t lastEvent = 0;
TTree *b = (TTree*) file->Get("esdTree");
- AliESD *esd = new AliESD();
+ AliESDEvent *esd = new AliESDEvent();
esd->ReadFromTree(b);
b->GetEntry(fFirstEvent);
// connect to ESD
TTree *t = (TTree*) esdFile->Get("esdTree");
- AliESD *esd = new AliESD();
+ AliESDEvent *esd = new AliESDEvent();
esd->ReadFromTree(t);
Int_t nEvents = t->GetEntries();
return;
}
-void AliReconstruction::WriteAlignmentData(AliESD* esd)
+void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
// Write space-points which are then used in the alignment procedures
// For the moment only ITS, TRD and TPC
}
//_____________________________________________________________________________
-void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESD* esd)
+void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
{
// The method reads the raw-data error log
// accumulated within the rawReader.
class AliTracker;
class AliVertexer;
class AliESDVertex;
-class AliESD;
+class AliESDEvent;
class TFile;
class TTree;
private:
Bool_t RunLocalReconstruction(const TString& detectors);
Bool_t RunLocalEventReconstruction(const TString& detectors);
- Bool_t RunVertexFinder(AliESD*& esd);
- Bool_t RunHLTTracking(AliESD*& esd);
- Bool_t RunMuonTracking(AliESD*& esd);
- Bool_t RunTracking(AliESD*& esd);
- Bool_t FillESD(AliESD*& esd, const TString& detectors);
- Bool_t FillTriggerESD(AliESD*& esd);
- Bool_t FillRawEventHeaderESD(AliESD*& esd);
+ Bool_t RunVertexFinder(AliESDEvent*& esd);
+ Bool_t RunHLTTracking(AliESDEvent*& esd);
+ Bool_t RunMuonTracking(AliESDEvent*& esd);
+ Bool_t RunTracking(AliESDEvent*& esd);
+ Bool_t FillESD(AliESDEvent*& esd, const TString& detectors);
+ Bool_t FillTriggerESD(AliESDEvent*& esd);
+ Bool_t FillRawEventHeaderESD(AliESDEvent*& esd);
Bool_t IsSelected(TString detName, TString& detectors) const;
Bool_t InitRunLoader();
Bool_t CreateTrackers(const TString& detectors);
void CleanUp(TFile* file = NULL, TFile* fileOld = NULL);
- Bool_t ReadESD(AliESD*& esd, const char* recStep) const;
- void WriteESD(AliESD* esd, const char* recStep) const;
+ Bool_t ReadESD(AliESDEvent*& esd, const char* recStep) const;
+ void WriteESD(AliESDEvent* esd, const char* recStep) const;
//===========================================//
//==========================================//
void ESDFile2AODFile(TFile* esdFile, TFile* aodFile);
- void WriteAlignmentData(AliESD* esd);
+ void WriteAlignmentData(AliESDEvent* esd);
- void FillRawDataErrorLog(Int_t iEvent, AliESD* esd);
+ void FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd);
//*** Global reconstruction flags *******************
Bool_t fUniformField; // uniform field tracking flag
TString fCDBUri; // Uri of the default CDB storage
TObjArray fSpecCDBUri; // Array with detector specific CDB storages
- ClassDef(AliReconstruction, 10) // class for running the reconstruction
+ ClassDef(AliReconstruction, 11) // class for running the reconstruction
};
#endif
//_____________________________________________________________________________
void AliReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/,
- AliESD* /*esd*/) const
+ AliESDEvent* /*esd*/) const
{
// fill the ESD.
// by default nothing is done
//_____________________________________________________________________________
void AliReconstructor::FillESD(AliRawReader* /*rawReader*/,
- TTree* clustersTree, AliESD* esd) const
+ TTree* clustersTree, AliESDEvent* esd) const
{
// fill the ESD in case of raw data input.
// by default the FillESD method for MC is called
//_____________________________________________________________________________
void AliReconstructor::FillESD(AliRunLoader* /*runLoader*/,
- AliESD* /*esd*/) const
+ AliESDEvent* /*esd*/) const
{
// fill the ESD.
// by default nothing is done
//_____________________________________________________________________________
void AliReconstructor::FillESD(AliRunLoader* runLoader,
- AliRawReader* /*rawReader*/, AliESD* esd) const
+ AliRawReader* /*rawReader*/, AliESDEvent* esd) const
{
// fill the ESD in case of raw data input.
// by default the FillESD method for MC is called
class AliRawReader;
class AliVertexer;
class AliTracker;
-class AliESD;
+class AliESDEvent;
class AliReconstructor: public TObject {
{return NULL;}
virtual void FillESD(TTree* digitsTree, TTree* clustersTree,
- AliESD* esd) const;
+ AliESDEvent* esd) const;
virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree,
- AliESD* esd) const;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ AliESDEvent* esd) const;
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const;
+ AliRawReader* rawReader, AliESDEvent* esd) const;
virtual const char* GetDetectorName() const;
class AliCluster;
class TTree;
class AliKalmanTrack;
-class AliESD;
+class AliESDEvent;
class AliTrackPoint;
class AliTracker : public TObject {
public:
AliTracker();
virtual ~AliTracker(){}
- virtual Int_t Clusters2Tracks(AliESD *event)=0;
- virtual Int_t PropagateBack(AliESD *event)=0;
- virtual Int_t RefitInward(AliESD *event)=0;
+ virtual Int_t Clusters2Tracks(AliESDEvent *event)=0;
+ virtual Int_t PropagateBack(AliESDEvent *event)=0;
+ virtual Int_t RefitInward(AliESDEvent *event)=0;
void SetVertex(const Double_t *xyz, const Double_t *ers=0) {
fX=xyz[0]; fY=xyz[1]; fZ=xyz[2];
if (ers) { fSigmaX=ers[0]; fSigmaY=ers[1]; fSigmaZ=ers[2]; }
#include <TObjArray.h>
#include <TTree.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDv0.h"
#include "AliESDtrack.h"
#include "AliV0vertexer.h"
Double_t AliV0vertexer::fgRmin=0.2; //min radius of the fiducial volume
Double_t AliV0vertexer::fgRmax=100.; //max radius of the fiducial volume
-Int_t AliV0vertexer::Tracks2V0vertices(AliESD *event) {
+Int_t AliV0vertexer::Tracks2V0vertices(AliESDEvent *event) {
//--------------------------------------------------------------------
//This function reconstructs V0 vertices
//--------------------------------------------------------------------
#include "TObject.h"
class TTree;
-class AliESD;
+class AliESDEvent;
//_____________________________________________________________________________
class AliV0vertexer : public TObject {
void SetCuts(const Double_t cuts[7]);
static void SetDefaultCuts(const Double_t cuts[7]);
- Int_t Tracks2V0vertices(AliESD *event);
+ Int_t Tracks2V0vertices(AliESDEvent *event);
void GetCuts(Double_t cuts[7]) const;
static void GetDefaultCuts(Double_t cuts[7]);
//---- AliRoot headers -----
#include "AliStrLine.h"
#include "AliVertexerTracks.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp(AliVertexerTracks)
if(fTrksToSkip) { delete [] fTrksToSkip; fTrksToSkip=NULL; }
}
//----------------------------------------------------------------------------
-AliESDVertex* AliVertexerTracks::FindPrimaryVertex(const AliESD *esdEvent)
+AliESDVertex* AliVertexerTracks::FindPrimaryVertex(const AliESDEvent *esdEvent)
{
//
// Primary vertex for current ESD event
return kTRUE;
}
//---------------------------------------------------------------------------
-void AliVertexerTracks::TooFewTracks(const AliESD* esdEvent)
+void AliVertexerTracks::TooFewTracks(const AliESDEvent* esdEvent)
{
//
// When the number of tracks is < fMinTracks
#include <TMatrixD.h>
class TTree;
-class AliESD;
+class AliESDEvent;
class AliVertexerTracks : public TObject {
AliVertexerTracks(Double_t fieldkG);
virtual ~AliVertexerTracks();
- AliESDVertex* FindPrimaryVertex(const AliESD *esdEvent);
+ AliESDVertex* FindPrimaryVertex(const AliESDEvent *esdEvent);
AliESDVertex* VertexForSelectedTracks(TTree *trkTree,Bool_t optUseFitter=kTRUE, Bool_t optPropagate=kTRUE);
AliESDVertex* VertexForSelectedTracks(TObjArray *trkArray, Bool_t optUseFitter=kTRUE, Bool_t optPropagate=kTRUE);
AliESDVertex* RemoveTracksFromVertex(AliESDVertex *inVtx,TTree *trksTree,Float_t *diamondxy);
void VertexFinder(Int_t optUseWeights=0);
void VertexFitter(Bool_t useConstraint=kFALSE);
void StrLinVertexFinderMinDist(Int_t optUseWeights=0);
- void TooFewTracks(const AliESD *esdEvent);
+ void TooFewTracks(const AliESDEvent *esdEvent);
AliESDVertex fVert; // vertex after vertex finder
AliESDVertex *fCurrentVertex; // ESD vertex after fitter
#include "AliRunLoader.h"
#include "AliLoader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliRun.h"
#include "AliStack.h"
#include "AliHeader.h"
Error("CheckESD", "opening ESD file %s failed", esdFileName);
return kFALSE;
}
- AliESD* esd = new AliESD;
+ AliESDEvent * esd = new AliESDEvent;
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree) {
Error("CheckESD", "no ESD tree found");
}
esd->ReadFromTree(tree);
- // efficienc and resolution histograms
+ // efficiency and resolution histograms
Int_t nBinsPt = 15;
Float_t minPt = 0.1;
Float_t maxPt = 3.1;
#pragma link off all functions;
#pragma link C++ enum AliLog::EType_t;
-#pragma link C++ enum AliESD::ESDListIndex_t;
+#pragma link C++ enum AliESDEvent::ESDListIndex_t;
+
#pragma link C++ class AliESD+;
+#pragma link C++ class AliESDEvent+;
#pragma link C++ class AliESDRun+;
#pragma link C++ class AliESDHeader+;
#pragma link C++ class AliESDZDC+;
-SRCS = AliESD.cxx AliESDfriend.cxx\
+SRCS = AliESDEvent.cxx AliESDfriend.cxx AliESD.cxx \
AliESDtrack.cxx AliESDfriendTrack.cxx\
AliESDMuonTrack.cxx AliESDPmdTrack.cxx AliESDTrdTrack.cxx AliESDHLTtrack.cxx \
AliESDv0.cxx AliESDcascade.cxx AliVertex.cxx AliESDVertex.cxx \
#include <TRandom.h>
#include <TTUBE.h>
#include <TVirtualMC.h>
-#include <AliESD.h>
#include "AliLog.h"
#include "AliMC.h"
#include <TDirectory.h>
#include "AliRunLoader.h"
-#include <AliESD.h>
+#include <AliESDEvent.h>
#include "AliLog.h"
#include "AliT0Loader.h"
#include "AliT0RecPoint.h"
}
//____________________________________________________________
-void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
+void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) const
{
/***************************************************
virtual void Reconstruct(AliRawReader*rawReader , TTree* recTree) const;
virtual void Reconstruct(AliRunLoader* ) const {};
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
- virtual void FillESD(AliRunLoader* , AliRawReader*, AliESD* ) const {};
- virtual void FillESD( AliRawReader*, TTree*, AliESD* ) const {};
- virtual void FillESD( TTree*, TTree*, AliESD* ) const {};
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+ virtual void FillESD(AliRunLoader* , AliRawReader*, AliESDEvent* ) const {};
+ virtual void FillESD( AliRawReader*, TTree*, AliESDEvent* ) const {};
+ virtual void FillESD( TTree*, TTree*, AliESDEvent* ) const {};
virtual Bool_t HasLocalReconstruction() const {return kTRUE;}
virtual Bool_t HasDigitConversion() const {return kFALSE;}
public:
class TTree;
-class AliESD;
+class AliESDEvent;
extern TDirectory *gDirectory;
extern TFile *gFile;
//_____________________________________________________________________________
void AliTOFReconstructor::FillESD(AliRunLoader* /*runLoader*/,
- AliESD* /*esd*/) const
+ AliESDEvent* /*esd*/) const
{
// nothing to be done
class TTree;
-class AliESD;
+class AliESDEvent;
class AliRawReader;
class AliRunLoader;
virtual void Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
virtual void ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const;
- virtual void FillESD(AliRunLoader*, AliRawReader*, AliESD*) const { };
- virtual void FillESD(AliRawReader*, TTree*, AliESD*) const { };
- virtual void FillESD(TTree*, TTree*, AliESD*) const { };
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ virtual void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const { };
+ virtual void FillESD(AliRawReader*, TTree*, AliESDEvent*) const { };
+ virtual void FillESD(TTree*, TTree*, AliESDEvent*) const { };
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
private:
AliTOFGeometry *fTOFGeometry; // pointer to TOF geometry
#include "AliLog.h"
#include "AliESDtrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliTOFpidESD.h"
}
//_________________________________________________________________________
-Int_t AliTOFpidESD::MakePID(AliESD *event, Double_t timeZero)
+Int_t AliTOFpidESD::MakePID(AliESDEvent *event, Double_t timeZero)
{
//
// This function calculates the "detector response" PID probabilities
}
//_________________________________________________________________________
-Int_t AliTOFpidESD::MakePID(AliESD *event)
+Int_t AliTOFpidESD::MakePID(AliESDEvent *event)
{
//
// This function calculates the "detector response" PID probabilities
#include "TObject.h"
-class AliESD;
+class AliESDEvent;
class AliTOFGeometry;
AliTOFpidESD(Double_t *param);
~AliTOFpidESD(){}
- Int_t MakePID(AliESD *event);
- Int_t MakePID(AliESD *event, Double_t timeZero);
+ Int_t MakePID(AliESDEvent *event);
+ Int_t MakePID(AliESDEvent *event, Double_t timeZero);
void SetEventNumber(Int_t n) {fEventN=n;}
Int_t GetEventNumber() const {return fEventN;}
#include "AliAlignObj.h"
#include "AliESDtrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliTrackPointArray.h"
delete fCalTree;
}
//_____________________________________________________________________________
-Int_t AliTOFtracker::PropagateBack(AliESD* event) {
+Int_t AliTOFtracker::PropagateBack(AliESDEvent* event) {
//
// Gets seeds from ESD event and Match with TOF Clusters
//
return tofcorr;
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromT0(AliESD *event) const {
+Float_t AliTOFtracker::GetTimeZerofromT0(AliESDEvent *event) const {
//Returns TimeZero as measured by T0 detector
return event->GetT0();
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromTOF(AliESD * /*event*/) const {
+Float_t AliTOFtracker::GetTimeZerofromTOF(AliESDEvent * /*event*/) const {
//dummy, for the moment. T0 algorithm using tracks on TOF
{
class TClonesArray;
-class AliESD;
+class AliESDEvent;
class AliTOFcluster;
class AliTOFRecoParam;
AliTOFtracker& operator=(const AliTOFtracker &source); // ass. op.
virtual ~AliTOFtracker();
- virtual Int_t Clusters2Tracks(AliESD* /*event*/) {return -1;};
- virtual Int_t PropagateBack(AliESD* event);
- virtual Int_t RefitInward(AliESD* /*event*/) {return -1;};
+ virtual Int_t Clusters2Tracks(AliESDEvent* /*event*/) {return -1;};
+ virtual Int_t PropagateBack(AliESDEvent* event);
+ virtual Int_t RefitInward(AliESDEvent* /*event*/) {return -1;};
virtual Int_t LoadClusters(TTree * cTree); // Load Clusters
virtual void UnloadClusters();// UnLoad Clusters
virtual AliCluster *GetCluster(Int_t /*index*/) const {return NULL;};
Int_t FindClusterIndex(Double_t z) const; // Returns cluster index
void MatchTracks(Bool_t mLastStep); // Matching Algorithm
void CollectESD(); // Select starting Set for Matching
- Float_t GetTimeZerofromTOF(AliESD* /*event*/) const; // T0 from TOF
- Float_t GetTimeZerofromT0(AliESD* event) const; // T0 from T0
+ Float_t GetTimeZerofromTOF(AliESDEvent* /*event*/) const; // T0 from TOF
+ Float_t GetTimeZerofromT0(AliESDEvent* event) const; // T0 from T0
Float_t CorrectTimeWalk(Float_t dist,Float_t tof); // Time Walk correction
AliTOFRecoParam* fRecoParam; // Pointer to TOF Recon. Pars
#include "TTreeStream.h"
#include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliTOFRecoParam.h"
}
//_____________________________________________________________________________
-Int_t AliTOFtrackerMI::PropagateBack(AliESD* event) {
+Int_t AliTOFtrackerMI::PropagateBack(AliESDEvent* event) {
//
// Gets seeds from ESD event and Match with TOF Clusters
//
class TTreeSRedirector;
class TClonesArray;
-class AliESD;
+class AliESDEvent;
class AliTOFcluster;
class AliTOFRecoParam;
// virtual ~AliTOFtrackerMI() {delete fTOFpid;}
virtual ~AliTOFtrackerMI();
- virtual Int_t Clusters2Tracks(AliESD* /*event*/) {return -1;};
- virtual Int_t PropagateBack(AliESD* event);
- virtual Int_t RefitInward(AliESD* /*event*/) {return -1;};
+ virtual Int_t Clusters2Tracks(AliESDEvent* /*event*/) {return -1;};
+ virtual Int_t PropagateBack(AliESDEvent* event);
+ virtual Int_t RefitInward(AliESDEvent* /*event*/) {return -1;};
virtual Int_t LoadClusters(TTree *dTree); // Loading Clusters from Digits
virtual void UnloadClusters();// UnLoad Clusters
virtual AliCluster *GetCluster(Int_t /*index*/) const {return NULL;};
//_____________________________________________________________________________
void AliTPCReconstructor::FillESD(AliRunLoader* /*runLoader*/,
- AliESD* esd) const
+ AliESDEvent* esd) const
{
// make PID
virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
virtual AliTracker* CreateTracker(AliRunLoader* runLoader) const;
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
virtual void FillESD(TTree* digitsTree, TTree* clustersTree,
- AliESD* esd) const {
+ AliESDEvent* esd) const {
AliReconstructor::FillESD(digitsTree,clustersTree,esd);
}
virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree,
- AliESD* esd) const {
+ AliESDEvent* esd) const {
AliReconstructor::FillESD(rawReader,clustersTree,esd);
}
virtual void FillESD(AliRunLoader* runLoader,
- AliRawReader* rawReader, AliESD* esd) const {
+ AliRawReader* rawReader, AliESDEvent* esd) const {
AliReconstructor::FillESD(runLoader,rawReader,esd);
}
//-----------------------------------------------------------------
#include "AliTPCpidESD.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
ClassImp(AliTPCpidESD)
}
//_________________________________________________________________________
-Int_t AliTPCpidESD::MakePID(AliESD *event)
+Int_t AliTPCpidESD::MakePID(AliESDEvent *event)
{
//
// This function calculates the "detector response" PID probabilities
//-------------------------------------------------------
#include <Rtypes.h>
-class AliESD;
+class AliESDEvent;
class AliTPCpidESD {
public:
AliTPCpidESD():fMIP(0.),fRes(0.),fRange(0.){}
AliTPCpidESD(Double_t *param);
virtual ~AliTPCpidESD() {}
- Int_t MakePID(AliESD *event);
+ Int_t MakePID(AliESDEvent *event);
static Double_t Bethe(Double_t bg);
private:
Double_t fMIP; // dEdx for MIP
#include <TFile.h>
#include <TTree.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliTPCtracker.h"
#include "AliTPCcluster.h"
}
//_____________________________________________________________________________
-Int_t AliTPCtracker::Clusters2Tracks(AliESD *event) {
+Int_t AliTPCtracker::Clusters2Tracks(AliESDEvent *event) {
//-----------------------------------------------------------------
// This is a track finder.
// The clusters must be already loaded !
}
//_____________________________________________________________________________
-Int_t AliTPCtracker::RefitInward(AliESD* event) {
+Int_t AliTPCtracker::RefitInward(AliESDEvent* event) {
//
// The function propagates tracks throught TPC inward
// using already associated clusters.
return 0;
}
-Int_t AliTPCtracker::PropagateBack(AliESD *event) {
+Int_t AliTPCtracker::PropagateBack(AliESDEvent *event) {
//-----------------------------------------------------------------
// This function propagates tracks back through the TPC.
// The clusters must be already loaded !
class AliTPCParam;
class TObjArray;
class TClonesArray;
-class AliESD;
+class AliESDEvent;
class AliTPCtracker : public AliTracker {
public:
void UnloadClusters();
AliCluster *GetCluster(Int_t index) const;
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
virtual void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
#include "AliLog.h"
#include "AliComplexCluster.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliKink.h"
#include "AliV0.h"
#include "AliHelix.h"
}
-void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESD * event)
+void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESDEvent * event)
{
// set input
}
-Int_t AliTPCtrackerMI::RefitInward(AliESD *event)
+Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
{
//
// back propagation of ESD tracks
}
-Int_t AliTPCtrackerMI::PropagateBack(AliESD *event)
+Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
{
//
// back propagation of ESD tracks
fSeeds =0;
}
-void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction)
+void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction)
{
//
//read seeds from the event
return seed;
}
-void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
+void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
{
//
// find kinks
timer.Print();
}
-void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
+void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESDEvent *esd)
{
//
// find V0s
return 0;
}
-Int_t AliTPCtrackerMI::Clusters2Tracks (AliESD *esd)
+Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *esd)
{
//
if (fSeeds) DeleteSeeds();
class AliTPCParam;
class AliTPCseed;
class AliTPCTrackerPoint;
-class AliESD;
+class AliESDEvent;
class TTree;
class AliESDkink;
class TTreeSRedirector;
virtual ~AliTPCtrackerMI();
//
void SetIteration(Int_t iteration){fIteration = iteration;}
- virtual Int_t Clusters2Tracks (AliESD *esd);
- virtual Int_t RefitInward (AliESD *esd);
+ virtual Int_t Clusters2Tracks (AliESDEvent *esd);
+ virtual Int_t RefitInward (AliESDEvent *esd);
virtual Int_t LoadClusters (TTree * tree);
Int_t LoadClusters();
void UnloadClusters();
void Transform(AliTPCclusterMI * cluster);
//
void SetIO(); //set default IO from folders
- void SetIO(TTree * input, TTree * output, AliESD * event);
+ void SetIO(TTree * input, TTree * output, AliESDEvent * event);
void FillESD(TObjArray* arr);
void WriteTracks();
void WriteTracks(TTree * tree);
void DeleteSeeds();
void SetDebug(Int_t debug){ fDebug = debug;}
- void FindKinks(TObjArray * array, AliESD * esd);
- void FindV0s(TObjArray * array, AliESD * esd);
+ void FindKinks(TObjArray * array, AliESDEvent * esd);
+ void FindV0s(TObjArray * array, AliESDEvent * esd);
void UpdateKinkQualityM(AliTPCseed * seed);
void UpdateKinkQualityD(AliTPCseed * seed);
Int_t CheckKinkPoint(AliTPCseed*seed, AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink);
Int_t FollowToNextCluster( AliTPCseed& t, Int_t nr);
Int_t PropagateBack(TObjArray * arr);
- Int_t PropagateBack(AliESD * event);
+ Int_t PropagateBack(AliESDEvent * event);
Int_t PropagateBack(AliTPCseed *pt, Int_t row0, Int_t row1);
Int_t PropagateForward();
Int_t PropagateForward2(TObjArray * arr);
Float_t GetSigmaZ(AliTPCseed * seed);
void GetShape(AliTPCseed * seed, Int_t row);
- void ReadSeeds(AliESD *event, Int_t direction); //read seeds from the event
+ void ReadSeeds(AliESDEvent *event, Int_t direction); //read seeds from the event
void MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t cuts[4], Float_t deltay = -1, Int_t ddsec=0);
void MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t cuts[4], Float_t deltay = -1);
TTree * fOutput; // output tree with tracks
TTree * fSeedTree; // output tree with seeds - filled in debug mode 1
TTree * fTreeDebug; // output with a debug information about track
- AliESD * fEvent; // output with esd tracks
+ AliESDEvent * fEvent; // output with esd tracks
Int_t fDebug; // debug option
Bool_t fNewIO; // indicated if we have data using New IO
Int_t fNtracks; //current number of tracks
Double_t fPadLength[200]; // max y for given pad row
const AliTPCParam *fParam; //pointer to the parameters
TTreeSRedirector *fDebugStreamer; //!debug streamer
- ClassDef(AliTPCtrackerMI,1)
+ ClassDef(AliTPCtrackerMI,2)
};
#include "AliRawReader.h"
#include "AliLog.h"
#include "AliESDTrdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliTRDReconstructor.h"
#include "AliTRDclusterizerV1.h"
//_____________________________________________________________________________
void AliTRDReconstructor::FillESD(AliRunLoader* /*runLoader*/
, AliRawReader* /*rawReader*/
- , AliESD *esd) const
+ , AliESDEvent *esd) const
{
//
// Make PID
//_____________________________________________________________________________
void AliTRDReconstructor::FillESD(AliRawReader* /*rawReader*/
, TTree* /*clusterTree*/
- , AliESD *esd) const
+ , AliESDEvent *esd) const
{
//
// Make PID
//_____________________________________________________________________________
void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/
, TTree* /*clusterTree*/
- , AliESD *esd) const
+ , AliESDEvent *esd) const
{
//
// Make PID
//_____________________________________________________________________________
void AliTRDReconstructor::FillESD(AliRunLoader* /*runLoader*/
- , AliESD *esd) const
+ , AliESDEvent *esd) const
{
//
// Make PID
virtual AliTracker *CreateTracker(AliRunLoader *runLoader) const;
- virtual void FillESD(AliRunLoader *runLoader, AliRawReader *rawReader, AliESD *esd) const;
- virtual void FillESD(AliRawReader *rawReader, TTree *clusterTree, AliESD *esd) const;
- virtual void FillESD(TTree *digitsTree, TTree *clusterTree, AliESD *esd) const;
- virtual void FillESD(AliRunLoader *runLoader, AliESD *esd) const;
+ virtual void FillESD(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd) const;
+ virtual void FillESD(AliRawReader *rawReader, TTree *clusterTree, AliESDEvent *esd) const;
+ virtual void FillESD(TTree *digitsTree, TTree *clusterTree, AliESDEvent *esd) const;
+ virtual void FillESD(AliRunLoader *runLoader, AliESDEvent *esd) const;
static void SetSeedingOn(Bool_t seeding) { fgkSeedingOn = seeding; }
static void SetStreamLevel(Int_t level) { fgStreamLevel = level; }
// Implementation of the TRD PID class //
// //
// Assigns the electron and pion likelihoods to each ESD track. //
-// The function MakePID(AliESD *event) calculates the probability //
+// The function MakePID(AliESDEvent *event) calculates the probability //
// of having dedx and a maximum timbin at a given //
// momentum (mom) and particle type k //
// from the precalculated distributions. //
////////////////////////////////////////////////////////////////////////////
#include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliTracker.h"
}
//_____________________________________________________________________________
-Int_t AliTRDpidESD::MakePID(AliESD *event)
+Int_t AliTRDpidESD::MakePID(AliESDEvent *event)
{
//
// This function calculates the PID probabilities based on TRD signals
#include <TObject.h>
-class AliESD;
+class AliESDEvent;
class AliESDtrack;
class AliExternalTrackParam;
class AliTRDpidESD : public TObject {
virtual void Copy(TObject &p) const;
static Bool_t CheckTrack(AliESDtrack *t);
- Int_t MakePID(AliESD *event);
+ Int_t MakePID(AliESDEvent *event);
void SetCheckTrackStatus(Bool_t status = kTRUE) { fCheckTrackStatus = status; };
void SetCheckKinkStatus(Bool_t status = kTRUE) { fCheckKinkStatus = status; };
#include <TTree.h>
#include <TTreeStream.h>
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliAlignObj.h"
#include "AliRieman.h"
#include "AliTrackPointArray.h"
}
//_____________________________________________________________________________
-Int_t AliTRDtracker::Clusters2Tracks(AliESD *event)
+Int_t AliTRDtracker::Clusters2Tracks(AliESDEvent *event)
{
//
// Finds tracks within the TRD. The ESD event is expected to contain seeds
}
//_____________________________________________________________________________
-Int_t AliTRDtracker::PropagateBack(AliESD *event)
+Int_t AliTRDtracker::PropagateBack(AliESDEvent *event)
{
//
// Gets seeds from ESD event. The seeds are AliTPCtrack's found and
}
//_____________________________________________________________________________
-Int_t AliTRDtracker::RefitInward(AliESD *event)
+Int_t AliTRDtracker::RefitInward(AliESDEvent *event)
{
//
// Refits tracks within the TRD. The ESD event is expected to contain seeds
}
//_____________________________________________________________________________
-void AliTRDtracker::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESD *esd)
+void AliTRDtracker::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESDEvent *esd)
{
//
// Creates seeds using clusters between position inner plane and outer plane
class AliTRDtracklet;
class AliTRDcluster;
class AliTRDseed;
-class AliESD;
+class AliESDEvent;
class TTreeSRedirector;
///////////////////////////////////////////////////////////////////////////////
return (AliCluster *) fClusters->UncheckedAt(index); }
static Int_t Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);
- Int_t Clusters2Tracks(AliESD *event);
- Int_t PropagateBack(AliESD *event);
- Int_t RefitInward(AliESD *event);
+ Int_t Clusters2Tracks(AliESDEvent *event);
+ Int_t PropagateBack(AliESDEvent *event);
+ Int_t RefitInward(AliESDEvent *event);
virtual void CookLabel(AliKalmanTrack *t, Float_t wrong) const;
private:
AliTRDtrack *RegisterSeed(AliTRDseed *seeds, Double_t *params);
- void MakeSeedsMI(Int_t inner, Int_t outer, AliESD *esd = 0);
+ void MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
Int_t FollowBackProlongation(AliTRDtrack &t);
Int_t FollowProlongation(AliTRDtrack &t);
#include "AliRunLoader.h"
#include "AliTRDgeometry.h"
#include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliTrackReference.h"
}
fEsdTree = (TTree*)esdFile->Get("esdTree");
- fESD = new AliESD();
+ fESD = new AliESDEvent();
fESD->ReadFromTree(fEsdTree);
//fEsdTree->SetBranchAddress("ESD", &fESD);
}
class AliRunLoader;
class AliTRDgeometry;
-class AliESD;
+class AliESDEvent;
class AliTRDcluster;
class AliTRDtracker;
AliRunLoader *fLoader; // AliRunLoader instance
TTree *fEsdTree; // ESD tree
- AliESD *fESD; // ESD
+ AliESDEvent *fESD; // ESD
AliTRDtracker *fTracker; // TRD tracker instance
#include "AliRunLoader.h"
#include "AliRawReader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliZDCDigit.h"
#include "AliZDCRawStream.h"
#include "AliZDCReco.h"
//_____________________________________________________________________________
void AliZDCReconstructor::FillESD(AliRunLoader* runLoader,
- AliESD* esd) const
+ AliESDEvent* esd) const
{
// fill energies and number of participants to the ESD
{AliReconstructor::Reconstruct(digitsTree,clustersTree);}
virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
{AliReconstructor::Reconstruct(rawReader,clustersTree);}
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
- virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESD* esd) const
+ virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+ virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const
{AliReconstructor::FillESD(digitsTree,clustersTree,esd);}
- virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESD* esd) const
+ virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESDEvent* esd) const
{AliReconstructor::FillESD(rawReader,clustersTree,esd);}
- virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESD* esd) const
+ virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESDEvent* esd) const
{AliReconstructor::FillESD(runLoader,rawReader,esd);}
AliCDBStorage *SetStorage(const char* uri);
name = "AliESDs.root";
TFile * fSig = TFile::Open(name.Data());
TTree * tSig = (TTree*)fSig->Get("esdTree");
- TBranch * bSig = tSig->GetBranch("ESD");
- AliESD * esdSig = 0; // The signal ESD object is put here
- bSig->SetAddress(&esdSig);
+ AliESDEvent * esdSig = new AliESDEvent; // The signal ESD object is put here
+ esdSig->ReadFromTree(tSig);
// Run loader
name = "galice.root";
cout << "Signal event " << iev << endl;
// Get ESD
- bSig->GetEntry(iev);
+ tSig->GetEntry(iev);
// Get MC
rlSig->GetEvent(iev);
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff