ANALYSIS/AliAnalysisGoodies.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 // Various utilities usefull for analysis
  17 //
  18 //*-- Yves Schutz
  19 //////////////////////////////////////////////////////////////////////////////
  20
  21 #include "AliAnalysisDataContainer.h"
  22 #include "AliTagAnalysis.h"
  23 #include "AliEventTagCuts.h"
  24 #include "AliRunTagCuts.h"
  25 #include "AliXMLCollection.h"
  26 #include "AliAnalysisGoodies.h"
  27 #include "AliAnalysisManager.h"
  28 #include "AliAnalysisTask.h"
  29   //#include "AliPhotonAnalysisTask.h"
  30 #include "AliLog.h"
  31
  32 #include <Riostream.h>
  33 #ifdef WITHALIEN
  34 #include <TAlienCollection.h>
  35 #include <TGridResult.h>
  36 #include <TFileMerger.h>
  37 #endif
  38 #include <TChain.h>
  39 #include <TGrid.h>
  40 #include <TROOT.h>
  41 #include <TSystem.h>
  42 #include <TEntryList.h>
  43
  44 //______________________________________________________________________________
  45 AliAnalysisGoodies::AliAnalysisGoodies() :
  46   fESDTreeName("esdTree"),
  47   fnumberOfTasks(0),
  48   fTaskList(0),
  49   fTaskInType(0),
  50   fTaskOuType(0)
  51 {
  52   fTimer.Reset() ;
  53
  54   TString token = gSystem->Getenv("GRID_TOKEN") ;
  55
  56   if ( token == "OK" )
  57     TGrid::Connect("alien://");
  58   else
  59     AliInfo("You are not connected to the GRID") ;
  60 }
  61
  62 //______________________________________________________________________________
  63 void AliAnalysisGoodies::Help() const
  64 {
  65   AliInfo("Analysis utilities:\n") ;
  66   printf("                ***  Alien2Local  : copy files ESD files listed in an xml collection from AliEn catalog to local storage and creates a local xml collection  \n") ;
  67   printf("                                        usage: Alien2Local(in, out)\n") ;
  68   printf("                                                in: a xml esd collection file name    \n") ;
  69   printf("                                                ou: the local directory where to save the esd root files   \n") ;
  70   printf("                ***  Make  : makes esd collection from tags  \n") ;
  71   printf("                                        usage: Make(tags, esds)\n") ;
  72   printf("                                                tags: is either a tag root file or an xml tag collection   \n") ;
  73   printf("                                                esds: is an esd collection     \n") ;
  74   printf("                ***  Merge  : merges files listed in a xml collection \n") ;
  75   printf("                                        usage Merge(collection, outputDile)\n") ;
  76   printf("                                               collection: is a xml collection \n") ;
  77   printf("                ***  Process : process the events with an Analysis Task \n") ;
  78   printf("                                        usage: Process(esdFile, tagCuts) \n") ;
  79   printf("                                                esdFile: can be a root file with the ESD Tree ( ex: esd?AliESDs.root) \n") ;
  80   printf("                                                        or a root file with the Tag Tree ( ex: tag?Run100.Event0_100.ESD.tag.root) \n") ;
  81   printf("                                                        or a local or alien xml file with the ESD collection ( ex: esd?esdCollection.xml) \n") ;
  82   printf("                                                        or a local or alien xml file with the TAG collection ( ex: tag?tagCollection.xml) \n") ;
  83   printf("                                                        or a TChain of esd TTrees \n") ;
  84   printf("                                               tagCuts: is the AliEventTagCuts (needed only for tag? cases \n") ;
  85   printf("                ***  Register: register files already stored in a MSS into the AliEn catalog\n") ;
  86   printf("                                        usage: Register(lfndir, pfndir, pfnFileName) \n") ;
  87   printf("                                                lfndir : AliEn directory ( ex:  /alice/data/2006/LHC06c/PHOS_TestBeam/\n") ;
  88   printf("                                                pfndir : MSS directory   ( ex: /castor/cern.ch/alice/testbeam/phos/2006 \n") ;
  89   printf("                                                file   : text file with a list of the file names to be registered\n ") ;
  90
  91 }
  92
  93 //______________________________________________________________________
  94 Bool_t AliAnalysisGoodies::Alien2Local(const TString collectionNameIn, const TString localDir)
  95 {
  96   // copy files ESD files listed in an xml collection from AliEn catalog to local storage and creates a local xml collection
  97   // usage: Alien2Local(in, out)
  98   //        in: a xml esd collection file name
  99   //        ou: the local directory where to save the esd root files
 100
 101 #ifdef WITHALIEN
 102   Bool_t rv = kTRUE ;
 103
 104   fTimer.Start() ;
 105
 106   AliXMLCollection * collectionIn = AliXMLCollection::Open(collectionNameIn) ;
 107   collectionIn->Reset() ;
 108
 109   AliXMLCollection * collectionOu = new AliXMLCollection() ;
 110   TString collectionNameOu(collectionIn->GetCollectionName()) ;
 111   collectionNameOu.Append("Local") ;
 112   collectionOu->SetCollectionName(collectionNameOu) ;
 113   collectionOu->WriteHeader() ;
 114
 115   TFileMerger merger ;
 116
 117   const char* ocwd = gSystem->WorkingDirectory();
 118
 119   Int_t counter = 1 ;
 120   while ( collectionIn->Next() ) {
 121     gSystem->ChangeDirectory(localDir) ;
 122     TString fileTURL = collectionIn->GetTURL("") ;
 123
 124     TString tempo(fileTURL) ;
 125     tempo.Remove(tempo.Last('/'), tempo.Length()) ;
 126     TString evtsNumber = tempo(tempo.Last('/')+1, tempo.Length())+"/";
 127     tempo.Remove(tempo.Last('/'), tempo.Length()) ;
 128     TString runNumber = tempo(tempo.Last('/')+1, tempo.Length())+"/" ;
 129     TString dir = localDir + runNumber ;
 130     dir += evtsNumber ;
 131     char line[1024] ;
 132     sprintf(line, ".! mkdir -p %s", dir.Data()) ;
 133     gROOT->ProcessLine(line) ;
 134     printf("***************************%s\n", line) ;
 135     TEntryList * list = collectionIn->GetEventList("") ;
 136     if (!list)
 137      list = new TEntryList() ;
 138     tempo = fileTURL ;
 139     TString filename = tempo(tempo.Last('/')+1, tempo.Length()) ;
 140     dir += filename ;
 141     AliInfo(Form("Copying %s to %s\n", fileTURL.Data(), dir.Data())) ;
 142     collectionOu->WriteBody(counter, collectionIn->GetGUID(""), collectionIn->GetLFN(""), dir, list) ;
 143     counter++ ;
 144     merger.Cp(fileTURL, dir) ;
 145   }
 146   collectionOu->Export() ;
 147   gSystem->ChangeDirectory(ocwd) ;
 148
 149   fTimer.Stop();
 150   fTimer.Print();
 151
 152   return rv ;
 153 #else
 154   return kFALSE;
 155 #endif
 156 }
 157
 158 //______________________________________________________________________
 159 Bool_t AliAnalysisGoodies::Make(AliRunTagCuts *runCuts, AliEventTagCuts *evtCuts, const char * in, const char * out) const
 160 {
 161   // makes esd collection from tags
 162   // usage Make(tags, esds)
 163   //              tags: is either a tag root file or an xml tag collection
 164   //              esds: is an esd collection
 165
 166   Bool_t rv = kTRUE ;
 167
 168   if ( !evtCuts && !runCuts ) {
 169     AliError("No Tag cuts provided") ;
 170     return kFALSE ;
 171   }
 172
 173   TString file(in) ;
 174   if ( file.Contains(".root") )
 175     rv = MakeEsdCollectionFromTagFile(runCuts, evtCuts, file.Data(), out) ;
 176   else  if ( file.Contains(".xml") )
 177     rv = MakeEsdCollectionFromTagCollection(runCuts, evtCuts, file.Data(), out) ;
 178   else {
 179     AliError(Form("%s is not a valid file format", in)) ;
 180     rv = kFALSE ;
 181   }
 182
 183   return rv ;
 184 }
 185
 186 //______________________________________________________________________
 187 Bool_t AliAnalysisGoodies::MakeEsdCollectionFromTagFile(AliRunTagCuts *runCuts, AliEventTagCuts *evtCuts, const char * in, const char * out) const
 188 {
 189   // Makes an esd collection from a root tag file
 190   Bool_t rv = kTRUE ;
 191     // Open the file collection
 192   printf("*** Create Collection       ***\n");
 193   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 194   printf("***  file   = |%s|             \n",in);
 195
 196   AliTagAnalysis * tagAna = new AliTagAnalysis();
 197   rv = tagAna->AddTagsFile(in);
 198   if ( ! rv )
 199     return rv ;
 200
 201   tagAna->CreateXMLCollection(out, runCuts, evtCuts) ;
 202
 203   return rv ;
 204
 205 }
 206
 207 //______________________________________________________________________
 208 Bool_t AliAnalysisGoodies::MakeEsdCollectionFromTagCollection(AliRunTagCuts * runCuts, AliEventTagCuts * evtCuts, const char * in, const char * out) const
 209 {
 210   // Makes an esd collection from a xml tag collection
 211   Bool_t rv = kTRUE ;
 212    // Open the file collection
 213   printf("*** Create Collection       ***\n");
 214   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 215   printf("***  Coll   = |%s|             \n",in);
 216
 217 #ifdef WITHALIEN
 218
 219   TGridCollection * collection = TAlienCollection::Open(in);
 220   TGridResult* result = collection->GetGridResult("");
 221   AliTagAnalysis * tagAna = new AliTagAnalysis();
 222   tagAna->ChainGridTags(result);
 223
 224   tagAna->CreateXMLCollection(out, runCuts, evtCuts) ;
 225
 226 #else
 227   rv =  kFALSE;
 228 #endif
 229   return rv ;
 230 }
 231
 232 //______________________________________________________________________
 233 Bool_t AliAnalysisGoodies::MakeEsdCollectionFromTagCollection(const char * runCuts, const char * evtCuts, const char * in, const char * out) const
 234 {
 235   // Makes an esd collection from a xml tag collection
 236
 237   Bool_t rv = kTRUE ;
 238
 239   // Open the file collection
 240   printf("*** Create Collection       ***\n");
 241   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 242   printf("***  Coll   = |%s|             \n",in);
 243
 244 #ifdef WITHALIEN
 245
 246   TGridCollection * collection = TAlienCollection::Open(in);
 247   TGridResult* result = collection->GetGridResult("");
 248   AliTagAnalysis * tagAna = new AliTagAnalysis();
 249   tagAna->ChainGridTags(result);
 250
 251   tagAna->CreateXMLCollection(out, runCuts, evtCuts) ;
 252
 253   return rv ;
 254 #else
 255   return kFALSE;
 256 #endif
 257 }
 258
 259 //______________________________________________________________________
 260 Bool_t AliAnalysisGoodies::Merge(const char * collectionFile, const char * subFile, const char * outFile)
 261 {
 262   // merges files listed in a xml collection
 263   // usage Merge(collection, outputFile))
 264   //              collection: is a xml collection
 265
 266   Bool_t rv = kFALSE ;
 267
 268   if ( strstr(collectionFile, ".xml") == 0 ) {
 269     AliError("Input collection file must be an \".xml\" file\n") ;
 270     return kFALSE ;
 271   }
 272
 273   fTimer.Start() ;
 274
 275   // Open the file collection
 276   printf("*** Create Collection       ***\n");
 277   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 278   printf("***  Coll   = |%s|             \n",collectionFile);
 279
 280 #ifdef WITHALIEN
 281
 282   TGridCollection * collection = TAlienCollection::Open(collectionFile);
 283   TGridResult* result = collection->GetGridResult("");
 284
 285   Int_t index = 0  ;
 286   const char * turl ;
 287   TFileMerger merger ;
 288   if (!outFile) {
 289     TString tempo(collectionFile) ;
 290     if ( subFile)
 291       tempo.ReplaceAll(".xml", subFile) ;
 292     else
 293       tempo.ReplaceAll(".xml", "_Merged.root") ;
 294     outFile = tempo.Data() ;
 295   }
 296   merger.OutputFile(outFile) ;
 297
 298   while ( (turl = result->GetKey(index, "turl")) ) {
 299     char file[2048] ;
 300     if ( subFile )
 301       sprintf(file, "%s#%s", turl, subFile) ;
 302     else
 303       sprintf(file, "%s", turl) ;
 304
 305     printf("%s\n", file) ;
 306     merger.AddFile(file) ;
 307     index++ ;
 308   }
 309
 310   if (index)
 311     merger.Merge() ;
 312
 313   AliInfo(Form("Files merged into %s\n", outFile)) ;
 314
 315   fTimer.Stop();
 316   fTimer.Print();
 317
 318   return rv ;
 319 #else
 320   return kFALSE;
 321 #endif
 322 }
 323
 324 //______________________________________________________________________
 325 Bool_t AliAnalysisGoodies::Process(TChain * chain)
 326 {
 327   // process events starting from a chain of esd Trees
 328   Bool_t rv = kFALSE ;
 329   fTimer.Start() ;
 330
 331   rv = ProcessChain(chain) ;
 332
 333   fTimer.Stop();
 334   fTimer.Print();
 335
 336   return rv ;
 337 }
 338
 339 //______________________________________________________________________
 340 Bool_t AliAnalysisGoodies::Process(const char * inFile)
 341 {
 342   // process the events with an Analysis Task
 343   // usage Process(esdFile)
 344   //              esdFile: is of the form opt?file_lfn
 345   Bool_t rv = kFALSE ;
 346   AliRunTagCuts   * runCuts = 0x0 ;
 347   AliEventTagCuts * evtCuts = 0x0 ;
 348
 349   rv = Process(inFile, runCuts, evtCuts) ;
 350
 351   return rv ;
 352 }
 353
 354 //______________________________________________________________________
 355 Bool_t AliAnalysisGoodies::Process(const char * inFile, AliRunTagCuts *runCuts, AliEventTagCuts * evtCuts )
 356 {
 357   // process the events with an Analysis Task
 358   // usage Process(esdFile, runtagCuts, evtTagCuts)
 359   //              esdFile: is of the form opt?file_lfn
 360
 361   Bool_t rv = kFALSE ;
 362
 363   fTimer.Start() ;
 364
 365   TString file(inFile) ;
 366   if ( file.Contains("esd?") && file.Contains(".root") ) {
 367     file.ReplaceAll("esd?", "") ;
 368     rv = ProcessEsdFile(file.Data()) ;
 369
 370   } else if ( file.Contains("esd?") && file.Contains(".xml") ) {
 371     file.ReplaceAll("esd?", "") ;
 372     rv = ProcessEsdXmlCollection(file.Data()) ;
 373
 374   } else if (file.Contains("tag?") && file.Contains(".root") ) {
 375     file.ReplaceAll("tag?", "") ;
 376     rv = ProcessTagFile(file.Data(), runCuts, evtCuts) ;
 377
 378   } else if (file.Contains("tag?") && file.Contains(".xml") ) {
 379     file.ReplaceAll("tag?", "") ;
 380     rv = ProcessTagXmlCollection(file.Data(), runCuts, evtCuts) ;
 381
 382   } else {
 383     AliError(Form("%s is not a valid file format", inFile)) ;
 384     rv = kFALSE ;
 385   }
 386
 387   fTimer.Stop();
 388   fTimer.Print();
 389
 390   return rv ;
 391 }
 392
 393 //______________________________________________________________________
 394 Bool_t AliAnalysisGoodies::Process(const char * inFile, const char * runCuts, const char * evtCuts)
 395 {
 396   // process the events with an Analysis Task
 397   // usage Process(esdFile, runtagCuts, evtTagCuts)
 398   //              esdFile: is of the form opt?file_lfn
 399
 400   Bool_t rv = kFALSE ;
 401
 402   fTimer.Start() ;
 403
 404   TString file(inFile) ;
 405   if ( file.Contains("esd?") && file.Contains(".root") ) {
 406     file.ReplaceAll("esd?", "") ;
 407     rv = ProcessEsdFile(file.Data()) ;
 408
 409   } else if ( file.Contains("esd?") && file.Contains(".xml") ) {
 410     file.ReplaceAll("esd?", "") ;
 411     rv = ProcessEsdXmlCollection(file.Data()) ;
 412
 413   } else if (file.Contains("tag?") && file.Contains(".root") ) {
 414     file.ReplaceAll("tag?", "") ;
 415     rv = ProcessTagFile(file.Data(), runCuts, evtCuts) ;
 416
 417   } else if (file.Contains("tag?") && file.Contains(".xml") ) {
 418     file.ReplaceAll("tag?", "") ;
 419     rv = ProcessTagXmlCollection(file.Data(), runCuts, evtCuts) ;
 420
 421   } else {
 422     AliError(Form("%s is not a valid file format", inFile)) ;
 423     rv = kFALSE ;
 424   }
 425
 426   fTimer.Stop();
 427   fTimer.Print();
 428
 429   return rv ;
 430 }
 431
 432 //______________________________________________________________________
 433 Bool_t AliAnalysisGoodies::ProcessChain(TChain * chain) const
 434 {
 435   // Procees a TChain.
 436
 437   Bool_t rv = kTRUE ;
 438
 439   if (! fTaskList ) {
 440     AliError("No tasks defined") ;
 441     return kFALSE ;
 442   }
 443
 444   // Make the analysis manager
 445   AliAnalysisManager * mgr = new AliAnalysisManager("Goodies Manager", "Analysis manager created by AliAnalysisGoodies") ;
 446
 447   // Make tasks
 448   // The top input must be common to all top tasks
 449   TClass * classIn = fTaskInType[0] ;
 450   AliAnalysisDataContainer * taskInput  = mgr->CreateContainer("InputContainer", classIn, AliAnalysisManager::kInputContainer) ;
 451   Int_t index ;
 452   for (index = 0; index < fnumberOfTasks; index++) {
 453     AliAnalysisTask * task = fTaskList[index] ;
 454     mgr->AddTask(task) ;
 455
 456     // Create containers for input/output
 457     TClass * classOu = fTaskOuType[index] ;
 458     AliAnalysisDataContainer * taskOutput = mgr->CreateContainer(Form("OutputContainer%d",index), classOu, AliAnalysisManager::kOutputContainer,
 459                                             Form("%s.root",task->GetName())) ;
 460     mgr->ConnectInput (task, 0, taskInput);
 461     mgr->ConnectOutput(task, 0, taskOutput);
 462   }
 463
 464   // Open data
 465 //  taskInput->SetData(chain);
 466
 467   if (mgr->InitAnalysis()) {
 468     mgr->PrintStatus();
 469 //    chain->Process(mgr);
 470     mgr->StartAnalysis("local",chain);
 471   } else
 472     rv = kFALSE ;
 473
 474   return rv ;
 475 }
 476
 477 //______________________________________________________________________
 478 Bool_t AliAnalysisGoodies::ProcessEsdFile(const char * esdFile) const
 479 {
 480   // process the events in a single ESD file with an Analysis Task
 481   // usage ProcessLocalEsdFile(esdFile)
 482   //              esdFile: is the root file (local or in alien) with the ESD Tree ( ex: AliESDs.root)
 483
 484   Bool_t rv = kTRUE ;
 485
 486   printf("*** Process       ***\n");
 487   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 488   printf("***  Coll   = |%s|             \n",esdFile);
 489
 490   // Makes the ESD chain
 491   printf("*** Getting the Chain       ***\n");
 492   TChain* analysisChain = new TChain(fESDTreeName) ;
 493   analysisChain->AddFile(esdFile);
 494
 495   // Process the events
 496   rv = ProcessChain(analysisChain) ;
 497
 498   return rv;
 499 }
 500
 501 //______________________________________________________________________
 502 Bool_t AliAnalysisGoodies::ProcessTagFile(const char * tagFile, AliRunTagCuts *runCuts, AliEventTagCuts *evtCuts) const
 503 {
 504   // process the events in a single Tag file with an Analysis Task
 505   // usage ProcessLocalEsdFile(tagFile)
 506   //              tagFile: is the root file (local or in alien) with the Tag Tree (ex: Run102.Event0_100.ESD.tag.root)
 507
 508   Bool_t rv = kTRUE ;
 509
 510   if ( !evtCuts && !runCuts ) {
 511     AliError("No Tag cuts provided") ;
 512     return kFALSE ;
 513   }
 514
 515   printf("*** Process       ***\n");
 516   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 517   printf("***  Coll   = |%s|             \n",tagFile);
 518
 519   AliTagAnalysis * tagAna = new AliTagAnalysis();
 520   rv = tagAna->AddTagsFile(tagFile);
 521   if ( ! rv )
 522     return rv ;
 523
 524   // Query the tag file and make the analysis chain
 525   TChain * analysisChain = new TChain(fESDTreeName)  ;
 526   analysisChain = tagAna->QueryTags(runCuts, evtCuts);
 527
 528   // Process the events
 529   rv = ProcessChain(analysisChain) ;
 530
 531   return rv;
 532 }
 533
 534 //______________________________________________________________________
 535 Bool_t AliAnalysisGoodies::ProcessTagFile(const char * tagFile, const char * runCuts, const char * evtCuts) const
 536 {
 537   // process the events in a single Tag file with an Analysis Task
 538   // usage ProcessLocalEsdFile(tagFile)
 539   //              tagFile: is the root file (local or in alien) with the Tag Tree (ex: Run102.Event0_100.ESD.tag.root)
 540
 541   Bool_t rv = kTRUE ;
 542
 543
 544   if ( !evtCuts && !runCuts ) {
 545     AliError("No Tag cuts provided") ;
 546     return kFALSE ;
 547   }
 548
 549   printf("*** Process       ***\n");
 550   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 551   printf("***  Coll   = |%s|             \n",tagFile);
 552
 553   AliTagAnalysis * tagAna = new AliTagAnalysis();
 554   rv = tagAna->AddTagsFile(tagFile);
 555   if ( ! rv )
 556     return rv ;
 557
 558   // Query the tag file and make the analysis chain
 559   TChain * analysisChain = new TChain(fESDTreeName)  ;
 560   analysisChain = tagAna->QueryTags(runCuts, evtCuts);
 561
 562   // Process the events
 563  rv = ProcessChain(analysisChain) ;
 564
 565   return rv;
 566 }
 567
 568 //______________________________________________________________________
 569 Bool_t AliAnalysisGoodies::ProcessEsdXmlCollection(const char * xmlFile) const
 570 {
 571   // process the events in a xml ESD collection  with an Analysis Task
 572   // usage ProcessLocalEsdFile(xmlFile)
 573   //              xmlFile: is the local xml file with the ESD collection ( ex: esdCollection.xml)
 574
 575   Bool_t rv = kTRUE ;
 576
 577   printf("*** Process       ***\n");
 578   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 579   printf("***  Coll   = |%s|             \n",xmlFile);
 580
 581 #ifdef WITHALIEN
 582
 583   TGridCollection * collection = TAlienCollection::Open(xmlFile) ;
 584   if (! collection) {
 585     AliError(Form("%s not found", xmlFile)) ;
 586     return kFALSE ;
 587   }
 588
 589   TGridResult* result = collection->GetGridResult("");
 590   TList* analysisfilelist = result->GetFileInfoList();
 591
 592   // Makes the ESD chain
 593   printf("*** Getting the Chain       ***\n");
 594   TChain* analysisChain = new TChain(fESDTreeName);
 595   analysisChain->AddFileInfoList(analysisfilelist);
 596
 597   // Process the events
 598   rv = ProcessChain(analysisChain) ;
 599
 600   return rv ;
 601 #else
 602   return kFALSE;
 603 #endif
 604 }
 605
 606 //______________________________________________________________________
 607 Bool_t AliAnalysisGoodies::ProcessTagXmlCollection(const char * xmlFile, AliRunTagCuts *runCuts, AliEventTagCuts * evtCuts) const
 608 {
 609   // process the events in a xml ESD collection  with an Analysis Task
 610   // usage ProcessLocalEsdFile(xmlFile)
 611   //              xmlFile: is the local xml file with the tag collection ( ex: tagCollection.xml)
 612
 613   Bool_t rv = kTRUE ;
 614
 615   if ( !evtCuts && !runCuts ) {
 616     AliError("No Tag cuts provided") ;
 617     return kFALSE ;
 618   }
 619
 620   printf("*** Process       ***\n");
 621   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 622   printf("***  Coll   = |%s|             \n",xmlFile);
 623
 624   // check if file is local or alien
 625   if ( gSystem->AccessPathName(xmlFile) )
 626     TGrid::Connect("alien://");
 627
 628 #ifdef WITHALIEN
 629
 630   TGridCollection * collection = TAlienCollection::Open(xmlFile) ;
 631   if (! collection) {
 632     AliError(Form("%s not found", xmlFile)) ;
 633     return kFALSE ;
 634   }
 635
 636   TGridResult* result = collection->GetGridResult("");
 637   AliTagAnalysis * tagAna = new AliTagAnalysis();
 638   tagAna->ChainGridTags(result);
 639
 640   // Query the tag file and make the analysis chain
 641   TChain * analysisChain = new TChain(fESDTreeName)  ;
 642   analysisChain = tagAna->QueryTags(runCuts, evtCuts);
 643
 644   // Process the events
 645   rv = ProcessChain(analysisChain) ;
 646
 647   return rv ;
 648 #else
 649   return kFALSE;
 650 #endif
 651 }
 652
 653 //______________________________________________________________________
 654 Bool_t AliAnalysisGoodies::ProcessTagXmlCollection(const char * xmlFile, const char * runCuts, const char * evtCuts) const
 655 {
 656   // process the events in a xml ESD collection  with an Analysis Task
 657   // usage ProcessLocalEsdFile(xmlFile)
 658   //              xmlFile: is the local xml file with the tag collection ( ex: tagCollection.xml)
 659
 660   Bool_t rv = kTRUE ;
 661
 662  if ( !evtCuts && !runCuts ) {
 663     AliError("No Tag cuts provided") ;
 664     return kFALSE ;
 665   }
 666
 667   printf("*** Process       ***\n");
 668   printf("***  Wk-Dir = |%s|             \n",gSystem->WorkingDirectory());
 669   printf("***  Coll   = |%s|             \n",xmlFile);
 670
 671 #ifdef WITHALIEN
 672
 673   // check if file is local or alien
 674   if ( gSystem->AccessPathName(xmlFile) )
 675     TGrid::Connect("alien://");
 676
 677   TGridCollection * collection = TAlienCollection::Open(xmlFile) ;
 678   if (! collection) {
 679     AliError(Form("%s not found", xmlFile)) ;
 680     return kFALSE ;
 681   }
 682
 683   TGridResult* result = collection->GetGridResult("");
 684   AliTagAnalysis * tagAna = new AliTagAnalysis();
 685   tagAna->ChainGridTags(result);
 686
 687   // Query the tag file and make the analysis chain
 688   TChain * analysisChain = new TChain(fESDTreeName)  ;
 689   analysisChain = tagAna->QueryTags(runCuts, evtCuts);
 690
 691   // Process the events
 692   rv = ProcessChain(analysisChain) ;
 693
 694   return rv ;
 695 #else
 696   return kFALSE;
 697 #endif
 698 }
 699
 700 //______________________________________________________________________
 701 Bool_t AliAnalysisGoodies::Register( const char * lfndir, const char * pfndir, const char * file)
 702 {
 703   // register files already stored in a MSS into the AliEn catalog
 704   // usage: Register(lfndir, pfndir, pfnFileName)
 705   //         lfndir : AliEn directory ( ex:  /alice/data/2006/LHC06c/PHOS_TestBeam/ )
 706   //         pfndir : MSS directory   ( ex: /castor/cern.ch/alice/testbeam/phos/2006 )
 707   //         file   : text file with a list of the file names to be registered
 708
 709   Bool_t rv = kTRUE ;
 710   fTimer.Start() ;
 711
 712   ifstream in;
 713   in.open(file);
 714   if ( in.bad() ) {
 715     AliError(Form("Cannot open file %s\n", file)) ;
 716     return kFALSE ;
 717   }
 718
 719   TGrid::Connect("alien://");
 720
 721   char fileName[1024] ;
 722
 723   while (1) {
 724     in >> fileName ;
 725     if (!in.good())
 726       break;
 727     char lfn[1024] ;
 728
 729     sprintf(lfn, "%s/%s", lfndir, fileName) ;
 730
 731     char pfn[1024] ;
 732
 733     sprintf(pfn, "castor://Alice::CERN::Castor2/%s/%s", pfndir, fileName) ;
 734
 735     printf("Register %s as %s\n", pfn, lfn) ;
 736
 737     gGrid->Register(lfn, pfn) ;
 738   }
 739
 740   fTimer.Stop();
 741   fTimer.Print();
 742
 743   return rv;
 744 }
 745
 746 //______________________________________________________________________
 747 void AliAnalysisGoodies::SetTasks(Int_t nb, AliAnalysisTask ** taskList, TClass ** inputType, TClass ** outputType)
 748 {
 749   // define a task with its output and input type
 750
 751
 752   fnumberOfTasks= nb;
 753   fTaskList   = taskList ;
 754   fTaskInType = inputType ;
 755   fTaskOuType = outputType ;
 756 }