bcd41cc80d1f5086ad7efa058e498abf80970446
[u/mrichter/AliRoot.git] / RAW / AliRawReaderRoot.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 ///////////////////////////////////////////////////////////////////////////////
17 //
18 // This is a class for reading a raw data from a root file and providing
19 // information about digits
20 //
21 ///////////////////////////////////////////////////////////////////////////////
22
23 #include "AliRawReaderRoot.h"
24
25
26 ClassImp(AliRawReaderRoot)
27
28
29 AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber)
30 {
31 // create an object to read digits from the given input file for the
32 // event with the given number
33
34   fFile = TFile::Open(fileName);
35   if (!fFile || !fFile->IsOpen()) {
36     Error("AliRawReaderRoot", "could not open file %s", fileName);
37     return;
38   }
39   TTree* tree = (TTree*) fFile->Get("RAW");
40   if (!tree) {
41     Error("AliRawReaderRoot", "no raw data tree found");
42     return;
43   }
44   TBranch* branch = tree->GetBranch("rawevent");
45   if (!branch) {
46     Error("AliRawReaderRoot", "no raw data branch found");
47     return;
48   }
49
50   fEvent = new AliRawEvent;
51   branch->SetAddress(&fEvent);
52   if (branch->GetEntry(eventNumber) <= 0) {
53     Error("AliRawReaderRoot", "no event with number %d found", eventNumber);
54     return;
55   }
56   
57   fSubEventIndex = 0;
58   fSubEvent = NULL;
59   fRawData = NULL;
60   fMiniHeader = NULL;
61
62   fCount = 0;
63   fPosition = fEnd = NULL;
64 }
65
66 AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event)
67 {
68 // create an object to read digits from the given raw event
69
70   fFile = NULL;
71   fEvent = event;
72   
73   fSubEventIndex = 0;
74   fSubEvent = NULL;
75   fRawData = NULL;
76   fMiniHeader =  NULL;
77
78   fCount = 0;
79   fPosition = fEnd = NULL;
80 }
81
82 AliRawReaderRoot::~AliRawReaderRoot()
83 {
84 // delete objects and close root file
85
86   if (fFile) {
87     if (fEvent) delete fEvent;
88     fFile->Close();
89     delete fFile;
90   }
91 }
92
93
94 UInt_t AliRawReaderRoot::GetType()
95 {
96 // get the type from the event header
97
98   if (!fEvent) return 0;
99   return fEvent->GetHeader()->GetType();
100 }
101
102 UInt_t AliRawReaderRoot::GetRunNumber()
103 {
104 // get the run number from the event header
105
106   if (!fEvent) return 0;
107   return fEvent->GetHeader()->GetRunNumber();
108 }
109
110 const UInt_t* AliRawReaderRoot::GetEventId()
111 {
112 // get the event id from the event header
113
114   if (!fEvent) return NULL;
115   return fEvent->GetHeader()->GetId();
116 }
117
118 const UInt_t* AliRawReaderRoot::GetTriggerPattern()
119 {
120 // get the trigger pattern from the event header
121
122   if (!fEvent) return NULL;
123   return fEvent->GetHeader()->GetTriggerPattern();
124 }
125
126 const UInt_t* AliRawReaderRoot::GetDetectorPattern()
127 {
128 // get the detector pattern from the event header
129
130   if (!fEvent) return NULL;
131   return fEvent->GetHeader()->GetDetectorPattern();
132 }
133
134 const UInt_t* AliRawReaderRoot::GetAttributes()
135 {
136 // get the type attributes from the event header
137
138   if (!fEvent) return NULL;
139   return fEvent->GetHeader()->GetTypeAttribute();
140 }
141
142 UInt_t AliRawReaderRoot::GetGDCId()
143 {
144 // get the GDC Id from the event header
145
146   if (!fEvent) return 0;
147   return fEvent->GetHeader()->GetGDCId();
148 }
149
150
151 Bool_t AliRawReaderRoot::ReadMiniHeader()
152 {
153 // read a mini header at the current position
154 // returns kFALSE if the mini header could not be read
155
156   if (!fEvent) return kFALSE;
157   do {
158     if (fCount > 0) fPosition += fCount;      // skip payload if event was not selected
159     if (!fSubEvent || (fPosition >= fEnd)) {  // new sub event
160       if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
161       fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);
162       fRawData = fSubEvent->GetRawData();
163       fCount = 0;
164       fPosition = (UChar_t*) fRawData->GetBuffer();
165       fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
166     }
167     if (fPosition >= fEnd) continue;          // no data left in the payload
168     if (fPosition + sizeof(AliMiniHeader) > fEnd) {
169       Error("ReadMiniHeader", "could not read data!");
170       return kFALSE;
171     }
172     fMiniHeader = (AliMiniHeader*) fPosition;
173     fPosition += sizeof(AliMiniHeader);
174     CheckMiniHeader();
175     fCount = fMiniHeader->fSize;
176     if (fPosition + fCount > fEnd) {  // check data size in mini header and sub event
177       Error("ReadMiniHeader", "size in mini header exceeds event size!");
178       fMiniHeader->fSize = fCount = fEnd - fPosition;
179     }
180   } while (!IsSelected());
181   return kTRUE;
182 }
183
184 Bool_t AliRawReaderRoot::ReadNextData(UChar_t*& data)
185 {
186 // reads the next payload at the current position
187 // returns kFALSE if the data could not be read
188
189   while (fCount == 0) {
190     if (!ReadMiniHeader()) return kFALSE;
191   }
192   data = fPosition;
193   fPosition += fCount;  
194   fCount = 0;
195   return kTRUE;
196 }
197
198 Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size)
199 {
200 // reads the next block of data at the current position
201 // returns kFALSE if the data could not be read
202
203   if (fPosition + size > fEnd) {
204     Error("ReadNext", "could not read data!");
205     return kFALSE;
206   }
207   memcpy(data, fPosition, size);
208   fPosition += size;
209   fCount -= size;
210   return kTRUE;
211 }
212
213
214 Bool_t AliRawReaderRoot::Reset()
215 {
216 // reset the current position to the beginning of the event
217
218   fSubEventIndex = 0;
219   fSubEvent = NULL;
220   fRawData = NULL;
221   fMiniHeader = NULL;
222
223   fCount = 0;
224   fPosition = fEnd = NULL;
225   return kTRUE;
226 }
227