]>
Commit | Line | Data |
---|---|---|
6923e953 | 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 raw data from a root chain. | |
19 | /// There are two constructors available - one from a text file containing the | |
20 | /// list of root raw-data files to be processed and one directly from | |
21 | /// TFileCollection. | |
22 | /// | |
23 | /// cvetan.cheshkov@cern.ch 29/07/2008 | |
24 | /// | |
25 | /////////////////////////////////////////////////////////////////////////////// | |
26 | ||
27 | #include <TChain.h> | |
28 | #include <TFileCollection.h> | |
3d456d99 | 29 | #include <TEntryList.h> |
30 | #include "TGridCollection.h" | |
31 | #include <TPluginManager.h> | |
32 | #include <TROOT.h> | |
33 | #include <TSystem.h> | |
34 | #include <TFile.h> | |
35 | #include <TKey.h> | |
bb0edcaf | 36 | #include <TGrid.h> |
37 | #include <TGridResult.h> | |
6923e953 | 38 | |
39 | #include "AliRawReaderChain.h" | |
33314186 | 40 | #include "AliRawVEvent.h" |
6923e953 | 41 | |
42 | ClassImp(AliRawReaderChain) | |
43 | ||
44 | AliRawReaderChain::AliRawReaderChain() : | |
45 | AliRawReaderRoot(), | |
46 | fChain(NULL) | |
47 | { | |
48 | // default constructor | |
49 | } | |
50 | ||
3d456d99 | 51 | AliRawReaderChain::AliRawReaderChain(const char* fileName) : |
6923e953 | 52 | AliRawReaderRoot(), |
53 | fChain(NULL) | |
54 | { | |
55 | // create raw-reader objects which takes as an input a root chain | |
3d456d99 | 56 | // either from the file list found in 'fileName' (IsCollection = true) |
57 | // or from entry list found in 'filename' (IsCollection = false) | |
58 | // The entry-list syntax follows root convetion: filename.root/listname | |
6923e953 | 59 | |
acce5036 | 60 | fChain = new TChain("RAW"); |
3d456d99 | 61 | |
62 | TString fileNameStr = fileName; | |
63 | if (fileNameStr.EndsWith(".xml")) { | |
64 | ||
65 | TGridCollection *collection = NULL; | |
66 | TPluginManager* pluginManager = gROOT->GetPluginManager(); | |
67 | TPluginHandler* pluginHandler = pluginManager->FindHandler("TGridCollection", "alice"); | |
68 | if (!pluginHandler) { | |
69 | pluginManager->AddHandler("TGridCollection", "alice", | |
70 | "AliXMLCollection", "ANALYSISalice", "AliXMLCollection(const char*)"); | |
71 | pluginHandler = pluginManager->FindHandler("TGridCollection", "alice"); | |
72 | } | |
73 | gSystem->Load("libANALYSIS"); | |
74 | if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) { | |
75 | collection = (TGridCollection*)pluginHandler->ExecPlugin(1,fileNameStr.Data()); | |
76 | } | |
77 | else { | |
78 | fIsValid = kFALSE; | |
79 | return; | |
80 | } | |
81 | collection->Reset(); | |
82 | Bool_t elistsExist = kFALSE; | |
83 | TEntryList *elist = new TEntryList(); | |
84 | while (collection->Next()) { | |
85 | fChain->Add(collection->GetTURL("")); | |
86 | TEntryList *list = (TEntryList *)collection->GetEntryList(""); | |
87 | if (list) { | |
88 | list->SetTreeName("RAW"); | |
89 | list->SetFileName(collection->GetTURL("")); | |
90 | elist->Add(list); | |
91 | elistsExist = kTRUE; | |
92 | } | |
93 | } | |
94 | if (elistsExist) { | |
95 | fChain->SetEntryList(elist,"ne"); | |
96 | } | |
97 | else { | |
98 | Info("AliRawReaderChain", "no entry lists found in %s. Using all entries", fileNameStr.Data()); | |
99 | delete elist; | |
100 | } | |
101 | } | |
102 | else if (fileNameStr.EndsWith(".root")) { | |
103 | ||
104 | TDirectory* dir = gDirectory; | |
105 | TFile *listFile = TFile::Open(fileNameStr.Data()); | |
106 | dir->cd(); | |
107 | if (!listFile || !listFile->IsOpen()) { | |
108 | Error("AliRawReaderChain", "could not open file %s", fileNameStr.Data()); | |
109 | fIsValid = kFALSE; | |
110 | return; | |
111 | } | |
112 | ||
113 | TEntryList *elist = NULL; | |
114 | TKey *key = NULL; | |
115 | TIter nextkey(listFile->GetListOfKeys()); | |
116 | while ((key=(TKey*)nextkey())){ | |
117 | if (strcmp("TEntryList", key->GetClassName())==0){ | |
118 | elist = (TEntryList*)key->ReadObj(); | |
119 | } | |
120 | } | |
121 | if (!elist) { | |
122 | Error("AliRawReaderChain", "no TEntryList found in %s", fileNameStr.Data()); | |
123 | fIsValid = kFALSE; | |
124 | return; | |
125 | } | |
126 | ||
127 | TEntryList *templist = NULL; | |
128 | TList *elists = elist->GetLists(); | |
129 | TIter next(elists); | |
130 | while((templist = (TEntryList*)next())){ | |
131 | Info("AliRawReaderChain", "%s added to the chain", templist->GetFileName()); | |
132 | fChain->Add(templist->GetFileName()); | |
133 | } | |
134 | fChain->SetEntryList(elist,"ne"); | |
135 | } | |
136 | else { | |
137 | ||
138 | TFileCollection collection("RAW", | |
139 | "Collection with raw-data files", | |
140 | fileNameStr.Data()); | |
141 | ||
142 | if (!fChain->AddFileInfoList((TCollection*)(collection.GetList()))) { | |
143 | Error("AliRawReaderChain","Bad file list in collection, the chain is empty"); | |
144 | fIsValid = kFALSE; | |
145 | return; | |
146 | } | |
6923e953 | 147 | } |
148 | ||
636c1780 | 149 | fChain->SetBranchStatus("*",1); |
4ebdfbcc | 150 | fChain->SetBranchAddress("rawevent",&fEvent,&fBranch); |
6923e953 | 151 | } |
152 | ||
153 | AliRawReaderChain::AliRawReaderChain(TFileCollection *collection) : | |
154 | AliRawReaderRoot(), | |
155 | fChain(NULL) | |
156 | { | |
157 | // create raw-reader objects which takes as an input a root chain | |
158 | // from a root file collection | |
159 | ||
acce5036 | 160 | fChain = new TChain("RAW"); |
6923e953 | 161 | if (!fChain->AddFileInfoList((TCollection*)(collection->GetList()))) { |
162 | Error("AliRawReaderChain","Bad file list in collection, the chain is empty"); | |
a97af23d | 163 | fIsValid = kFALSE; |
6923e953 | 164 | return; |
165 | } | |
166 | ||
636c1780 | 167 | fChain->SetBranchStatus("*",1); |
4ebdfbcc | 168 | fChain->SetBranchAddress("rawevent",&fEvent,&fBranch); |
636c1780 | 169 | } |
170 | ||
171 | AliRawReaderChain::AliRawReaderChain(TChain *chain) : | |
172 | AliRawReaderRoot(), | |
173 | fChain(chain) | |
174 | { | |
175 | // create raw-reader objects which takes as an input a root chain | |
176 | // from a root file collection | |
177 | ||
68d8e599 | 178 | if (!fChain) { |
179 | fIsValid = kFALSE; | |
180 | return; | |
181 | } | |
a97af23d | 182 | |
636c1780 | 183 | fChain->SetBranchStatus("*",1); |
4ebdfbcc | 184 | fChain->SetBranchAddress("rawevent",&fEvent,&fBranch); |
6923e953 | 185 | } |
186 | ||
3d456d99 | 187 | AliRawReaderChain::AliRawReaderChain(TEntryList *elist) : |
188 | AliRawReaderRoot(), | |
189 | fChain(NULL) | |
190 | { | |
191 | // create raw-reader objects which takes as an input a root chain | |
192 | // from a root file collection | |
193 | ||
68d8e599 | 194 | if (!elist) { |
195 | fIsValid = kFALSE; | |
196 | return; | |
197 | } | |
3d456d99 | 198 | |
199 | fChain = new TChain("RAW"); | |
200 | ||
201 | TEntryList *templist = NULL; | |
202 | TList *elists = elist->GetLists(); | |
203 | TIter next(elists); | |
204 | while((templist = (TEntryList*)next())){ | |
205 | fChain->Add(templist->GetFileName()); | |
206 | } | |
207 | fChain->SetEntryList(elist,"ne"); | |
208 | ||
209 | fChain->SetBranchStatus("*",1); | |
210 | fChain->SetBranchAddress("rawevent",&fEvent,&fBranch); | |
211 | } | |
212 | ||
bb0edcaf | 213 | AliRawReaderChain::AliRawReaderChain(Int_t runNumber) : |
214 | AliRawReaderRoot(), | |
215 | fChain(NULL) | |
216 | { | |
217 | // create raw-reader objects which takes as an input a root chain | |
218 | // with the raw-data files for a given run | |
219 | // It queries alien FC in order to do that and therefore | |
220 | // it needs alien API to be enabled | |
221 | ||
222 | if (runNumber <= 0) { | |
223 | Error("AliRawReaderChain","Bad run number:%d",runNumber); | |
224 | fIsValid = kFALSE; | |
225 | } | |
226 | ||
227 | if (!gGrid) TGrid::Connect("alien://"); | |
228 | if (!gGrid) { | |
229 | fIsValid = kFALSE; | |
230 | return; | |
231 | } | |
232 | ||
233 | TGridResult *res = gGrid->Query("/alice/data",Form("%09d/raw/*%09d*0.root",runNumber,runNumber)); | |
234 | Int_t nFiles = res->GetEntries(); | |
235 | if (!nFiles) { | |
236 | Error("AliRawReaderChain","No raw-data files found for run %d",runNumber); | |
237 | fIsValid = kFALSE; | |
238 | delete res; | |
239 | return; | |
240 | } | |
241 | ||
242 | fChain = new TChain("RAW"); | |
243 | for (Int_t i = 0; i < nFiles; i++) { | |
244 | TString filename = res->GetKey(i, "turl"); | |
245 | if(filename == "") continue; | |
246 | fChain->Add(filename.Data()); | |
247 | } | |
248 | delete res; | |
249 | ||
250 | fChain->SetBranchStatus("*",1); | |
251 | fChain->SetBranchAddress("rawevent",&fEvent,&fBranch); | |
252 | } | |
253 | ||
254 | ||
6923e953 | 255 | AliRawReaderChain::AliRawReaderChain(const AliRawReaderChain& rawReader) : |
256 | AliRawReaderRoot(rawReader), | |
257 | fChain(rawReader.fChain) | |
258 | { | |
259 | // copy constructor | |
260 | } | |
261 | ||
262 | AliRawReaderChain& AliRawReaderChain::operator = (const AliRawReaderChain& | |
263 | rawReader) | |
264 | { | |
265 | // assignment operator | |
266 | ||
267 | this->~AliRawReaderChain(); | |
268 | new(this) AliRawReaderChain(rawReader); | |
269 | return *this; | |
270 | } | |
271 | ||
272 | AliRawReaderChain::~AliRawReaderChain() | |
273 | { | |
274 | // delete objects and close root file | |
275 | ||
276 | if (fChain) { | |
277 | delete fChain; | |
278 | fChain = NULL; | |
279 | } | |
280 | } | |
281 | ||
282 | Bool_t AliRawReaderChain::NextEvent() | |
283 | { | |
284 | // go to the next event in the root file | |
285 | ||
286 | if (!fChain || !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE; | |
287 | ||
288 | do { | |
289 | delete fEvent; | |
33314186 | 290 | fEvent = NULL; |
291 | fEventHeader = NULL; | |
4ebdfbcc | 292 | Long64_t treeEntry = fChain->LoadTree(fEventIndex+1); |
293 | if (!fBranch) | |
636c1780 | 294 | return kFALSE; |
4ebdfbcc | 295 | if (fBranch->GetEntry(treeEntry) <= 0) |
6923e953 | 296 | return kFALSE; |
33314186 | 297 | fEventHeader = fEvent->GetHeader(); |
6923e953 | 298 | fEventIndex++; |
299 | } while (!IsEventSelected()); | |
300 | fEventNumber++; | |
301 | return Reset(); | |
302 | } | |
303 | ||
304 | Bool_t AliRawReaderChain::RewindEvents() | |
305 | { | |
306 | // go back to the beginning of the root file | |
307 | ||
308 | fEventIndex = -1; | |
309 | delete fEvent; | |
33314186 | 310 | fEvent = NULL; |
311 | fEventHeader = NULL; | |
6923e953 | 312 | fEventNumber = -1; |
313 | return Reset(); | |
314 | } | |
636c1780 | 315 | |
316 | Bool_t AliRawReaderChain::GotoEvent(Int_t event) | |
317 | { | |
318 | // go to a particular event | |
319 | // Uses the absolute event index inside the | |
320 | // chain with raw data | |
321 | ||
322 | if (!fChain || !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE; | |
323 | ||
324 | delete fEvent; | |
33314186 | 325 | fEvent = NULL; |
326 | fEventHeader = NULL; | |
4ebdfbcc | 327 | Long64_t treeEntry = fChain->LoadTree(event); |
328 | if (!fBranch) | |
636c1780 | 329 | return kFALSE; |
4ebdfbcc | 330 | if (fBranch->GetEntry(treeEntry) <= 0) |
636c1780 | 331 | return kFALSE; |
33314186 | 332 | fEventHeader = fEvent->GetHeader(); |
636c1780 | 333 | fEventIndex = event; |
334 | fEventNumber++; | |
335 | return Reset(); | |
336 | } | |
25e82ff5 | 337 | |
338 | Int_t AliRawReaderChain::GetNumberOfEvents() const | |
339 | { | |
340 | // Get the total number of events in the chain | |
341 | // of raw-data files | |
342 | ||
343 | if (!fChain) return -1; | |
344 | ||
345 | return fChain->GetEntries(); | |
346 | } |