TPC/macros/AliXRDPROOFtoolkit.cxx

   1 /*
   2   TTOOLKIT to acces files on XRD
   3   WORKING ONLY AT GSI
   4 //
   5
   6   Example usage:
   7   Load toolkit
   8   gSystem->AddIncludePath("-I$ALICE_ROOT/TPC/macros")
   9   gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+")
  10
  11   1.
  12   Retrieve the list of files : POSSIBLE ONLY FOR USER WITH LOGIN ACCESS TO THE XRD MACHINES
  13
  14   AliXRDPROOFtoolkit tool;
  15   tool.ListOfFiles("all.txt","/data.local2/sma/sim/v4-06-Rev-03/pp*", "AliESDs.root", kFALSE);
  16   tool.ListOfFiles("pp.txt","/data.local2/sma/sim/v4-06-Rev-03/pp", "AliESDs.root", kFALSE);
  17
  18   tool.ListOfFiles("pp64.txt","/data.local2/sma/sim/v4-06-Rev-03/pp64", "AliESDs.root", kFALSE);
  19   tool.ListOfFiles("pp64m.txt","/data.local2/sma/sim/v4-06-Rev-03/pp64", "AliESDs.root", kTRUE);
  20
  21   // check the list
  22   AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0)
  23   AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
  24
  25   2.
  26
  27   AliXRDPROOFtoolkit tool;
  28   TChain * chain = tool.MakeChain("pp.txt","esdTree",0,10)
  29   chain->Draw("fTPCnclsF");
  30
  31
  32   3. Process logs - ONLY priority users - with ssh acces
  33   AliXRDPROOFtoolkit tool;
  34   tool.FilterSegFault();
  35   TTree * treeSys  = tool.DumpSys(kTRUE)
  36
  37 */
  38
  39
  40 #include <TTree.h>
  41 #include <TString.h>
  42 #include <TObjArray.h>
  43 #include <TObjString.h>
  44 #include <TTree.h>
  45 #include <TFile.h>
  46 #include <TChain.h>
  47 #include <TDSet.h>
  48 #include <TH1.h>
  49 #include <TGraph.h>
  50 #include <TMath.h>
  51 #include <TPad.h>
  52 #include <exception>
  53 #include <fstream>
  54 #include <TRandom.h>
  55
  56
  57 #include <AliXRDPROOFtoolkit.h>
  58
  59
  60 ClassImp(AliXRDPROOFtoolkit);
  61
  62
  63
  64 //______________________________________________________________________________
  65 AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () : TObject ()
  66 {
  67   //
  68   // Default  -GSI specific setup
  69   //
  70   for(Int_t i=255;i<269;i++)
  71   //for(Int_t i=259;i<260;i++)
  72     listeMachine.push_back(new TString(Form("lxb%d.gsi.de", i)));
  73   fUserGroup = gSystem->GetUserInfo();
  74   fUserName = fUserGroup->fUser;
  75   fVerbose=1;
  76 }
  77
  78 void AliXRDPROOFtoolkit::Print(Option_t* /*option*/) const{
  79   //
  80   // Print current setup of toolkit
  81   //
  82   printf("User name\t%s\n", fUserName.Data());
  83   printf("List of slaves\n");
  84
  85   for(UInt_t i=0;i<listeMachine.size();i++)
  86     printf("%s\n",listeMachine[i]->Data());
  87 }
  88
  89
  90 //______________________________________________________________________________
  91 void AliXRDPROOFtoolkit::AddMachine (const char*name)
  92 {
  93   //
  94   // add computer to the list
  95   //
  96   listeMachine.push_back( new TString(name));
  97 }
  98
  99
 100 //______________________________________________________________________________
 101 Bool_t AliXRDPROOFtoolkit::ListOfFiles(const char*fileName, const char*path, const char*filter, Bool_t displayMachine)
 102 {
 103   //
 104   // Get the list of files on "registerd slaves"
 105   //
 106   // fileName - Resultinfg file with list
 107   // path     - starting path on slave e.g /data.local2/sma/
 108   // filter   - filter expression e.g. AliESDs.root
 109   // display machine - not used yet
 110
 111   char filterXRD[100];
 112   char command[1000];
 113   //
 114   // FILTER expression - to get REDIRECTOR NAME
 115   //
 116   //what we want for sed
 117   //  sprintf(filterXRD,"sed s/\\/data.local2/root:\\/\\/gsiaf.gsi.de:1094\\//");
 118   //what we should write
 119   sprintf(filterXRD,"sed s/\\\\/data.local2/root:\\\\/\\\\/gsiaf.gsi.de:1094\\\\//");
 120   //
 121   //
 122   //
 123   gSystem->Exec(Form("echo  >%s",fileName));
 124   for(UInt_t i=0; i<listeMachine.size(); i++){
 125     if (displayMachine){
 126       sprintf(filterXRD,"sed s/\\\\/data.local2/root:\\\\/\\\\/%s:1094\\\\//",listeMachine[i]->Data());
 127     }
 128     cout<<"Inspecting "<<listeMachine[i]->Data()<<" ..."<<endl;
 129     sprintf(command,"lsrun -m %s   find %s | grep %s | %s >> %s", listeMachine[i]->Data(), path, filter, filterXRD,fileName);
 130     printf(command);
 131     gSystem->Exec(command);
 132   }
 133   return kTRUE;
 134 }
 135
 136
 137 TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles, Int_t startFile)
 138 {
 139   //
 140   // Create the chain
 141   //
 142   TChain* chain = new TChain(treeName);
 143
 144   // Open the input stream
 145   ifstream in;
 146   in.open(fileIn);
 147
 148   // Read the input list of files and add them to the chain
 149   TString currentFile;
 150   Int_t counter=0;
 151   while(in.good()) {
 152     in >> currentFile;
 153     if (fName) {
 154       currentFile+="#";
 155       currentFile+=fName;
 156     }
 157     if (!currentFile.Contains("root")) continue; // protection
 158     counter++;
 159     if (counter<startFile) continue;
 160     if (counter>maxFiles+startFile) break;
 161     chain->Add(currentFile.Data());
 162   }
 163
 164   in.close();
 165
 166   return chain;
 167 }
 168
 169 TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * treeName,const char *fName, Int_t maxFiles, Int_t startFile)
 170 {
 171   //
 172   // Create a TDSet - files are in random order
 173   //
 174   // filein    - input list text file
 175   // treename  - containg tree
 176   // maxFiles  - maximum number of files included
 177
 178   TObjArray array(10000);
 179
 180   TChain* chain = new TChain(treeName);
 181
 182   // Open the input stream
 183   ifstream in;
 184   in.open(fileIn);
 185
 186   // Read the input list of files and add them to the chain
 187   TString currentFile;
 188   Int_t counter=0;
 189   while(in.good()) {
 190     in >> currentFile;
 191     if (fName) {
 192       currentFile+="#";
 193       currentFile+=fName;
 194     }
 195     if (!currentFile.Contains("root")) continue; // protection
 196     counter++;
 197     //    chain->Add(currentFile.Data());
 198     array.AddLast(new TObjString(currentFile));
 199   }
 200   in.close();
 201   Int_t entries = array.GetEntries();
 202   printf("Number of entries\t%d",entries);
 203   if (maxFiles<0) maxFiles=entries;
 204   if (maxFiles>entries) maxFiles=entries;
 205   //
 206   //
 207   //
 208   for (Int_t i=0; i<maxFiles; i++){
 209     Int_t ifile = TMath::Nint(gRandom->Rndm()*Float_t(entries));
 210     if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
 211       printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
 212       chain->Add(array.At(ifile)->GetName());
 213       array.At(ifile)->SetBit(TObject::kCannotPick);
 214     }
 215   }
 216   return chain;
 217 }
 218
 219
 220
 221 TDSet* AliXRDPROOFtoolkit::MakeSet(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
 222 {
 223   //
 224   // Create the TDSet out of list
 225   // filein    - input list text file
 226   // treename  - containg tree
 227   // maxFiles  - maximum number of files included
 228
 229   TDSet* chain = new TDSet(treeName);
 230
 231   // Open the input stream
 232   ifstream in;
 233   in.open(fileIn);
 234
 235   // Read the input list of files and add them to the chain
 236   TString currentFile;
 237   Int_t counter=0;
 238   while(in.good()) {
 239     in >> currentFile;
 240     if (fName) {
 241       currentFile+="#";
 242       currentFile+=fName;
 243     }
 244     if (!currentFile.Contains("root")) continue; // protection
 245     counter++;
 246     if (maxFiles>0 && counter>maxFiles) break;
 247     chain->Add(currentFile.Data());
 248   }
 249
 250   in.close();
 251   chain->Validate();
 252   return chain;
 253 }
 254
 255
 256 TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
 257 {
 258   //
 259   // Create a TDSet - files are in random order
 260   //
 261   // filein    - input list text file
 262   // treename  - containg tree
 263   // maxFiles  - maximum number of files included
 264
 265   TObjArray array(10000);
 266
 267   TDSet* chain = new TDSet(treeName);
 268
 269   // Open the input stream
 270   ifstream in;
 271   in.open(fileIn);
 272
 273   // Read the input list of files and add them to the chain
 274   TString currentFile;
 275   Int_t counter=0;
 276   while(in.good()) {
 277     in >> currentFile;
 278     if (fName) {
 279       currentFile+="#";
 280       currentFile+=fName;
 281     }
 282     if (!currentFile.Contains("root")) continue; // protection
 283     counter++;
 284     //    chain->Add(currentFile.Data());
 285     array.AddLast(new TObjString(currentFile));
 286   }
 287   in.close();
 288   Int_t entries = array.GetEntries();
 289   printf("Number of entries\t%d",entries);
 290   if (maxFiles<0) maxFiles=entries;
 291   if (maxFiles>entries) maxFiles=entries;
 292   for (Int_t i=0; i<maxFiles; i++){
 293     Int_t ifile = TMath::Nint(gRandom->Rndm()*Float_t(entries));
 294     if (ifile<entries && (array.At(ifile)) &&  array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
 295       printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
 296       chain->Add(array.At(ifile)->GetName());
 297       array.At(ifile)->SetBit(TObject::kCannotPick);
 298     }
 299   }
 300
 301
 302   chain->Validate();
 303   return chain;
 304 }
 305
 306 //_______________________________________________________________________________
 307
 308
 309 void   AliXRDPROOFtoolkit::FilterSegFault(const char *filter){
 310   //
 311   // Print the list of slaves finished with seg fault
 312   //
 313   printf("List of the PROOF slaves  with seg fault (Last session) \n");
 314   for(UInt_t i=0; i<listeMachine.size(); i++){
 315     if (HasSegFault(listeMachine[i]->Data(), filter)){
 316       printf("%s\n",listeMachine[i]->Data());
 317     }
 318   }
 319 }
 320
 321 //_______________________________________________________________________________
 322
 323 Bool_t    AliXRDPROOFtoolkit::HasSegFault(const char * machine, const char *filter){
 324   //
 325   // check if segmentation fault on the node
 326   //
 327   char command0[1000];
 328   char command[1000];
 329   char *path  =  "segfault.log";
 330   Long_t id,size,flags,modtime;
 331
 332   // first check if we have a log file
 333   sprintf(command0, Form("lsrun -m %s find /data.local2/proof/%s/  | grep %s | grep .log >filelist.list", machine,fUserName.Data(), filter));
 334   if (fVerbose>1) {
 335     printf("%s\n",command0);
 336   }
 337   gSystem->Exec(command0);
 338   gSystem->GetPathInfo("filelist.list", &id, &size, &flags, &modtime);
 339   if (size<1) return kFALSE;
 340
 341   //
 342   // now check the content
 343   //
 344   sprintf(command, Form("lsrun -m %s  cat `lsrun -m %s find /data.local2/proof/%s/  | grep %s|grep log ` | grep segmentation  >segfault.log", machine, machine,fUserName.Data(), filter));
 345
 346   if (fVerbose) {
 347     printf("%s\n",command);
 348   }
 349   if (fVerbose>1) gSystem->Exec(command);
 350   gSystem->GetPathInfo(path, &id, &size, &flags, &modtime);
 351   return (size>10);
 352 }
 353
 354
 355 //--------------------------------------------------------------------
 356
 357 TTree *    AliXRDPROOFtoolkit::DumpSys(Bool_t verbose){
 358   //
 359   // Dump memory usage on worker nodes
 360   gSystem->Exec("echo > syswatch.log");
 361   for(UInt_t i=0; i<listeMachine.size(); i++){
 362     if (verbose) gSystem->Exec(Form("ssh %s cat /data.local2/proof/miranov/last-worker*/syswatch.log ",listeMachine[i]->Data()));
 363     gSystem->Exec(Form("ssh %s cat /data.local2/proof/miranov/last-worker*/syswatch.log >> syswatch.log",listeMachine[i]->Data()));
 364   }
 365
 366   TTree * tree = new TTree("asci","asci");
 367   tree->SetDirectory(0);
 368   //  tree->ReadFile("syswatch.log","hname/C:fname/C:entry/I:time/I:mem0/F:mem1/F:mem2/F:mem3/F");
 369   tree->ReadFile("syswatch.log","hname/C:fname/C:entry/I:time/I:mem0/F:mem1/F:mem2/F:mem3/F:cpu0/F:cpu1/F:cpu2/F:cpu3/F");
 370   return tree;
 371 }
 372
 373 // //--------------------------------------------------------------------
 374
 375 TTree * AliXRDPROOFtoolkit::DumpSys2(Bool_t verbose){
 376   //
 377   // Dump memory usage on worker nodes
 378   //
 379   gSystem->Exec("echo > syswatch.log");
 380   for(UInt_t i=0; i<listeMachine.size(); i++){
 381     if (verbose)
 382       gSystem->Exec(Form("lsrun -m %s cat /data.local2/proof/miranov/last-worker*/syswatch.log ",listeMachine[i]->Data()));
 383     gSystem->Exec(Form("lsrun -m  %s cat /data.local2/proof/miranov/last-workersession/syswatch.log >> syswatch.log",listeMachine[i]->Data()));
 384   }
 385
 386   TTree * tree = new TTree("asci","asci");
 387   tree->SetDirectory(0);
 388   //  tree->ReadFile("syswatch.log","hname/C:fname/C:entry/I:time/I:mem0/F:mem1/F:mem2/F:mem3/F");
 389   tree->ReadFile("syswatch.log","hname/C:fname/C:entry/I:time/I:mem0/F:mem1/F:mem2/F:mem3/F:cpu0/F:cpu1/F:cpu2/F:cpu3/F");
 390   return tree;
 391 }
 392
 393
 394
 395
 396 //
 397
 398
 399 TTree*    AliXRDPROOFtoolkit::DumpFiles(Bool_t verbose){
 400   //
 401   //
 402   //
 403   gSystem->Exec("touch filewatch.log");
 404   for(UInt_t i=0; i<listeMachine.size(); i++){
 405     if (verbose) gSystem->Exec(Form("ssh %s cat /data.local2/proof/miranov/last-worker*/worker*/filewatch.log >>filewatch.log",listeMachine[i]->Data()));
 406     gSystem->Exec(Form("ssh %s cat /data.local2/proof/miranov/last-worker*/worker*/filewatch.log >>filewatch.log",listeMachine[i]->Data()));
 407   }
 408  TTree * tree = new TTree("asci","asci");
 409  tree->SetDirectory(0);
 410  tree->ReadFile("filewatch.log","hname/C:fname/C:entry/I:status/I");
 411  return tree;
 412 }
 413
 414
 415
 416
 417
 418
 419 //______________________________________________________________________________
 420 void AliXRDPROOFtoolkit::CheckFiles (const char*fileIn, UInt_t checkLevel, const char*treeToRetrieve, const char*varexp, const char*selection)
 421 {
 422   //
 423   // check the files
 424   //
 425   fstream fic;
 426   fic.open(fileIn, ios_base::in);
 427   fstream focGood;
 428   fstream focBad;
 429   focGood.open(Form("%s.Good",fileIn), ios_base::out|ios_base::trunc);
 430   focBad.open(Form("%s.Bad",fileIn), ios_base::out|ios_base::trunc);
 431   //
 432   if(!fic.is_open()) {
 433     cout<<"Can't open file "<<fileIn<<endl;
 434     return;
 435   }
 436   //
 437   //
 438   //
 439   Long64_t size;
 440   char buffer[256];
 441   char * line;
 442   char * machine;
 443   Int_t level=0;
 444   Float_t compressionFactor;
 445   Int_t nkey;
 446   Int_t version;
 447   TObjString * fileName=0x0;
 448   TObjString * machineName=0x0;
 449   //  TChain chain ("check_chain");
 450
 451   TFile fout(Form("%s.root",fileIn),"recreate");
 452   TTree * tree=new TTree("stats", "stats of AliXRDPROOFtoolkit::CheckFiles function");
 453
 454   tree->Branch ("machine", "TObjString", &machineName, 256000,0);
 455   tree->Branch ("file", "TObjString", &fileName, 256000,0);
 456   tree->Branch ("level", &level, "level/I");
 457   tree->Branch ("size", &size, "size/L");
 458   tree->Branch ("nkey", &nkey, "nkey/I");
 459   tree->Branch ("compress", &compressionFactor, "compress/F");
 460   tree->Branch ("version", &version, "version/I");
 461
 462   // start loop over the files
 463   fic.getline(buffer, sizeof(buffer));
 464   while (fic.good()){
 465
 466     // get the machine name if present in the file
 467     machine=strchr(buffer, '\t');
 468     if(machine!=0x0){
 469       machine[0]='\0';
 470       line=machine+1;
 471       machine=buffer;
 472       machineName=new TObjString(machine);
 473     }else {
 474       machineName=new TObjString("x");
 475       line=buffer;
 476     }
 477     cout<<"Inspecting file :"<<line<<endl;
 478
 479
 480     TTree * getTree=0x0;
 481     fileName=new TObjString(line);
 482
 483     TFile * f=TFile::Open(line);
 484     //    chain.AddFile(line);
 485     level=0;
 486     size=-1;
 487     nkey=-1;
 488     compressionFactor=-1;
 489     version=-1;
 490
 491     if (fileName->String().Contains("AliESDs.root")){
 492       //
 493       // check  friend file
 494       //
 495       char  fnameFriend[1000];
 496       sprintf(fnameFriend,"%s/AliESDfriends.root",gSystem->DirName(fileName->String().Data()));
 497       cout<<"Inspecting file :"<<fnameFriend<<endl;
 498       TFile * ffriend=TFile::Open(fnameFriend);
 499       if (!ffriend) level=-4;
 500       else{
 501         if (ffriend->IsZombie()) level=-3;
 502         if (ffriend->TestBit(TFile::kRecovered) || ffriend->TestBit(TFile::kWriteError)){
 503           level=-2;
 504         }
 505         ffriend->Close();
 506         delete ffriend;
 507       }
 508     }
 509
 510
 511     if(level>=-1 && f!=0x0){
 512       level=1;
 513       size=f->GetSize();
 514       nkey=f->GetNkeys();
 515       compressionFactor=f->GetCompressionFactor();
 516       version=f->GetVersion();
 517
 518       if(checkLevel>0 && !f->IsZombie()){
 519         level=2;
 520         if(checkLevel>1 && treeToRetrieve!="" && (getTree=(TTree*)f->Get(treeToRetrieve))!=0x0){
 521           level=3;
 522           Int_t tentries = getTree->GetEntries();
 523           if (tentries>=0) level=4;
 524           cout<<"Number of entries :"<<getTree->GetEntries()<<endl;
 525
 526           if(checkLevel>3 && varexp!="" &&tentries>0) {
 527             getTree->SetBranchStatus("*",1);
 528             try{
 529               TH1F his("his","his",100,-1,1);
 530               Int_t selected = getTree->Draw(Form("%s>>his",varexp), selection, "goff", 1, tentries-1);
 531               cout<<"Selected\t"<<selected<<endl;
 532               if(selected>-1){
 533                 level=5;
 534
 535                 //try to remove the created histogrames ...
 536 //              TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp"); // 1D
 537 //              TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph"); // 2D
 538 //              if(htemp!=0x0) {cout<<"removing TH1D"<<endl; delete htemp;}
 539 //              else if(graph!=0x0) {cout<<"removing TGraph"<<endl; delete graph;}
 540 //              else cout<<"nothing to remove : memory leak ..."<<endl;
 541
 542               }
 543             }catch(std::bad_alloc){
 544               cout<<"Warning : Draw option send std::badalloc"<<endl;
 545             }
 546           }
 547           delete getTree;
 548         }
 549       }
 550       f->Close();
 551       delete f;
 552     }
 553     if (level>checkLevel){
 554       focGood<<line<<endl;
 555     }
 556     else{
 557       focBad<<line<<"\t"<<level<<endl;
 558     }
 559
 560
 561     tree->Fill();
 562     fic.getline(buffer, sizeof(buffer));
 563   }
 564
 565   //now use chain to check
 566   //chain.Lookup(kTRUE);
 567
 568
 569   // Save the tree
 570   tree->Write();
 571   fout.Close();
 572   focGood.close();
 573   focBad.close();
 574
 575 }
 576
 577 Int_t  AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel, const char *branchName){
 578   //
 579   // Check the tree in file
 580   // fileName   - the name of the file with tree
 581   // treeName   - the name of file
 582   // debugLevel - 0 check the existance of the file -  1 make loop over entries
 583   // branchName - if debugLevel>0 the branch is chcecked
 584   //              if brnachName =0 the content of full tree is chcecked
 585   // return value = 0 - Check things  OK
 586   //               -1 - file not exist or not accesible
 587   //               -2 - file is zombie
 588   //               -3 - tree not present
 589   //               -4 - branch not present
 590   TFile * file = TFile::Open(fileName);
 591   if (!file) { return -1;}
 592   if (file->IsZombie()) {file->Close(); delete file; return -2;};
 593
 594   TString TrName(treeName);
 595   if (TrName=="*") {
 596     //cout <<"        treename ==== *"<<endl;;
 597     file->Close(); delete file;
 598     return 0;
 599   }
 600   TTree * tree = (TTree*)file->Get(treeName);
 601   if (!tree) {file->Close(); delete file; return -3;}
 602   TBranch * branch = 0;
 603   if (branchName) {
 604     branch = tree->GetBranch(branchName);
 605     if (!branch) {file->Close(); delete file; return -4;}
 606   }
 607   //
 608   tree->SetBranchStatus("*",1);
 609   try {
 610     if (debugLevel>0){
 611       Int_t entries = tree->GetEntries();
 612       for (Int_t i=0;i<entries; i++){
 613         if (branch) branch->GetEntry(i);
 614         else tree->GetEntry();
 615       }
 616     }
 617   }catch ( ... ) {
 618     printf("PROBLEM\n");
 619     // never catched  - as there is no exception in the ROOT IO
 620     file->Close(); delete file;
 621     return 1 ;
 622   }
 623
 624   file->Close(); delete file;
 625   return 0;
 626 }
 627
 628
 629 Bool_t  AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList, Int_t checkLevel){
 630   //
 631   // Filter the list
 632   // inputList - list of original file names
 633   // fileList  - list of file to be checked
 634   //           - 0 - fileName
 635   //           - 1 - treeName (if * not checked)
 636   //           - 2 - fileName
 637   //                 ....
 638   // checkLevel - 0 - check only existance of the files and tree's +
 639   //                  simple file corruption
 640   //            > 1 - check the content of the tree -
 641   //                  (can crash as there do not exest exception handling in ROOT)
 642   // Output -  two streams are created - file with good entries
 643   // "%s.Good a,d file with bad entries %s.Bad
 644   //EXAMPLE:
 645   // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
 646
 647   fstream finput;
 648   finput.open(inputList, ios_base::in);
 649   fstream focGood;
 650   fstream focBad;
 651   focGood.open(Form("%s.Good",inputList), ios_base::out|ios_base::trunc);
 652   focBad.open(Form("%s.Bad",inputList), ios_base::out|ios_base::trunc);
 653   //
 654   if(!finput.is_open()) {
 655     cout<<"Can't open file "<<inputList<<endl;
 656     return kFALSE;
 657   }
 658   //
 659   // Read the input list of files and add them to the chain
 660   //
 661   TObjArray *array = (TString(fileList)).Tokenize(" ");
 662   TString currentFile;
 663   Int_t counter=0;
 664   while(finput.good()) {
 665     finput >> currentFile;
 666     if (!currentFile.Contains("root")) continue; // protection
 667     //    Bool_t isZip = currentFile.Contains("#");
 668     const char * dirname = gSystem->DirName(currentFile.Data());
 669     Int_t status = 0;
 670     for (Int_t i=0; i<array->GetEntries(); i+=2){
 671       char fname[1000];
 672       //if (isZip) sprintf(fname,
 673       sprintf(fname, "%s/%s",dirname,array->At(i)->GetName());
 674       printf("\nFile to be checked %s/%s",dirname,array->At(i)->GetName());
 675       //cout <<"\n arguments: "<< array->At(i+1)->GetName()<<" "<<checkLevel<<endl;
 676       Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0);
 677       //printf("  CheckTreeInFile returns %d",cstatus);
 678       if (cstatus!=0) {
 679         status = cstatus;
 680         break;
 681       }
 682     }
 683     if (status==0){
 684       focGood<<currentFile<<endl;
 685     }else{
 686       focBad<<currentFile<<endl;
 687     }
 688     counter++;
 689   }
 690   finput.close();
 691 }
 692
 693
 694
 695
 696
 697 Bool_t  AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t zip){
 698   //
 699   // idir  - input directory
 700   // odir  - output directory
 701   // files - the list of files to be coppied
 702   // zip   - not supported yet
 703   //
 704   // Example :
 705   //
 706   // idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000";
 707   // odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000";
 708   // char *files="AliESDs.root AliESDfriend.root Kinematics.root";
 709   TString str(files);
 710   TObjArray * array = str.Tokenize(" ");
 711   Int_t nfiles = array->GetEntries();
 712   char infile[1000];
 713   char outfile[1000];
 714   Bool_t succes=kTRUE;
 715   for (Int_t ifile =0; ifile<nfiles; ifile++){
 716     sprintf(infile,"%s/%s", idir, array->At(ifile)->GetName());
 717     sprintf(outfile,"%s/%s", odir, array->At(ifile)->GetName());
 718     printf("%s - %s\n",infile, outfile);
 719     Bool_t result = TFile::Cp(infile,outfile);
 720     succes &= result;
 721   }
 722   return succes;
 723 }
 724
 725
 726
 727