Adding the VZERO information to the ESD
[u/mrichter/AliRoot.git] / STEER / AliESD.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 //-----------------------------------------------------------------
19 //           Implementation of the ESD class
20 //   This is the class to deal with during the phisical analysis of data
21 //   This class is generated directly by the reconstruction methods
22 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
23 //-----------------------------------------------------------------
24
25 #include "AliESD.h"
26 #include "AliESDfriend.h"
27
28 ClassImp(AliESD)
29
30 //______________________________________________________________________________
31 AliESD::AliESD():
32   fEventNumber(0),
33   fRunNumber(0),
34   fTimeStamp(0),
35   fEventType(0),
36   fTriggerMask(0),
37   fTriggerCluster(0),
38   fRecoVersion(0),
39   fMagneticField(0),
40   fZDCN1Energy(0),
41   fZDCP1Energy(0),
42   fZDCN2Energy(0),
43   fZDCP2Energy(0),
44   fZDCEMEnergy(0),
45   fZDCParticipants(0),
46   fT0zVertex(0),
47   fSPDVertex(),
48   fPrimaryVertex(),
49   fSPDMult(),
50   fT0timeStart(0),
51   fTracks("AliESDtrack",15000),
52   fHLTConfMapTracks("AliESDHLTtrack",25000),
53   fHLTHoughTracks("AliESDHLTtrack",15000),
54   fMuonTracks("AliESDMuonTrack",30),
55   fPmdTracks("AliESDPmdTrack",3000),
56   fTrdTracks("AliESDTrdTrack",300),
57   fV0s("AliESDv0",200),  
58   fCascades("AliESDcascade",20),
59   fKinks("AliESDkink",4000),
60   fCaloClusters("AliESDCaloCluster",10000),
61   fEMCALClusters(0), 
62   fFirstEMCALCluster(-1),
63   fPHOSClusters(0), 
64   fFirstPHOSCluster(-1),
65   fESDFMD(0x0),
66   fESDVZERO(0x0)
67 {
68   for (Int_t i=0; i<24; i++) {
69     fT0time[i] = 0;
70     fT0amplitude[i] = 0;
71   }
72 }
73 //______________________________________________________________________________
74 AliESD::AliESD(const AliESD& esd):
75   TObject(esd),
76   fEventNumber(esd.fEventNumber),
77   fRunNumber(esd.fRunNumber),
78   fTimeStamp(esd.fTimeStamp),
79   fEventType(esd.fEventType),
80   fTriggerMask(esd.fTriggerMask),
81   fTriggerCluster(esd.fTriggerCluster),
82   fRecoVersion(esd.fRecoVersion),
83   fMagneticField(esd.fMagneticField),
84   fZDCN1Energy(esd.fZDCN1Energy),
85   fZDCP1Energy(esd.fZDCP1Energy),
86   fZDCN2Energy(esd.fZDCN2Energy),
87   fZDCP2Energy(esd.fZDCP2Energy),
88   fZDCEMEnergy(esd.fZDCEMEnergy),
89   fZDCParticipants(esd.fZDCParticipants),
90   fT0zVertex(esd.fT0zVertex),
91   fSPDVertex(esd.fSPDVertex),
92   fPrimaryVertex(esd.fPrimaryVertex),
93   fSPDMult(esd.fSPDMult),
94   fT0timeStart(esd.fT0timeStart),
95   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
96   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
97   fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
98   fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
99   fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
100   fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
101   fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
102   fCascades(*((TClonesArray*)esd.fCascades.Clone())),
103   fKinks(*((TClonesArray*)esd.fKinks.Clone())),
104   fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
105   fEMCALClusters(esd.fEMCALClusters), 
106   fFirstEMCALCluster(esd.fFirstEMCALCluster),
107   fPHOSClusters(esd.fPHOSClusters), 
108   fFirstPHOSCluster(esd.fFirstPHOSCluster),
109   fESDFMD(esd.fESDFMD),
110   fESDVZERO(esd.fESDVZERO)
111 {
112   for (Int_t i=0; i<24; i++) {
113     fT0time[i] = esd.fT0time[i];
114     fT0amplitude[i] = esd.fT0amplitude[i];
115   }
116 }
117
118 //______________________________________________________________________________
119 AliESD & AliESD::operator=(const AliESD& source) {
120
121   // Assignment operator
122
123   if(&source == this) return *this;
124
125   fEventNumber = source.fEventNumber;
126   fRunNumber = source.fRunNumber;
127   fTimeStamp   = source.fTimeStamp;
128   fEventType   = source.fEventType;
129   fTriggerMask = source.fTriggerMask;
130   fTriggerCluster = source.fTriggerCluster;
131   fRecoVersion = source.fRecoVersion;
132   fMagneticField = source.fMagneticField;
133   fZDCN1Energy = source.fZDCN1Energy;
134   fZDCP1Energy = source.fZDCP1Energy;
135   fZDCN2Energy = source.fZDCN2Energy;
136   fZDCP2Energy = source.fZDCP2Energy;
137   fZDCEMEnergy = source.fZDCEMEnergy;
138   fZDCParticipants = source.fZDCParticipants;
139   fT0zVertex = source.fT0zVertex;
140   fSPDVertex = source.fSPDVertex;
141   fPrimaryVertex = source.fPrimaryVertex;
142   fSPDMult = source.fSPDMult;
143   fT0timeStart = source.fT0timeStart;
144   fTracks = *((TClonesArray*)source.fTracks.Clone());
145   fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
146   fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
147   fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
148   fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
149   fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
150   fV0s = *((TClonesArray*)source.fV0s.Clone());
151   fCascades = *((TClonesArray*)source.fCascades.Clone());
152   fKinks = *((TClonesArray*)source.fKinks.Clone());
153   fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
154   fEMCALClusters = source.fEMCALClusters;
155   fFirstEMCALCluster = source.fFirstEMCALCluster;
156   fPHOSClusters = source.fPHOSClusters;
157   fFirstPHOSCluster = source.fFirstPHOSCluster;
158   fESDFMD = source.fESDFMD;
159   fESDVZERO = source.fESDVZERO;
160
161   for (Int_t i=0; i<24; i++) {
162     fT0time[i] = source.fT0time[i];
163     fT0amplitude[i] = source.fT0amplitude[i];
164   }
165
166   return *this;
167
168 }
169
170
171 //______________________________________________________________________________
172 AliESD::~AliESD()
173 {
174   //
175   // Standard destructor
176   //
177   fTracks.Delete();
178   fHLTConfMapTracks.Delete();
179   fHLTHoughTracks.Delete();
180   fMuonTracks.Delete();
181   fPmdTracks.Delete();
182   fTrdTracks.Delete();
183   fV0s.Delete();
184   fCascades.Delete();
185   fKinks.Delete();
186   fCaloClusters.Delete();
187   delete fESDFMD;
188   delete fESDVZERO;
189 }
190
191 //______________________________________________________________________________
192 void AliESD::Reset()
193 {
194   fEventNumber=0;
195   fRunNumber=0;
196   fTimeStamp = 0;
197   fEventType = 0;
198   fTriggerMask=0;
199   fTriggerCluster=0;
200   fRecoVersion=0;
201   fMagneticField=0;
202   fZDCN1Energy=0;
203   fZDCP1Energy=0;
204   fZDCN2Energy=0;
205   fZDCP2Energy=0;
206   fZDCEMEnergy=0;
207   fZDCParticipants=0;
208   fT0zVertex=0;
209   fT0timeStart = 0;
210   new (&fSPDVertex) AliESDVertex();
211   new (&fPrimaryVertex) AliESDVertex();
212   new (&fSPDMult) AliMultiplicity();
213   fTracks.Clear();
214   fHLTConfMapTracks.Clear();
215   fHLTHoughTracks.Clear();
216   fMuonTracks.Clear();
217   fPmdTracks.Clear();
218   fTrdTracks.Clear();
219   fV0s.Clear();
220   fCascades.Clear();
221   fCaloClusters.Clear();
222   fEMCALClusters=0; 
223   fFirstEMCALCluster=-1; 
224   fPHOSClusters=0; 
225   fFirstPHOSCluster=-1; 
226   if (fESDFMD) fESDFMD->Clear();
227 }
228
229 Int_t AliESD::AddV0(const AliESDv0 *v) {
230   //
231   // Add V0
232   //
233     Int_t idx=fV0s.GetEntriesFast();
234     new(fV0s[idx]) AliESDv0(*v);
235     return idx;
236 }  
237
238 //______________________________________________________________________________
239 void AliESD::Print(Option_t *) const 
240 {
241   //
242   // Print header information of the event
243   //
244   printf("ESD run information\n");
245   printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
246          GetEventNumber(),
247          GetRunNumber(),
248          GetTriggerMask(),
249          GetMagneticField() );
250     printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
251            fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
252            fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
253            fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
254     printf("SPD Multiplicity. Number of tracklets %d \n",
255            fSPDMult.GetNumberOfTracklets());
256   printf("Event from reconstruction version %d \n",fRecoVersion);
257   printf("Number of tracks: \n");
258   printf("                 charged   %d\n", GetNumberOfTracks());
259   printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
260   printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
261   printf("                 muon      %d\n", GetNumberOfMuonTracks());
262   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
263   printf("                 trd       %d\n", GetNumberOfTrdTracks());
264   printf("                 v0        %d\n", GetNumberOfV0s());
265   printf("                 cascades  %d\n", GetNumberOfCascades());
266   printf("                 kinks     %d\n", GetNumberOfKinks());
267   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
268   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
269   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
270   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
271   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
272 }
273
274 void AliESD::SetESDfriend(const AliESDfriend *ev) {
275   //
276   // Attaches the complementary info to the ESD
277   //
278   if (!ev) return;
279
280   Int_t ntrk=ev->GetNumberOfTracks();
281
282   for (Int_t i=0; i<ntrk; i++) {
283     const AliESDfriendTrack *f=ev->GetTrack(i);
284     GetTrack(i)->SetFriendTrack(f);
285   }
286 }
287
288 void AliESD::GetESDfriend(AliESDfriend *ev) const {
289   //
290   // Extracts the complementary info from the ESD
291   //
292   if (!ev) return;
293
294   Int_t ntrk=GetNumberOfTracks();
295
296   for (Int_t i=0; i<ntrk; i++) {
297     const AliESDtrack *t=GetTrack(i);
298     const AliESDfriendTrack *f=t->GetFriendTrack();
299     ev->AddTrack(f);
300   }
301 }