PWG2/RESONANCES/macros/PWG2resonancesUtils.C

   1 #ifndef AliRsnUtils_cxx
   2 #define AliRsnUtils_cxx
   3
   4 class AliRsnUtils
   5 {
   6   public:
   7     enum EType {
   8       kLocal = 0,
   9       kProof,
  10       kAlien,
  11       kLastIndex
  12     };
  13
  14     enum EDataType {
  15       kTxt = 0,
  16       kDataSet,
  17       kXmlCollection,
  18       kXmlCollectionTag,
  19       kDataLastIndex
  20     };
  21
  22     AliRsnUtils(EType type, TString where, TString reset = "", TString rootVer = "");
  23     AliRsnUtils(EType type, Bool_t shouldRun = kTRUE, Bool_t shouldCopy = kTRUE,TAlienJDL*jdl=0);
  24     ~AliRsnUtils() {}
  25
  26     Bool_t Connect();
  27     Bool_t CleanPackages(TString pars = "all");
  28     Bool_t LoadPars(TString pars = "STEERBase:ESD:AOD:ANALYSIS:ANALYSISalice:PWG2resonances",Bool_t loadParsLocaly=kTRUE);
  29     Bool_t SetInputData(EDataType type = kTxt, TString source = "ESD.txt", TString treeName = "esdTree",
  30                         TString port = "", Int_t numfiles = 1000000, Int_t filesSkip = 0);
  31     Bool_t Run(TString macro, Long64_t numEvents = 1, Long64_t numEventsSkip = 0);
  32
  33     void Print();
  34
  35     void PrintInfoString(TString s);
  36     void PrintWarningString(TString s);
  37     void PrintErrorString(TString s);
  38
  39     Bool_t IsConnected() const { return fIsConnected; }
  40
  41     void ShouldCopy(const Bool_t& theValue) { fShouldCopy = theValue; }
  42
  43     void SetAlienRunFile(const TString& theValue) { fAlienRunFile = theValue; }
  44
  45     void AddFilesToAlien(const TString& theValue);
  46
  47     void SetAlienProjectDir(const TString& theValue) { fAlienProjectDir = theValue; }
  48     TString GetAlienProjectDir() const { return fAlienProjectDir; }
  49
  50     TAlienJDL* SetJDL(TAlienJDL*jdl) const { fJDL= jdl;}
  51     TAlienJDL* GetJDL() const;
  52
  53     void ShouldRunAlienJob(const Bool_t& theValue) { fShouldRunAlienJob = theValue; }
  54
  55     TString GetTagTypeFromTreeName(TString treeName);
  56
  57     void SetAlienProjectDirSE(TString se="ALICE::CERN::SE") { fAlienProjectDirSE = se; };
  58
  59     void DoMixing(Bool_t doMix=kTRUE) { fDoMixing = doMix; }
  60
  61   private:
  62
  63     EType      fCurrentType;              // current analysis type
  64     EDataType  fCurrentDataType;          // current data type
  65     Bool_t     fDoMixing;                 // flag if we will use mixing (AliAnalysisTaskME)
  66     Bool_t     fIsConnected;              // flag if we are connected
  67     Bool_t     fShouldEnd;                // flag if macro should be terminated(in case error)
  68     TString    fConnectInfo[3];           // connection info (all 3 are use in proof mode)
  69     TString    fDataInfo[kLastIndex];     // data info
  70     TString    fTreeName;                 // tree name
  71     TString    fParNames;                 // pars name
  72     TChain*    fChain;                    // chain which will be processed
  73
  74     // AliEn Part
  75     TString    fAlienProjectDir;          // alien Project directory
  76     TString    fAlienProjectDirSE;        // alien Project directory Storage Element
  77     TString    fAlienOutputDir;           // alien output directory
  78     TString    fAlienRunFile;             // run file name (default is AliRsnAlien.C)
  79     TString    fFilesToAlien;             // list of files to copy to alien additional to
  80
  81     // pars. for example (PWG2resonances.C)
  82     TAlienJDL* fJDL;                      // jdl class which submits job
  83     Bool_t     fShouldCopy;               // flag if files should be copied to alien
  84     Bool_t     fShouldRunAlienJob;        // flag if job will be submited
  85
  86     // connect functions
  87     Bool_t     ConnectProof();
  88     Bool_t     ConnectAliEn();
  89
  90     // clean functions
  91     Bool_t     CleanParsLocal(TString pars);
  92     Bool_t     CleanParsProof(TString pars);
  93
  94     // load functions
  95     Bool_t     LoadParsLocal(TString pars);
  96     Bool_t     LoadParsProof(TString pars);
  97
  98     // process par
  99     Bool_t     ProcessPAR(TString pars);
 100
 101     // gets chain from TXT file
 102     TChain* CreateChainFromTXT(TString chainName = "esdTree", TString aDataDir = "ESDfiles.txt",Int_t aRuns = 200, Int_t offset = 0, TString portNum = "1094");
 103
 104     // gets chain from xml collection file
 105     TChain* CreateChainFromCollection(TString chainName = "esdTree", TString collname = "my.xml", Int_t maxFiles = 1000, Int_t skipfiles = 0);
 106
 107     // gets chain from xml collection file
 108     TChain* CreateChainFromCollectionTag(TString chainName = "ESD", TString collname = "tag.xml");
 109
 110     // copy to AliEn function
 111     Bool_t CopyFilesToAliEn();
 112
 113     // generates macro which will be run on alien
 114     Bool_t CreateRunAliEnFile(TString macro);
 115
 116     // runs alien job
 117     Bool_t RunAliEnJob();
 118
 119     // copies one file to alien
 120     Bool_t CopyFileToAlien(TString file,Bool_t overwrite = kTRUE);
 121
 122     ClassDef(AliRsnUtils, 1)
 123 };
 124
 125 #endif
 126
 127 ClassImp(AliRsnUtils)
 128
 129 //________________________________________________________________________
 130 AliRsnUtils::AliRsnUtils(EType type, TString where, TString reset, TString rootVer) :
 131     fCurrentType(type),
 132     fCurrentDataType(kTxt),
 133     fDoMixing(kFALSE),
 134     fIsConnected(kFALSE),
 135     fShouldEnd(kFALSE),
 136     fChain(0),
 137     fAlienProjectDirSE("ALICE::CERN::SE"),
 138     fJDL(0),
 139     fShouldCopy(kTRUE),
 140     fShouldRunAlienJob(kTRUE),
 141     fAlienRunFile("AliRsnAlien.C")
 142 {
 143 //
 144 // Constructor
 145 //
 146   // setting up parameters
 147   fConnectInfo[0] = where;
 148   fConnectInfo[1] = reset;
 149   fConnectInfo[2] = rootVer;
 150
 151   // connecting
 152   Connect();
 153 }
 154
 155 //________________________________________________________________________
 156 AliRsnUtils::AliRsnUtils(EType type, Bool_t shouldRun, Bool_t shouldCopy,TAlienJDL*jdl) :
 157     fCurrentType(type),
 158     fCurrentDataType(kTxt),
 159     fDoMixing(kFALSE),
 160     fIsConnected(kFALSE),
 161     fShouldEnd(kFALSE),
 162     fChain(0),
 163     fJDL(jdl),
 164     fShouldRunAlienJob(shouldRun),
 165     fShouldCopy(shouldCopy),
 166     fAlienRunFile("AliRsnAlien.C")
 167 {
 168
 169   // connecting
 170   Connect();
 171 }
 172
 173 //________________________________________________________________________
 174 void AliRsnUtils::PrintInfoString(const char *msg)
 175 {
 176   // prints message as Info
 177   Info("", msg);
 178 }
 179
 180 //________________________________________________________________________
 181 void AliRsnUtils::PrintWarningString(const char *msg)
 182 {
 183   // prints message as Warning
 184   Warning("", msg);
 185 }
 186
 187 //________________________________________________________________________
 188 void AliRsnUtils::PrintErrorString(const char *msg)
 189 {
 190   // prints message as Error
 191   Error("", msg);
 192 }
 193
 194 //________________________________________________________________________
 195 Bool_t AliRsnUtils::Connect()
 196 {
 197 // connect to local, proof, alien if needed
 198   switch (fCurrentType) {
 199     case kLocal:
 200       PrintInfoString("Running Local...");
 201       fIsConnected = kTRUE;
 202       break;
 203     case kProof:
 204       PrintInfoString(Form("Running Proof at %s...", fConnectInfo[0].Data()));
 205       fIsConnected = ConnectProof();
 206       if (!IsConnected()) {
 207         PrintErrorString(Form("Not connected to %s !!!", fConnectInfo[0].Data()));
 208       }
 209       break;
 210     case kAlien:
 211       PrintInfoString(Form("Running AliEn..."));
 212       fIsConnected = ConnectAliEn();
 213       if (!IsConnected()) {
 214         PrintErrorString("Not connected to AliEn !!!");
 215       }
 216       break;
 217     default:
 218       PrintErrorString("Wrong type");
 219       fIsConnected = kFALSE;
 220       return kFALSE;
 221   }
 222
 223   if (!IsConnected()) {
 224     PrintErrorString("Connection failed. Aborting...");
 225     return kFALSE;
 226   }
 227
 228   return kTRUE;
 229 }
 230
 231 //________________________________________________________________________
 232 Bool_t AliRsnUtils::CleanPackages(TString pars)
 233 {
 234
 235 // cleans packages
 236   if (fShouldEnd) return kFALSE;
 237   switch (fCurrentType) {
 238     case kLocal:
 239       return CleanParsLocal(pars);
 240       break;
 241     case kProof:
 242       if (!IsConnected()) return kFALSE;
 243       return CleanParsProof(pars);
 244       break;
 245     case kAlien:
 246       return kTRUE;
 247       break;
 248     default:
 249       PrintErrorString("Wrong type");
 250       return kFALSE;
 251   }
 252 }
 253
 254 //________________________________________________________________________
 255 Bool_t AliRsnUtils::LoadPars(TString pars,Bool_t loadParsLocaly)
 256 {
 257 // loads par files
 258   if (fShouldEnd) return kFALSE;
 259   switch (fCurrentType) {
 260     case kLocal:
 261       if (!IsConnected()) return kFALSE;
 262       return LoadParsLocal(pars);
 263       break;
 264     case kProof:
 265       if (!IsConnected()) return kFALSE;
 266       return LoadParsProof(pars);
 267       break;
 268     case kAlien:
 269       if (!pars.IsNull()) {
 270         fParNames = pars;
 271         pars.ReplaceAll(":",".par:");
 272         pars += ".par";
 273         AddFilesToAlien(pars);
 274         if (loadParsLocaly)
 275           return LoadParsLocal(pars);
 276       }
 277       return kTRUE;
 278       break;
 279     default:
 280       PrintErrorString("Wrong type");
 281       return kFALSE;
 282   }
 283
 284   return kTRUE;
 285 }
 286
 287 //________________________________________________________________________
 288 Bool_t AliRsnUtils::SetInputData
 289 (EDataType type, TString source, TString treeName, TString port, Int_t numfiles, Int_t filesSkip)
 290 {
 291 // sets input which will be used in Run() function
 292 //
 293
 294   fDataInfo[type] = source;
 295   switch (type) {
 296     case kTxt:
 297       fCurrentDataType = type;
 298       fChain = CreateChainFromTXT(treeName, fDataInfo[type], numfiles, filesSkip, port);
 299       if (!fChain) return kFALSE;
 300       return kTRUE;
 301       break;
 302     case kDataSet:
 303       fCurrentDataType = type;
 304       break;
 305     case kXmlCollection:
 306       fCurrentDataType = type;
 307       fTreeName = treeName;
 308       if (fCurrentType == AliRsnUtils::kAlien) return kTRUE;
 309       if (fCurrentType == AliRsnUtils::kLocal) ConnectAliEn();
 310       fChain = CreateChainFromCollection(treeName, fDataInfo[type], numfiles, filesSkip);
 311       break;
 312     case kXmlCollectionTag:
 313       fCurrentDataType = type;
 314       fTreeName = treeName;
 315       if (fCurrentType == AliRsnUtils::kAlien) return kTRUE;
 316       if (fCurrentType == AliRsnUtils::kLocal) ConnectAliEn();
 317       fDataInfo[type] = source;
 318       fChain = CreateChainFromCollectionTag(treeName, fDataInfo[type]);
 319
 320       break;
 321     default:
 322       PrintErrorString("Wrong type");
 323       return kFALSE;
 324   }
 325
 326   return kTRUE;
 327 }
 328
 329 //________________________________________________________________________
 330 Bool_t AliRsnUtils::Run(TString macro, Long64_t numEvents, Long64_t numEventsSkip)
 331 {
 332 // runs job
 333   if (fCurrentType == AliRsnUtils::kAlien) {
 334     Bool_t returnBool = CreateRunAliEnFile(macro);
 335     if (returnBool == kFALSE) return kFALSE;
 336     returnBool = CopyFilesToAliEn();
 337     if (returnBool == kFALSE) return kFALSE;
 338     returnBool = RunAliEnJob();
 339     if (returnBool == kFALSE) return kFALSE;
 340     return kTRUE;
 341   }
 342
 343   gROOT->LoadMacro(macro.Data());
 344   macro.ReplaceAll(".C","");
 345   AliAnalysisManager *mgr = (AliAnalysisManager *) gROOT->ProcessLine(Form("%s();", macro.Data()));
 346
 347   if (!mgr) return kFALSE;
 348
 349   if (mgr->InitAnalysis()) {
 350     mgr->PrintStatus();
 351
 352     switch (fCurrentDataType) {
 353       case kTxt:
 354         if (!fChain) PrintErrorString("fChain is null");
 355         TString mode = "local";
 356         if (fCurrentType == AliRsnUtils::kProof) mode="proof";
 357         if (fDoMixing) mode="mix";
 358         Info("AliRsnUtils::Run",Form("Running mgr->StartAnalysis(\"%s\",%p,%d,%d)",mode.Data(),fChain,numEvents,numEventsSkip));
 359         return mgr->StartAnalysis(mode, fChain,numEvents,numEventsSkip);
 360         break;
 361       case kDataSet:
 362         TString mode = "local";
 363         if (fCurrentType == AliRsnUtils::kProof) mode="proof";
 364         if (fDoMixing) mode="mix";
 365         Info("AliRsnUtils::Run",Form("Running mgr->StartAnalysis(\"%s\",\"%s\",%d,%d)",mode.Data(),fDataInfo[kDataSet].Data(),numEvents,numEventsSkip));
 366         return mgr->StartAnalysis(mode, fDataInfo[kDataSet].Data(),numEvents,numEventsSkip);
 367         break;
 368       case kXmlCollection:
 369         if (!fChain) {
 370           PrintErrorString("fChain is null");
 371           return kFALSE;
 372         }
 373         TString mode = "local";
 374         if (fDoMixing) mode="mix";
 375         Info("AliRsnUtils::Run",Form("Running mgr->StartAnalysis(\"%s\",%p,%d,%d)",mode.Data(),fChain,numEvents,numEventsSkip));
 376         return mgr->StartAnalysis(mode, fChain,numEvents,numEventsSkip);
 377         break;
 378       case kXmlCollectionTag:
 379         if (!fChain) {
 380           PrintErrorString("fChain is null");
 381           return kFALSE;
 382         }
 383         TString mode = "local";
 384         if (fDoMixing) mode="mix";
 385         Info("AliRsnUtils::Run",Form("Running mgr->StartAnalysis(\"%s\",%p,%d,%d)",mode.Data(),fChain,numEvents,numEventsSkip));
 386         return mgr->StartAnalysis(mode, fChain,numEvents,numEventsSkip);
 387         break;
 388       default:
 389         PrintErrorString("Wrong type");
 390         return kFALSE;
 391
 392     }
 393   }
 394   return kTRUE;
 395 }
 396
 397 //________________________________________________________________________
 398 Bool_t AliRsnUtils::ConnectProof()
 399 {
 400   // connects to proof
 401   //
 402   // if one uses AliRsnUtils::kProof constructor
 403   // AliRsnUtils ( AliRsnUtils::kProof,TString where = "mvala@lxb6046.cern.ch
 404 // " , TString reset = "RESET", TString rootVer = "HEADXYZ" );
 405 //
 406 // where : means where to connect
 407 // reset : "RESET" will do gProof->Reset(where.Data());
 408 // rootVer : "HEADXYZ" will use different version of root, in this case "HEADXYZ"
 409 //
 410   if (fConnectInfo[0].IsNull()) {
 411     PrintErrorString("Proof is empty!!!");
 412     return kFALSE;
 413   }
 414
 415   if (!fConnectInfo[1].IsNull())
 416     TProof::Reset(fConnectInfo[0].Data());
 417
 418   if (!fConnectInfo[2].IsNull())
 419     TProof::Mgr(fConnectInfo[0].Data())->SetROOTVersion(fConnectInfo[2].Data());
 420
 421   return TProof::Open(fConnectInfo[0].Data());
 422 }
 423
 424 //________________________________________________________________________
 425 Bool_t AliRsnUtils::ConnectAliEn()
 426 {
 427 // connects to alien
 428   if (!gGrid)
 429     TGrid::Connect("alien://");
 430   if (!gGrid)
 431     return kFALSE;
 432
 433   return kTRUE;
 434 }
 435
 436 //________________________________________________________________________
 437 Bool_t AliRsnUtils::CleanParsLocal(TString pars)
 438 {
 439 // just delete directories which are in pars variable
 440 //
 441 // pars = "STEERBase:ESD"
 442 // will delete STEERBase and ESD directories
 443 //
 444
 445   if (pars.IsNull()) return kTRUE;
 446
 447   if (!pars.CompareTo("all")) pars = fgPARS;
 448
 449   TObjArray* array = pars.Tokenize(":");
 450   TObjString *str;
 451   TString strr;
 452   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 453     str = (TObjString *) array->At(i);
 454     strr = str->GetString();
 455     Info("",Form("Cleaning %s.par...",strr.Data()));
 456     gSystem->Exec(Form("rm -Rf %s/",strr.Data()));
 457   }
 458
 459 }
 460
 461 //________________________________________________________________________
 462 Bool_t AliRsnUtils::CleanParsProof(TString pars)
 463 {
 464 // clear par files in proof (divided by ":"). example "STEERBase:ESD"
 465 // will clear STEERBase.par and ESD.par
 466 // if pars is ALL clears all packages
 467
 468   if (pars.IsNull()) return kTRUE;
 469
 470   if (!pars.CompareTo("all")) {
 471     Info("",Form("Cleaning %s par files...",pars.Data()));
 472     gProof->ClearPackages();
 473     return kTRUE;
 474   }
 475
 476   TObjArray* array = (TObjArray*) pars.Tokenize(":");
 477   TObjString *str;
 478   TString strr;
 479   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 480     str = (TObjString *) array->At(i);
 481     strr = str->GetString();
 482     Info("",Form("Cleaning %s.par...",strr.Data()));
 483     gProof->ClearPackage(strr.Data());
 484   }
 485
 486   return kTRUE;
 487 }
 488
 489 //________________________________________________________________________
 490 Bool_t AliRsnUtils::LoadParsLocal(TString pars)
 491 {
 492 // loads pars localy
 493   TObjArray* array = pars.Tokenize(":");
 494   TObjString *str;
 495   TString strr;
 496   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 497     str = (TObjString *) array->At(i);
 498     strr = str->GetString();
 499     if (!ProcessPAR(strr.Data())) {
 500       return kFALSE;
 501     }
 502   }
 503
 504   return kTRUE;
 505 }
 506
 507 //________________________________________________________________________
 508 Bool_t AliRsnUtils::LoadParsProof(TString pars)
 509 {
 510 // load pars on proof
 511   if (!IsConnected()) return kFALSE;
 512
 513   TObjArray* array = pars.Tokenize(":");
 514   TObjString *str;
 515   TString strr;
 516   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 517     if (fShouldEnd) return kFALSE;
 518     str = (TObjString *) array->At(i);
 519     strr = str->GetString();
 520     gSystem->Exec(Form("rm -Rf %s",strr.Data()));
 521     if (gProof->UploadPackage(Form("%s.par", strr.Data()))) {
 522       PrintErrorString(Form("Error uploading %s package!!!",strr));
 523       fShouldEnd = kTRUE;
 524       return kFALSE;
 525     }
 526     if (gProof->EnablePackage(strr)) {
 527       PrintErrorString(Form("Error loading %s package!!!",strr));
 528       fShouldEnd = kTRUE;
 529       return kFALSE;
 530     }
 531     fShouldEnd = kFALSE;
 532   }
 533   gProof->ShowEnabledPackages();
 534   return kTRUE;
 535 }
 536
 537 //________________________________________________________________________
 538 void AliRsnUtils::Print()
 539 {
 540 // prints number of events
 541   if (fChain)
 542     PrintInfoString(Form("Number of events %d",fChain->GetEntries()));
 543 }
 544
 545 //________________________________________________________________________
 546 Bool_t AliRsnUtils::CopyFilesToAliEn()
 547 {
 548 // copy needed files to alien
 549   if (!IsConnected()) return kFALSE;
 550
 551   if (!fShouldCopy) return kTRUE;
 552
 553   if (fAlienProjectDir.IsNull()) {
 554     fAlienProjectDir = Form("%sRSNTASK/01",gGrid->GetHomeDirectory());
 555     PrintWarningString(Form("Alien Project directory is not defined.Setting \"%s\" as project directory ...",fAlienProjectDir.Data()));
 556   }
 557   gGrid->Rmdir(Form("%s",fAlienProjectDir.Data()));
 558   gGrid->Mkdir(Form("%s",fAlienProjectDir.Data()),"-p");
 559
 560
 561   TObjArray* array = fFilesToAlien.Tokenize(":");
 562   TObjString *str;
 563   TString strr;
 564   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 565     str = (TObjString *) array->At(i);
 566     strr = str->GetString();
 567     if (!CopyFileToAlien(Form("%s",strr.Data()) ,kFALSE)) return kFALSE;
 568   }
 569   if (!CopyFileToAlien(fAlienRunFile.Data(),kFALSE)) return kFALSE;
 570
 571   return kTRUE;
 572 }
 573
 574 //________________________________________________________________________
 575 Bool_t AliRsnUtils::CreateRunAliEnFile(TString macro)
 576 {
 577 // generated AliRsnAlien.C macro which will be executed in alien
 578   if (!IsConnected()) return kFALSE;
 579   TString file = fAlienRunFile.Data();
 580   ofstream outFile(file.Data());
 581   if (!outFile) {
 582     PrintErrorString(Form("Cannot open file %s",file.Data()));
 583     return kFALSE;
 584   }
 585   file.ReplaceAll(".C","");
 586   TString tmp;
 587   tmp = Form("Int_t %s() {",file.Data());
 588   outFile << tmp.Data() << endl;
 589
 590
 591
 592   tmp = "\tTStopwatch timer;";
 593   outFile << tmp.Data() << endl;
 594
 595   tmp = "\ttimer.Start();\n";
 596   outFile << tmp.Data() << endl;
 597
 598   tmp = "\tBool_t returnValue = kTRUE;\n";
 599   outFile << tmp.Data() << endl;
 600
 601   tmp = "\tgROOT->LoadMacro (\"PWG2resonancesUtils.C\");\n";
 602   outFile << tmp.Data() << endl;
 603
 604   tmp = "\tAliRsnUtils *utils = new AliRsnUtils (AliRsnUtils::kLocal);\n";
 605   outFile << tmp.Data() << endl;
 606
 607   tmp = Form("\treturnValue = utils->LoadPars(\"%s\");",fParNames.Data());
 608   outFile << tmp.Data() << endl;
 609
 610   tmp = "\tif (returnValue == kFALSE) {\n";
 611   tmp += "\t\tError(\"\",\"Error in utils->LoadPars()\");\n";
 612   tmp += "\t\ttimer.Stop();\n";
 613   tmp += "\t\ttimer.Print();\n";
 614   tmp += "\t\treturn -1;\n";
 615   tmp += "\t}\n";
 616   outFile << tmp.Data() << endl;
 617
 618   TString collTypeName;
 619   if (fCurrentDataType == kXmlCollection) {
 620     collTypeName = "AliRsnUtils::kXmlCollection";
 621   } else if (fCurrentDataType == kXmlCollectionTag) {
 622     collTypeName = "AliRsnUtils::kXmlCollectionTag";
 623   } else {
 624     Error("",Form("File %s was not created correctly!!!!!!!",macro.Data()));
 625     return kFALSE;
 626   }
 627
 628   tmp = Form("\treturnValue = utils->SetInputData(%s,\"wn.xml\",\"%s\");",collTypeName.Data(),fTreeName.Data());
 629   outFile << tmp.Data() << endl;
 630
 631   tmp = "\tif (returnValue == kFALSE) {\n";
 632   tmp += "\t\tError(\"\",\"Error in utils->SetInputData()\");\n";
 633   tmp += "\t\ttimer.Stop();\n";
 634   tmp += "\t\ttimer.Print();\n";
 635   tmp += "\t\treturn -1;\n";
 636   tmp += "\t}\n";
 637   outFile << tmp.Data() << endl;
 638
 639   tmp = Form("\treturnValue = utils->Run(\"%s\",10000000);",macro.Data());
 640   outFile << tmp.Data() << endl;
 641
 642   tmp = "\tif (returnValue == kFALSE) {\n";
 643   tmp += "\t\tError(\"\",\"Error in utils->Run()\");\n";
 644   tmp += "\t\ttimer.Stop();\n";
 645   tmp += "\t\ttimer.Print();\n";
 646   tmp += "\t\treturn -1;\n";
 647   tmp += "\t}\n";
 648   outFile << tmp.Data() << endl;
 649
 650   tmp = "\ttimer.Stop();";
 651   outFile << tmp.Data() << endl;
 652
 653   tmp = "\ttimer.Print();\n";
 654   outFile << tmp.Data() << endl;
 655
 656   tmp = Form("\treturn 0;",file.Data());
 657   outFile << tmp.Data() << endl;
 658
 659   tmp = Form("}",file.Data());
 660   outFile << tmp.Data() << endl;
 661
 662   outFile.close();
 663
 664   return kTRUE;
 665 }
 666
 667 //________________________________________________________________________
 668 Bool_t AliRsnUtils::RunAliEnJob()
 669 {
 670 // runs alien job
 671
 672   fJDL->SetArguments(Form("%s",fAlienRunFile.Data()));
 673
 674   TObjArray* array = fFilesToAlien.Tokenize(":");
 675   TObjString *str;
 676   TString strr;
 677   for (Int_t i=0;i< array->GetEntriesFast();i++) {
 678     str = (TObjString *) array->At(i);
 679     strr = str->GetString().Data();
 680     fJDL->AddToInputSandbox(Form("LF:%s/%s",fAlienProjectDir.Data(),strr.Data())) ;
 681   }
 682   fJDL->AddToInputSandbox(Form("LF:%s/%s",fAlienProjectDir.Data(), fAlienRunFile.Data())) ;
 683
 684   if (fShouldRunAlienJob == kFALSE)
 685     PrintInfoString(Form("\n%s",fJDL->Generate().Data()));
 686   else {
 687     TGridJob* job = gGrid->Submit(fJDL->Generate());
 688     if (job == 0) {
 689       Error("SubmitTest", "submitting failed");
 690       return kFALSE;
 691     }
 692   }
 693   return kTRUE;
 694 }
 695
 696 //________________________________________________________________________
 697 Bool_t AliRsnUtils::CopyFileToAlien(TString file, Bool_t overwrite)
 698 {
 699 // copy one file to alien
 700   if (fAlienProjectDir.IsNull()) {
 701     PrintErrorString("AliEn project directory does not exist...");
 702     return kFALSE;
 703   }
 704
 705   if (overwrite)
 706     gGrid->Rm(Form("alien://%s/%s",fAlienProjectDir.Data(),file.Data()));
 707
 708   Info("",Form("Copy from %s to %s",file.Data(),Form("alien:://%s/%s",fAlienProjectDir.Data(),file.Data())));
 709
 710
 711   return TFile::Cp(file.Data(),Form("alien:://%s/%s",fAlienProjectDir.Data(),file.Data()));
 712 }
 713
 714 //________________________________________________________________________
 715 Bool_t AliRsnUtils::ProcessPAR(TString pars)
 716 {
 717 // process one par
 718
 719   TString pararchivenameS(pars);
 720   PrintInfoString(Form("==== Processing %s package LOCAL =====",pararchivenameS.Data()));
 721
 722   if (gSystem->AccessPathName(Form("%s.par",pararchivenameS.Data()))) {
 723     PrintErrorString(Form("File %s.par was not found !!!",pararchivenameS.Data()));
 724     return kFALSE;
 725   }
 726
 727   gROOT->ProcessLine(Form(".! tar xzf %s.par", pararchivenameS.Data()));
 728   TString ocwd = gSystem->WorkingDirectory();
 729 //     gSystem->ChangeDirectory(Form("%s/%s",dirname,pararchivenameS.Data()));
 730   gSystem->ChangeDirectory(Form("%s",pararchivenameS.Data()));
 731   // check for BUILD.sh and execute
 732   if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
 733     PrintInfoString(Form("==== Building %s package =====",pararchivenameS.Data()));
 734     if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
 735       EPrintErrorString("Cannot Build the PAR Archive! - Abort!");
 736       return kFALSE;
 737     }
 738   }
 739   // check for SETUP.C and execute
 740   if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
 741     PrintInfoString(Form("==== Running SETUP.C of %s package =====",pararchivenameS.Data()));
 742     gROOT->Macro("PROOF-INF/SETUP.C");
 743     if (gROOT->Macro("PROOF-INF/SETUP.C")) {
 744       PrintErrorString("Cannot SETUP the PAR Archive! - Abort!");
 745       return kFALSE;
 746     }
 747   }
 748
 749   gSystem->ChangeDirectory(ocwd);
 750
 751   PrintInfoString(Form("==== All OK for %s package LOCAL =====",pararchivenameS.Data()));
 752   return kTRUE;
 753
 754 }
 755
 756 //________________________________________________________________________
 757 TChain* AliRsnUtils::CreateChainFromTXT
 758 (TString chainName, TString aDataDir, Int_t aRuns, Int_t offset, TString portNum)
 759 {
 760   // creates chain of files in a given directory or file containing a list.
 761   // In case of directory the structure is expected as:
 762   // <aDataDir>/<dir0>/AliESDs.root
 763   // <aDataDir>/<dir1>/AliESDs.root
 764   // ...
 765
 766   PrintInfoString(Form("Loading the chain %s", chainName.Data()));
 767   if (aDataDir.IsNull()) {
 768     PrintErrorString(Form("aDataDir not found."));
 769     return kFALSE;
 770   }
 771
 772   Long_t id, size, flags, modtime;
 773   if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime)) {
 774     PrintErrorString(Form("%s not found.", aDataDir.Data()));
 775     return kFALSE;
 776   }
 777
 778   TChain *chain = new TChain(chainName.Data());
 779
 780   // Open the input stream
 781   ifstream fileIn;
 782   fileIn.open(aDataDir.Data());
 783
 784   Int_t count = 0;
 785
 786   // Read the input list of files and add them to the chain
 787   TString esdfile;
 788   while (fileIn.good()) {
 789     fileIn >> esdfile;
 790     if (esdfile.IsNull()) continue;
 791     if (offset > 0) {
 792       --offset;
 793       continue;
 794     }
 795     if (count++ == aRuns) break;
 796
 797     // add esd file
 798     TString esdFileWithPort(esdfile);
 799     esdFileWithPort.ReplaceAll("root://","");
 800     if (!portNum.IsNull())
 801       esdFileWithPort.ReplaceAll("//",Form(":%s//",portNum.Data()));
 802     PrintInfoString (Form ("Adding root://%s",esdFileWithPort.Data()));
 803     chain->Add(Form("root://%s",esdFileWithPort.Data()));
 804   }
 805   fileIn.close();
 806
 807   PrintInfoString(Form("Loading the chain %s DONE.", chainName.Data()));
 808   return chain;
 809 }
 810
 811 //________________________________________________________________________
 812 TChain* AliRsnUtils::CreateChainFromCollection
 813 (TString chainName, TString collname, Int_t maxFiles, Int_t skipfiles)
 814 {
 815 // gets chain from xml collection file
 816
 817   TChain *chain = new TChain(chainName.Data());
 818   TAlienCollection *myCollection = TAlienCollection::Open(collname.Data());
 819   if (!myCollection) {
 820     PrintErrorString(Form("Cannot create an AliEn collection from %s", collectionFile));
 821     return 0x0;
 822   }
 823
 824   // initialize a counter to check the number of read files
 825   Int_t nfiles = 0;
 826   TString filename;
 827   myCollection->Reset();
 828   while (myCollection->Next()) {
 829     if (skipfiles > 0) {
 830       --skipfiles;
 831       continue;
 832     }
 833     if (maxFiles > 0 && nfiles >= maxFiles) break;
 834     // char fileName[255];
 835     // sprintf(fileName, "%s", myCollection->GetTURL(""));
 836     filename = myCollection->GetTURL("");
 837 //     PrintInfoString(Form("Adding file '%s'", filename.Data()));
 838     chain->Add(filename.Data());
 839     nfiles++;
 840   }
 841
 842   return chain;
 843 }
 844
 845 //________________________________________________________________________
 846 TChain* AliRsnUtils::CreateChainFromCollectionTag
 847 (TString chainName, TString collname)
 848 {
 849 // gets chain from xml collection file
 850
 851   TAlienCollection *coll = TAlienCollection::Open(collname.Data());
 852   if (!coll) {
 853     PrintErrorString(Form("Cannot create an AliEn collection from %s", collname.Data()));
 854     return 0x0;
 855   }
 856
 857   TString anaType = GetTagTypeFromTreeName(chainName);
 858   if (anaType.IsNull()) {
 859     PrintErrorString(Form("anaType is %s", anaType.Data()));
 860     return (TChain*)0x0;
 861   }
 862
 863   TGridResult* tagResult = coll->GetGridResult("",kFALSE,kFALSE);
 864   AliTagAnalysis *tagAna = new AliTagAnalysis(anaType.Data());
 865   tagAna->ChainGridTags(tagResult);
 866
 867   AliRunTagCuts      *runCuts = new AliRunTagCuts();
 868   AliLHCTagCuts      *lhcCuts = new AliLHCTagCuts();
 869   AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
 870   AliEventTagCuts    *evCuts  = new AliEventTagCuts();
 871   // Check if the cuts configuration file was provided
 872   if (!gSystem->AccessPathName("ConfigureCuts.C")) {
 873     gROOT->LoadMacro("ConfigureCuts.C");
 874     ConfigureCuts(runCuts, lhcCuts, detCuts, evCuts);
 875   }
 876   TChain *chain = tagAna->QueryTags(runCuts, lhcCuts, detCuts, evCuts);
 877   if (!chain || !chain->GetNtrees()) return (TChain*)0x0;
 878   chain->ls();
 879   return chain;
 880
 881 }
 882
 883 //________________________________________________________________________
 884 void AliRsnUtils::AddFilesToAlien(const TString &fileName)
 885 {
 886 // adds file to alien's list which will be copied to alien
 887   if (fFilesToAlien.IsNull()) fFilesToAlien += fileName;
 888   else {
 889     fFilesToAlien += ":";
 890     fFilesToAlien += fileName;
 891   }
 892 }
 893
 894 //________________________________________________________________________
 895 TAlienJDL* AliRsnUtils::GetJDL() const
 896 {
 897 // gets JDL
 898   if (!fJDL) fJDL = (TAlienJDL*) gGrid->GetJDLGenerator();
 899   return fJDL;
 900 }
 901
 902 //________________________________________________________________________
 903 TString AliRsnUtils::GetTagTypeFromTreeName(TString treeName)
 904 {
 905 // gets Tag name
 906
 907   if (!treeName.CompareTo("esdTree"))
 908     return "ESD";
 909   if (!treeName.CompareTo("aodTree"))
 910     return "AOD";
 911
 912   return "";
 913 }
 914
 915 // EXTRA MACROS
 916
 917 static TString fgMode,fgProofToConnect,fgLIBS,fgPARS,fgPARSClean,fgMacro,fgPostMacro,fgInputFileName,fgTreeName;
 918 static TString fgAlirootLibPath;
 919 static TString fgPort,fgUser,fgReset,fgRootVersionInProof,fgCollName;
 920 static TString fgProjectDir,fgOutputDir,fgExtraInputFiles,fgProjectDirSE;
 921 static TString fgPostMacroArgs;
 922 static Int_t fgDataType,fgAlienSplit;
 923 static Long64_t fgNumOfEvents,fgNumOfEventsSkip;
 924 static Bool_t fgAlienShouldRun = kFALSE, fgAlienShoudlCopy = kFALSE,fgUseLocalLibs=kFALSE,fgDoMixing=kFALSE;
 925 static TAlienJDL *fgJDL=0;
 926 Bool_t runLocal()
 927 {
 928
 929   Bool_t returnBool = kTRUE;
 930
 931   // creating utils (located in macro PWG2resonancesUtils.C)
 932   AliRsnUtils *utils = new AliRsnUtils(AliRsnUtils::kLocal);
 933   utils->DoMixing(fgDoMixing);
 934
 935   returnBool = utils->CleanPackages ( fgPARSClean );
 936   if (!returnBool) return kFALSE;
 937
 938   // Loading pars
 939 //   if (fgUseLocalLibs)
 940     returnBool = runLocalLibs(fgLIBS.Data(),fgAlirootLibPath.Data());
 941 //   else
 942     returnBool = utils->LoadPars(fgPARS.Data());
 943
 944   if (!returnBool) return kFALSE;
 945
 946   // Input Data
 947   returnBool = utils->SetInputData((AliRsnUtils::EDataType)fgDataType,fgInputFileName,fgTreeName,fgPort);
 948   if (!returnBool) return kFALSE;
 949
 950 //   utils->Print();
 951
 952   if (fgMacro.IsNull()) {
 953     utils->PrintErrorString("fMacro is null");
 954     return kFALSE;
 955   }
 956
 957   // Running Macro
 958   utils->Run(fgMacro.Data(),fgNumOfEvents,fgNumOfEventsSkip);
 959
 960   return returnBool;
 961 }
 962 Bool_t runProof()
 963 {
 964
 965   Bool_t returnBool = kTRUE;
 966
 967   // creating utils (located in macro PWG2resonancesUtils.C)
 968   AliRsnUtils *utils = new AliRsnUtils(AliRsnUtils::kProof,fgProofToConnect,fgReset,fgRootVersionInProof);
 969   utils->DoMixing(fgDoMixing);
 970
 971   utils->CleanPackages(fgPARSClean);
 972
 973   // Loading pars
 974   returnBool = utils->LoadPars(fgPARS.Data());
 975   if (!returnBool) return kFALSE;
 976
 977   // Input Data
 978   returnBool = utils->SetInputData((AliRsnUtils::EDataType)fgDataType,fgInputFileName,fgTreeName);
 979   if (!returnBool) return kFALSE;
 980
 981   // runs macro
 982   if (fgMacro.IsNull()) {
 983     utils->PrintErrorString("fgMacro is null");
 984     return kFALSE;
 985   }
 986   utils->Run(fgMacro.Data(),fgNumOfEvents,fgNumOfEventsSkip);
 987   return returnBool;
 988 }
 989
 990 Bool_t runAlien()
 991 {
 992   Bool_t returnBool = kTRUE;
 993
 994   // creating utils (located in macro PWG2resonancesUtils.C)
 995   AliRsnUtils *utils = new AliRsnUtils ( AliRsnUtils::kAlien,fgAlienShouldRun,fgAlienShoudlCopy,fgJDL);
 996   utils->DoMixing(fgDoMixing);
 997
 998   // Loading pars
 999   if (fgUseLocalLibs) {
1000     returnBool = runLocalLibs(fgPARS.Data());
1001     if (!returnBool) return kFALSE;
1002   }
1003   returnBool = utils->LoadPars(fgPARS.Data(),!fgUseLocalLibs);
1004   if (!returnBool) return kFALSE;
1005
1006   // Input Data
1007   returnBool = utils->SetInputData((AliRsnUtils::EDataType)fgDataType,fgInputFileName,fgTreeName);
1008   if (!returnBool) return kFALSE;
1009
1010
1011   // set Directory in AliEn where all files will be copied first
1012   // WARNING this directory will be removed first when fgAlienShoudlCopy
1013   // in AliRsnUtils constructor is set to kTRUE and it is done by default
1014 //   utils->SetAlienProjectDir("/alice/cern.ch/user/m/mvala/RSNTASK/FILTER/28001");
1015   utils->SetAlienProjectDir(fgProjectDir.Data());
1016   // sets pname string (Project dir) for JDL setup
1017 //     TString pname(utils->GetAlienProjectDir());
1018
1019   if (fgMacro.IsNull()) {
1020     utils->PrintErrorString("fgMacro is null");
1021     return kFALSE;
1022   }
1023
1024   // not working
1025   if (!fgProjectDirSE.IsNull()) {
1026     utils->SetAlienProjectDirSE(fgProjectDirSE);
1027   }
1028
1029   //run AliEn job (if shouldRun is set to kTRUE, if not it will just copy files
1030   //if shouldCopy is set to kTRUE)
1031   utils->Run(fgMacro.Data(),fgNumOfEvents,fgNumOfEventsSkip);
1032
1033   // uncomment it when you wanna have
1034   // AliEn shell after job is submited
1035   //gGrid->Shell();
1036
1037   return returnBool;
1038 }
1039
1040 Bool_t runLocalLibs(TString pars,TString pathToAliRoot="$ALICE_ROOT/lib/tgt_$ALICE_TARGET")
1041 {
1042   Bool_t returnBool = kTRUE;
1043
1044   if (pars.IsNull()) return kTRUE;
1045
1046   gSystem->Load("libGeom.so");
1047
1048   TObjArray* array = pars.Tokenize(":");
1049   TObjString *str;
1050   TString strr;
1051   for (Int_t i=0;i< array->GetEntriesFast();i++) {
1052     str = (TObjString *) array->At(i);
1053     strr = str->GetString();
1054     Info("",Form("Loading %s ...",Form("%s/lib%s",gSystem->ExpandPathName(Form("%s",pathToAliRoot.Data())),strr.Data())));
1055     gSystem->Load(Form("%s/lib%s",gSystem->ExpandPathName(Form("%s",pathToAliRoot.Data())),strr.Data()));
1056   }
1057
1058
1059   return returnBool;
1060 }