Coding violations in HLT/MUON
[u/mrichter/AliRoot.git] / HLT / MUON / src / AliRoot / ADCStreamSource.cxx
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // Author: Artur Szostak
4 // Email:  artur@alice.phy.uct.ac.za | artursz@iafrica.com
5 //
6 ////////////////////////////////////////////////////////////////////////////////
7
8 /* AliHLTMUONADCStreamSource is used to store the raw DDL data generated
9    from an AliRoot simulation.
10    This class is used as a storage class for the input dataset for
11    AliHLTMUONMicrodHLT.
12  */
13
14 #include "AliRoot/ADCStreamSource.hpp"
15 #include "AliRoot/Base.hpp"
16 #include "TSystem.h"
17 #include <stdio.h>
18
19 // TODO: Change all the Error message statements to AliError at some stage.
20
21 ClassImp(AliHLTMUONADCStreamSource)
22 ClassImp(AliHLTMUONADCStreamSource::AliDataBlock)
23
24
25 AliHLTMUONADCStreamSource::AliHLTMUONADCStreamSource()
26         : TObject(), fList(AliHLTMUONADCStreamSource::AliDataBlock::Class())
27 {
28         fCurrentStream = -1;
29 }
30
31
32 AliHLTMUONADCStreamSource::~AliHLTMUONADCStreamSource()
33 {
34         // Everything is cleaned up implicitly.
35 }
36
37
38 void AliHLTMUONADCStreamSource::FillFromFile(const TString& filename, Int_t eventnumber)
39 {
40 // Fills the internal data structures from the specified file.
41
42         DebugMsg(1, "Entering FillFromFile, file = " << filename.Data()
43                 << ", event number = " << eventnumber
44         );
45         FILE* file = fopen(filename, "r");
46         try
47         {
48                 Long_t id = -1;
49                 Long64_t size = -1;
50                 Long_t flags = -1;
51                 Long_t modtime = -1;
52                 if ( gSystem->GetPathInfo(filename, &id, &size, &flags, &modtime) == 0 )
53                 {
54                         DebugMsg(2, "Size of file: " << filename.Data() << " is " << size << " bytes");
55                         AliHLTMUONADCStream stream;
56                         stream.Size(size/sizeof(Int_t));
57                         size_t bytesread = fread(stream.Data(), 1, size, file);
58                         if (bytesread == (size_t)size)
59                                 AddStream(stream, eventnumber);
60                         else
61                                 Error("FillFromFile", "Could not read from file: %s", filename.Data());
62                 }
63                 else
64                         Error("FillFromFile", "Could not stat the file: %s", filename.Data());
65         }
66         finally
67         (
68                 fclose(file);
69         );
70         
71         DebugMsg(1, "Leaving FillFromFile");
72 }
73
74
75 void AliHLTMUONADCStreamSource::FillFrom(const TString& directory, Int_t eventnumber)
76 {
77 // Fills the internal data structures from the specified directory.
78 // FillFromFile is called for every file in the directory that is
79 // prefixed with MUON_ and ends in .ddl
80
81         DebugMsg(1, "Entering FillFrom, directory = " << directory.Data()
82                 << ", event number = " << eventnumber
83         );
84         
85         void* dir = gSystem->OpenDirectory(directory);
86         try
87         {
88                 const char* entry = gSystem->GetDirEntry(dir);
89                 while (entry != NULL)
90                 {
91                         TString filename = entry;
92                         if (filename.BeginsWith("MUON"))
93                                 FillFromFile(filename, eventnumber);
94                         entry = gSystem->GetDirEntry(dir);
95                 };
96         }
97         finally
98         (
99                 gSystem->FreeDirectory(dir);
100         );
101         
102         
103         DebugMsg(1, "Leaving FillFrom");
104 }
105
106
107 void AliHLTMUONADCStreamSource::FillFrom(
108                 const TString& dirprefix, UInt_t firstevent, UInt_t lastevent
109         )
110 {
111 // Same as the methods above except the directory name is created as
112 // dirprefix + eventnumber, where eventnumber is looped from firstevent
113 // to lastevent.
114
115         DebugMsg(1, "Entering FillFrom");
116         
117         for (UInt_t i = firstevent; i <= lastevent; i++)
118         {
119                 TString dirname = dirprefix;
120                 dirname += i;
121                 FillFrom(dirname, i);
122         };
123         
124         DebugMsg(1, "Leaving FillFrom");
125 }
126
127
128 void AliHLTMUONADCStreamSource::Clear(Option_t* /*option*/)
129 {
130 // Clears all the internal arrays.
131
132         fCurrentStream = -1;
133         fList.Clear("C");
134 }
135
136
137 Int_t AliHLTMUONADCStreamSource::NumberOfStreams() const
138 {
139 // Returns the number of ADC streams stored.
140
141         return fList.GetEntriesFast();
142 }
143
144
145 Bool_t AliHLTMUONADCStreamSource::GetStream(Int_t index) const
146 {
147 // Fetches the index'th ADC stream stored.
148 // kTRUE is returned if the stream was found, kFALSE otherwise.
149
150         if ( 0 <= index && index < NumberOfStreams() )
151         {
152                 fCurrentStream = index;
153                 return kTRUE;
154         }
155         else
156         {
157                 // The index is out of bounds so inform the user.
158                 if (NumberOfStreams() > 0)
159                         Error(  "GetStream",
160                                 "The ADC stream index (%d) is out of bounds. Valid range is [0, %d]",
161                                 index, NumberOfStreams() - 1
162                         );
163                 else
164                         Error(  "GetStream",
165                                 "The ADC stream index (%d) is out of bounds. No streams found.",
166                                 index
167                         );
168                 return kFALSE;
169         }
170 }
171
172
173 Bool_t AliHLTMUONADCStreamSource::FirstStream() const
174 {
175 // Fetches the first ADC stream stored.
176 // kTRUE is returned if the stream was found, kFALSE otherwise.
177
178         if (NumberOfStreams() > 0)
179         {
180                 fCurrentStream = 0;
181                 return kTRUE;
182         }
183         else
184                 return kFALSE;
185 }
186
187
188 Bool_t AliHLTMUONADCStreamSource::NextStream() const
189 {
190 // Fetches the next ADC stream stored following the currently selected one.
191 // kTRUE is returned if the stream was found, kFALSE otherwise.
192
193         if ( 0 <= fCurrentStream && fCurrentStream < NumberOfStreams() - 1 )
194         {
195                 fCurrentStream++;
196                 return kTRUE;
197         }
198         else
199                 return kFALSE;
200 };
201
202
203 Int_t AliHLTMUONADCStreamSource::EventNumber() const
204 {
205 // Returns the corresponding AliRoot event number for the current stream.
206 // -1 is returned if no stream is selected.
207
208         if (fCurrentStream >= 0)
209         {
210                 Assert( fCurrentStream < NumberOfStreams() );
211                 return ((AliDataBlock*)fList[fCurrentStream])->EventNumber();
212         }
213         else
214         {
215                 Error("EventNumber", "No ADC stream selected.");
216                 return -1;
217         }
218 }
219
220
221 Bool_t AliHLTMUONADCStreamSource::FetchStream(AliHLTMUONADCStream& stream) const
222 {
223 // Returns the current ADC stream selected.
224 // kFALSE is returned if there is no stream selected.
225
226         if (fCurrentStream >= 0)
227         {
228                 Assert( fCurrentStream < NumberOfStreams() );
229                 stream = ((AliDataBlock*)fList[fCurrentStream])->Stream();
230                 return kTRUE;
231         }
232         else
233         {
234                 Error("FetchStream", "No ADC stream selected.");
235                 return kFALSE;
236         }
237 }
238
239
240 Bool_t AliHLTMUONADCStreamSource::FetchStream(Int_t index, AliHLTMUONADCStream& stream) const
241 {
242 // Returns the index'th ADC stream.
243 // kTRUE is returned if the stream was found, kFALSE otherwise.
244
245         if ( GetStream(index) )
246                 return FetchStream(stream);
247         else
248                 return kFALSE;
249 }
250
251
252 const AliHLTMUONADCStream* AliHLTMUONADCStreamSource::FetchStream() const
253 {
254 // Returns the current ADC stream selected.
255 // A NULL pointer is returned if no ADC stream is selected.
256
257         if (fCurrentStream >= 0)
258         {
259                 Assert( fCurrentStream < NumberOfStreams() );
260                 return &( ((AliDataBlock*)fList[fCurrentStream])->Stream() );
261         }
262         else
263         {
264                 Error("FetchStream", "No ADC stream selected.");
265                 return NULL;
266         }
267 }
268
269
270 void AliHLTMUONADCStreamSource::AddStream(
271                 AliHLTMUONADCStream& stream, UInt_t eventnumber
272         )
273 {
274 // Adds a new AliHLTMUONADCStream object to the internal arrays.
275
276         DebugMsg(1, "Entering AddStream");
277         
278         fCurrentStream = fList.GetEntriesFast();
279         new ( fList[fCurrentStream] ) AliDataBlock();
280         ((AliDataBlock*)fList[fCurrentStream])->EventNumber() = eventnumber;
281         ((AliDataBlock*)fList[fCurrentStream])->Stream() = stream;
282         
283         DebugMsg(1, "Leaving AddStream");
284 }
285