PWG0/PWG0Helper.C

   1 /* $Id$ */
   2
   3 // Helper macros can be found in this file
   4 // A set of them can be used to connect to proof and execute selectors.
   5
   6 TProof* connectProof(const char* proofServer)
   7 {
   8   TProof* proof = TProof::Open(proofServer);
   9
  10   if (!proof)
  11   {
  12     printf("ERROR: PROOF connection not established.\n");
  13     return 0;
  14   }
  15
  16   // enable the new packetizer
  17   //proof->AddInput(new TNamed("PROOF_Packetizer", "TPacketizerProgressive"));
  18
  19   proof->ClearInput();
  20
  21   return proof;
  22 }
  23
  24 Bool_t prepareQuery(TString libraries, TString packages, Int_t useAliRoot)
  25 {
  26   // if not proof load libraries
  27   if (!gProof)
  28   {
  29     TObjArray* librariesList = libraries.Tokenize(";");
  30     for (Int_t i=0; i<librariesList->GetEntries(); ++i)
  31     {
  32       TObjString* str = dynamic_cast<TObjString*> (librariesList->At(i));
  33       if (!str)
  34         continue;
  35
  36       printf("Loading %s...", str->String().Data());
  37       Int_t result = CheckLoadLibrary(str->String());
  38       if (result < 0)
  39       {
  40         printf("failed\n");
  41         //return kFALSE;
  42       }
  43       else
  44         printf("succeeded\n");
  45     }
  46   }
  47   else
  48   {
  49     if (useAliRoot > 0)
  50       ProofEnableAliRoot(useAliRoot);
  51
  52     TObjArray* packagesList = packages.Tokenize(";");
  53     for (Int_t i=0; i<packagesList->GetEntries(); ++i)
  54     {
  55       TObjString* str = dynamic_cast<TObjString*> (packagesList->At(i));
  56       if (!str)
  57         continue;
  58
  59       /*if (!EnablePackageLocal(str->String()))
  60       {
  61         printf("Loading of package %s locally failed\n", str->String().Data());
  62         return kFALSE;
  63       }*/
  64
  65       if (gProof->UploadPackage(Form("%s.par", str->String().Data())))
  66       {
  67         printf("Uploading of package %s failed\n", str->String().Data());
  68         return kFALSE;
  69       }
  70
  71       if (gProof->EnablePackage(str->String()))
  72       {
  73         printf("Loading of package %s failed\n", str->String().Data());
  74         return kFALSE;
  75       }
  76     }
  77  }
  78
  79  return kTRUE;
  80 }
  81
  82 Int_t executeQuery(TChain* chain, TList* inputList, TString selectorName, const char* option = "", Long64_t entries = TChain::kBigNumber)
  83 {
  84   if (!gProof)
  85     chain->GetUserInfo()->AddAll(inputList);
  86   else
  87   {
  88     for (Int_t i=0; i<inputList->GetEntries(); ++i)
  89       gProof->AddInput(inputList->At(i));
  90   }
  91
  92   TStopwatch timer;
  93   timer.Start();
  94
  95   Long64_t result = -1;
  96
  97   if (gProof)
  98   {
  99     chain->SetProof();
 100     result = chain->Process(selectorName, option, entries);
 101   }
 102   else
 103     result = chain->Process(selectorName, option, entries);
 104
 105   if (result < 0)
 106     printf("ERROR: Executing process failed with %d.\n", result);
 107
 108   timer.Stop();
 109   timer.Print();
 110
 111   return result;
 112 }
 113
 114 const char* GetAliRootLocation(Int_t aliroot)
 115 {
 116   switch (aliroot)
 117   {
 118     case 1: return "/afs/cern.ch/alice/caf/sw/ALICE/$ROOTVERSIONTAG/v4-04-Release/slc4_ia32_gcc34/aliroot"; break;
 119     default: return 0;
 120   }
 121 }
 122
 123 void ProofEnableAliRoot(Int_t aliroot)
 124 {
 125   // enables a locally deployed AliRoot in a PROOF cluster
 126
 127   /* executes the following commands on each node:
 128      gSystem->Setenv("ALICE_ROOT", "/home/alicecaf/ALICE/aliroot-head")
 129      gSystem->AddIncludePath("/home/alicecaf/ALICE/aliroot-head/include");
 130      gSystem->SetDynamicPath(Form("%s:%s", gSystem->GetDynamicPath(), "/home/alicecaf/ALICE/aliroot-head/lib/tgt_linux"))
 131      gSystem->Load("libMinuit");
 132      gROOT->Macro("$ALICE_ROOT/macros/loadlibs.C");
 133   */
 134
 135   const char* location = GetAliRootLocation(aliroot);
 136         const char* target = "tgt_linux";
 137
 138   gProof->Exec(Form("TString str(gSystem->ExpandPathName(\"%s\")); gSystem->Setenv(\"ALICE_ROOT\", str);", location), kTRUE);
 139
 140   gProof->AddIncludePath(Form("%s/include", location));
 141   gProof->AddDynamicPath(Form("%s/lib/%s", location, target));
 142
 143   // load all libraries
 144   gProof->Exec("gROOT->Macro(\"$ALICE_ROOT/macros/loadlibs.C\")");
 145 }
 146
 147 void ProofAddAliRootIncludePath(Int_t aliroot, const char* dir)
 148 {
 149   // adds an include path inside the aliroot structure
 150
 151   const char* location = GetAliRootLocation(aliroot);
 152   gProof->AddIncludePath(Form("%s/%s", location, dir));
 153 }
 154
 155 Bool_t EnablePackageLocal(const char* package)
 156 {
 157   printf("Enabling package %s locally...\n", package);
 158
 159   TString currentDir(gSystem->pwd());
 160   if (!gSystem->cd(package))
 161     return kFALSE;
 162
 163   gROOT->ProcessLine(".x PROOF-INF/SETUP.C");
 164   gSystem->cd(currentDir);
 165
 166   return kTRUE;
 167 }
 168
 169 Int_t CheckLoadLibrary(const char* library)
 170 {
 171   // checks if a library is already loaded, if not loads the library
 172
 173   if (strlen(gSystem->GetLibraries(Form("%s.so", library), "", kFALSE)) > 0)
 174     return 1;
 175
 176   return gSystem->Load(library);
 177 }
 178
 179 void redeployPackages(const char* proofServer, Bool_t localAliRoot = kTRUE)
 180 {
 181   // deploys PWG0base and PWG0dep (the latter only when localAliRoot is true) that are expected in $ALICE_ROOT
 182   // when localAliRoot is false ESD.par is also deployed
 183
 184   TProof::Reset(proofServer);
 185   TVirtualProof* proof = TProof::Open(proofServer);
 186   proof->ClearPackages();
 187
 188   if (localAliRoot)
 189     ProofEnableAliRoot();
 190   else
 191   {
 192     proof->UploadPackage("$ALICE_ROOT/ESD.par");
 193     proof->EnablePackage("ESD");
 194   }
 195
 196   proof->UploadPackage("$ALICE_ROOT/PWG0base.par");
 197   proof->EnablePackage("PWG0base");
 198
 199   proof->UploadPackage("$ALICE_ROOT/PWG0dep.par");
 200   proof->EnablePackage("PWG0dep");
 201 }