]>
Commit | Line | Data |
---|---|---|
ffab0c37 | 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 | marian.ivanov@cern.ch | |
18 | ||
19 | //TOOLKIT for chain manipulation: | |
20 | //Example usage: | |
21 | // | |
22 | // 1. Check the list of files | |
23 | AliXRDPROOFtoolkit toolkit; | |
24 | AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0) | |
25 | AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1) | |
26 | // | |
27 | //2. make a chain or random chain form the list of files | |
28 | TChain * chain = toolkit.MakeChain("esd.txt","esdTree",0,10) | |
29 | TChain * chainRandom = toolkit.MakeChainrandom("esd.txt","esdTree",0,10) | |
30 | chain->Draw("fTPCnclsF"); | |
31 | ||
32 | ||
33 | */ | |
34 | #include <TTree.h> | |
35 | #include <TEnv.h> | |
36 | #include <TString.h> | |
37 | #include <TObjArray.h> | |
38 | #include <TObjString.h> | |
39 | #include <TTree.h> | |
40 | #include <TFile.h> | |
41 | #include <TChain.h> | |
42 | #include <TDSet.h> | |
43 | #include <TH1.h> | |
44 | #include <TGraph.h> | |
45 | #include <TMath.h> | |
46 | #include <TPad.h> | |
47 | #include <exception> | |
48 | #include <fstream> | |
49 | #include <TRandom.h> | |
50 | #include <AliXRDPROOFtoolkit.h> | |
51 | ||
52 | ||
53 | ClassImp(AliXRDPROOFtoolkit) | |
54 | ||
55 | ||
56 | ||
57 | //______________________________________________________________________________ | |
58 | AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () : | |
59 | TObject () , | |
60 | fVerbose(kFALSE), // verbso mode - print command | |
61 | fUserName(""), // user name | |
62 | fUserGroup(0) // user group info | |
63 | { | |
64 | // | |
65 | // | |
66 | // | |
67 | fUserGroup = gSystem->GetUserInfo(); | |
68 | fUserName = fUserGroup->fUser; | |
69 | fVerbose=1; | |
70 | } | |
71 | ||
72 | ||
73 | ||
74 | ||
75 | ||
76 | TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles, Int_t startFile) | |
77 | { | |
78 | // | |
79 | // Create the chain | |
80 | // | |
81 | TChain* chain = new TChain(treeName); | |
82 | ||
83 | // Open the input stream | |
84 | ifstream in; | |
85 | in.open(fileIn); | |
86 | ||
87 | // Read the input list of files and add them to the chain | |
88 | TString currentFile; | |
89 | Int_t counter=0; | |
90 | while(in.good()) { | |
91 | in >> currentFile; | |
92 | if (fName) { | |
93 | currentFile+="#"; | |
94 | currentFile+=fName; | |
95 | } | |
96 | if (!currentFile.Contains("root")) continue; // protection | |
97 | counter++; | |
98 | if (counter<startFile) continue; | |
99 | if (counter>maxFiles+startFile) break; | |
0f923679 | 100 | TFile * f = TFile::Open(currentFile.Data()); |
101 | if (f){ | |
102 | chain->Add(currentFile.Data()); | |
103 | } | |
104 | delete f; | |
ffab0c37 | 105 | } |
106 | ||
107 | in.close(); | |
108 | ||
109 | return chain; | |
110 | } | |
111 | ||
112 | TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * treeName,const char *fName, Int_t maxFiles, Int_t startFile) | |
113 | { | |
114 | // | |
115 | // Create a TDSet - files are in random order | |
116 | // | |
117 | // filein - input list text file | |
118 | // treename - containg tree | |
119 | // maxFiles - maximum number of files included | |
120 | ||
121 | TObjArray array(10000); | |
122 | ||
123 | TChain* chain = new TChain(treeName); | |
124 | ||
125 | // Open the input stream | |
126 | ifstream in; | |
127 | in.open(fileIn); | |
128 | ||
129 | // Read the input list of files and add them to the chain | |
130 | TString currentFile; | |
131 | Int_t counter=0; | |
132 | while(in.good()) { | |
133 | in >> currentFile; | |
134 | if (fName) { | |
135 | currentFile+="#"; | |
136 | currentFile+=fName; | |
137 | } | |
138 | if (!currentFile.Contains("root")) continue; // protection | |
139 | counter++; | |
140 | // chain->Add(currentFile.Data()); | |
141 | array.AddLast(new TObjString(currentFile)); | |
142 | } | |
143 | in.close(); | |
144 | Int_t entries = array.GetEntries(); | |
145 | printf("Number of entries\t%d\n",entries); | |
146 | // | |
147 | // | |
148 | // | |
149 | Double_t *randomI = new Double_t[entries]; | |
150 | Int_t *indexes = new Int_t[entries]; | |
151 | for (Int_t i=0;i<entries; i++) randomI[i]=gRandom->Rndm(); | |
152 | TMath::Sort(entries,randomI,indexes); | |
153 | ||
154 | for (Int_t i=startFile; (i<startFile+maxFiles) && (i<entries); i++){ | |
155 | Int_t ifile = indexes[i]; | |
156 | if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){ | |
157 | printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName()); | |
158 | chain->Add(array.At(ifile)->GetName()); | |
159 | array.At(ifile)->SetBit(TObject::kCannotPick); | |
160 | } | |
161 | } | |
162 | return chain; | |
163 | } | |
164 | ||
165 | ||
166 | ||
167 | TDSet* AliXRDPROOFtoolkit::MakeSet(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles) | |
168 | { | |
169 | // | |
170 | // Create the TDSet out of list | |
171 | // filein - input list text file | |
172 | // treename - containg tree | |
173 | // maxFiles - maximum number of files included | |
174 | ||
175 | TDSet* chain = new TDSet(treeName); | |
176 | ||
177 | // Open the input stream | |
178 | ifstream in; | |
179 | in.open(fileIn); | |
180 | ||
181 | // Read the input list of files and add them to the chain | |
182 | TString currentFile; | |
183 | Int_t counter=0; | |
184 | while(in.good()) { | |
185 | in >> currentFile; | |
186 | if (fName) { | |
187 | currentFile+="#"; | |
188 | currentFile+=fName; | |
189 | } | |
190 | if (!currentFile.Contains("root")) continue; // protection | |
191 | counter++; | |
192 | if (maxFiles>0 && counter>maxFiles) break; | |
193 | chain->Add(currentFile.Data()); | |
194 | } | |
195 | ||
196 | in.close(); | |
197 | chain->Validate(); | |
198 | return chain; | |
199 | } | |
200 | ||
201 | ||
202 | TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles) | |
203 | { | |
204 | // | |
205 | // Create a TDSet - files are in random order | |
206 | // | |
207 | // filein - input list text file | |
208 | // treename - containg tree | |
209 | // maxFiles - maximum number of files included | |
210 | ||
211 | TObjArray array(10000); | |
212 | ||
213 | TDSet* chain = new TDSet(treeName); | |
214 | ||
215 | // Open the input stream | |
216 | ifstream in; | |
217 | in.open(fileIn); | |
218 | ||
219 | // Read the input list of files and add them to the chain | |
220 | TString currentFile; | |
221 | Int_t counter=0; | |
222 | while(in.good()) { | |
223 | in >> currentFile; | |
224 | if (fName) { | |
225 | currentFile+="#"; | |
226 | currentFile+=fName; | |
227 | } | |
228 | if (!currentFile.Contains("root")) continue; // protection | |
229 | counter++; | |
230 | // chain->Add(currentFile.Data()); | |
231 | array.AddLast(new TObjString(currentFile)); | |
232 | } | |
233 | in.close(); | |
234 | Int_t entries = array.GetEntries(); | |
235 | printf("Number of entries\t%d",entries); | |
236 | if (maxFiles<0) maxFiles=entries; | |
237 | if (maxFiles>entries) maxFiles=entries; | |
238 | for (Int_t i=0; i<maxFiles; i++){ | |
239 | Int_t ifile = TMath::Nint(gRandom->Rndm()*Float_t(entries)); | |
240 | if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){ | |
241 | printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName()); | |
242 | chain->Add(array.At(ifile)->GetName()); | |
243 | array.At(ifile)->SetBit(TObject::kCannotPick); | |
244 | } | |
245 | } | |
246 | ||
247 | ||
248 | chain->Validate(); | |
249 | return chain; | |
250 | } | |
251 | ||
252 | ||
253 | ||
254 | ||
255 | ||
256 | ||
ffab0c37 | 257 | |
258 | Int_t AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel, const char *branchName){ | |
259 | // | |
260 | // Check the tree in file | |
261 | // fileName - the name of the file with tree | |
262 | // treeName - the name of file | |
263 | // debugLevel - 0 check the existance of the file - 1 make loop over entries | |
264 | // branchName - if debugLevel>0 the branch is chcecked | |
265 | // if brnachName =0 the content of full tree is chcecked | |
266 | // return value = 0 - Check things OK | |
267 | // -1 - file not exist or not accesible | |
268 | // -2 - file is zombie | |
269 | // -3 - tree not present | |
270 | // -4 - branch not present | |
271 | TFile * file = TFile::Open(fileName); | |
272 | if (!file) { return -1;} | |
273 | if (file->IsZombie()) {file->Close(); delete file; return -2;}; | |
274 | ||
275 | TString TrName(treeName); | |
276 | if (TrName=="*") { | |
277 | //cout <<" treename ==== *"<<endl;; | |
278 | file->Close(); delete file; | |
279 | return 0; | |
280 | } | |
281 | TTree * tree = (TTree*)file->Get(treeName); | |
282 | if (!tree) {file->Close(); delete file; return -3;} | |
283 | TBranch * branch = 0; | |
284 | if (branchName) { | |
285 | branch = tree->GetBranch(branchName); | |
286 | if (!branch) {file->Close(); delete file; return -4;} | |
287 | } | |
288 | // | |
289 | if (debugLevel==1 && tree->GetEntries()==0 ) return 1; //empty | |
290 | ||
291 | tree->SetBranchStatus("*",1); | |
292 | try { | |
293 | if (debugLevel>1){ | |
294 | Int_t entries = tree->GetEntries(); | |
295 | for (Int_t i=0;i<entries; i++){ | |
296 | if (branch) branch->GetEntry(i); | |
297 | else tree->GetEntry(); | |
298 | } | |
299 | } | |
300 | }catch ( ... ) { | |
301 | printf("PROBLEM\n"); | |
302 | // never catched - as there is no exception in the ROOT IO | |
303 | file->Close(); delete file; | |
304 | return 1 ; | |
305 | } | |
306 | ||
307 | file->Close(); delete file; | |
308 | return 0; | |
309 | } | |
310 | ||
311 | ||
312 | Bool_t AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList, Int_t checkLevel){ | |
313 | // | |
314 | // Filter the list | |
315 | // inputList - list of original file names | |
316 | // fileList - list of file to be checked | |
317 | // - 0 - fileName | |
318 | // - 1 - treeName (if * not checked) | |
319 | // - 2 - fileName | |
320 | // .... | |
321 | // checkLevel - 0 - check only existance of the files and tree's + | |
322 | // simple file corruption | |
323 | // > 1 - check the content of the tree - | |
324 | // (can crash as there do not exest exception handling in ROOT) | |
325 | // Output - two streams are created - file with good entries | |
326 | // "%s.Good a,d file with bad entries %s.Bad | |
327 | //EXAMPLE: | |
328 | // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1) | |
329 | gEnv->SetValue("TFile.Recover", 0); | |
330 | // | |
331 | fstream finput; | |
332 | finput.open(inputList, ios_base::in); | |
333 | fstream focGood; | |
334 | fstream focBad; | |
335 | focGood.open(Form("%s.Good",inputList), ios_base::out|ios_base::trunc); | |
336 | focBad.open(Form("%s.Bad",inputList), ios_base::out|ios_base::trunc); | |
337 | // | |
338 | if(!finput.is_open()) { | |
339 | cout<<"Can't open file "<<inputList<<endl; | |
340 | return kFALSE; | |
341 | } | |
342 | // | |
343 | // Read the input list of files and add them to the chain | |
344 | // | |
345 | TObjArray *array = (TString(fileList)).Tokenize(" "); | |
346 | TString currentFile; | |
347 | Int_t counter=0; | |
348 | while(finput.good()) { | |
349 | finput >> currentFile; | |
350 | if (!currentFile.Contains("root")) continue; // protection | |
351 | if (currentFile.Contains("alien://")){ | |
352 | focGood<<currentFile<<endl; | |
353 | continue; | |
354 | } | |
355 | Bool_t isZip = currentFile.Contains("#"); | |
356 | const char * dirname = gSystem->DirName(currentFile.Data()); | |
357 | Int_t status = 0; | |
358 | // | |
359 | for (Int_t i=0; i<array->GetEntries(); i+=2){ | |
360 | char fname[1000]; | |
361 | if (!isZip){ | |
472f0066 | 362 | snprintf(fname,1000, "%s/%s",dirname,array->At(i)->GetName()); |
ffab0c37 | 363 | if (((TObjString*)array->At(i))->String().Contains("*")){ |
472f0066 | 364 | snprintf(fname,1000, "%s", currentFile.Data()); |
ffab0c37 | 365 | } |
366 | } | |
367 | if (isZip) { | |
368 | const char * fileName = gSystem->BaseName(currentFile.Data()); | |
369 | TString fstring=fileName; | |
370 | fstring[fstring.First("#")]=0; | |
472f0066 | 371 | snprintf(fname,1000, "%s/%s#%s",dirname,fstring.Data(),array->At(i)->GetName()); |
ffab0c37 | 372 | printf(fname, "To check %s%s#%s\n",dirname,fstring.Data(),array->At(i)->GetName()); |
373 | } | |
374 | ||
375 | printf("\nFile to be checked %s\n",fname); | |
376 | //cout <<"\n arguments: "<< array->At(i+1)->GetName()<<" "<<checkLevel<<endl; | |
377 | Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0); | |
378 | //printf(" CheckTreeInFile returns %d",cstatus); | |
379 | if (cstatus!=0) { | |
380 | status = cstatus; | |
381 | break; | |
382 | } | |
383 | } | |
384 | if (status==0){ | |
385 | focGood<<currentFile<<endl; | |
386 | }else{ | |
387 | focBad<<currentFile<<endl; | |
388 | } | |
389 | counter++; | |
390 | } | |
391 | finput.close(); | |
392 | return kTRUE; | |
393 | } | |
394 | ||
395 | ||
396 | Bool_t AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileList, Int_t checkLevel){ | |
397 | // | |
398 | // Filter the list | |
399 | // inputList - list of original file names | |
400 | // fileList - list of file to be checked | |
401 | // - 0 - fileName | |
402 | // - 1 - treeName (if * not checked) | |
403 | // - 2 - fileName | |
404 | // .... | |
405 | // checkLevel - 0 - check only existance of the files and tree's + | |
406 | // simple file corruption | |
407 | // > 1 - check the content of the tree - | |
408 | // (can crash as there do not exest exception handling in ROOT) | |
409 | // Output - two streams are created - file with good entries | |
410 | // "%s.Good a,d file with bad entries %s.Bad | |
411 | //EXAMPLE: | |
412 | // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1) | |
413 | ||
414 | fstream finput; | |
415 | finput.open(inputList, ios_base::in); | |
416 | fstream focGood; | |
417 | fstream focBad; | |
418 | focGood.open(Form("%s.Good",inputList), ios_base::out|ios_base::trunc); | |
419 | focBad.open(Form("%s.Bad",inputList), ios_base::out|ios_base::trunc); | |
420 | // | |
421 | if(!finput.is_open()) { | |
422 | cout<<"Can't open file "<<inputList<<endl; | |
423 | return kFALSE; | |
424 | } | |
425 | // | |
426 | // Read the input list of files and add them to the chain | |
427 | // | |
428 | TObjArray *array = (TString(fileList)).Tokenize(" "); | |
429 | TString currentFile; | |
430 | Int_t counter=0; | |
431 | while(finput.good()) { | |
432 | finput >> currentFile; | |
433 | if (!currentFile.Contains("root")) continue; // protection | |
434 | if (currentFile.Contains("alien://")){ | |
435 | focGood<<currentFile<<endl; | |
436 | continue; | |
437 | } | |
438 | //Bool_t isZip = currentFile.Contains("#"); | |
439 | const char * dirname = gSystem->DirName(currentFile.Data()); | |
440 | const char * fileName = gSystem->BaseName(currentFile.Data()); | |
441 | TString fstring=fileName; | |
442 | fstring[fstring.First("#")]=0; | |
443 | Int_t status = 0; | |
444 | for (Int_t i=0; i<array->GetEntries(); i+=2){ | |
445 | char fname[1000]; | |
446 | //if (isZip) sprintf(fname, | |
472f0066 | 447 | snprintf(fname,1000, "%s/%s#%s",dirname,fstring.Data(),array->At(i)->GetName()); |
ffab0c37 | 448 | printf(fname, "To check %s%s#%s\n",dirname,fstring.Data(),array->At(i)->GetName()); |
449 | //cout <<"\n arguments: "<< array->At(i+1)->GetName()<<" "<<checkLevel<<endl; | |
450 | Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0); | |
451 | //printf(" CheckTreeInFile returns %d",cstatus); | |
452 | if (cstatus!=0) { | |
453 | status = cstatus; | |
454 | break; | |
455 | } | |
456 | } | |
457 | if (status==0){ | |
458 | focGood<<currentFile<<endl; | |
459 | }else{ | |
460 | focBad<<currentFile<<endl; | |
461 | } | |
462 | counter++; | |
463 | } | |
464 | finput.close(); | |
465 | return kTRUE; | |
466 | } | |
467 | ||
468 | ||
469 | ||
470 | ||
471 | ||
472 | Bool_t AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t /*zip*/){ | |
473 | // | |
474 | // idir - input directory | |
475 | // odir - output directory | |
476 | // files - the list of files to be coppied | |
477 | // zip - not supported yet | |
478 | // | |
479 | // Example : | |
480 | // | |
481 | // idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000"; | |
482 | // odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000"; | |
483 | // char *files="AliESDs.root AliESDfriend.root Kinematics.root"; | |
484 | TString str(files); | |
485 | TObjArray * array = str.Tokenize(" "); | |
486 | Int_t nfiles = array->GetEntries(); | |
487 | char infile[1000]; | |
488 | char outfile[1000]; | |
489 | Bool_t succes=kTRUE; | |
490 | for (Int_t ifile =0; ifile<nfiles; ifile++){ | |
472f0066 | 491 | snprintf(infile,1000,"%s/%s", idir, array->At(ifile)->GetName()); |
492 | snprintf(outfile,1000,"%s/%s", odir, array->At(ifile)->GetName()); | |
ffab0c37 | 493 | printf("%s - %s\n",infile, outfile); |
494 | Bool_t result = TFile::Cp(infile,outfile); | |
495 | succes &= result; | |
496 | } | |
497 | return succes; | |
498 | } | |
499 | ||
500 | ||
501 | ||
502 |